From 10a0a8de42267d574a9865bd13150f3dcb476187 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 12 Sep 2026 14:53:37 +0900 Subject: [PATCH 01/27] Make bearing a clockwise map rotation (#5) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Make bearing a clockwise map rotation bearing を「値を増やすと地図が時計回りに回る」向きに統一し、ネイティブ SDK との変換をコアの CameraBearing に集約する。 * ci: build the core module from the matching branch コアの未マージ/未リリースな変更に追随する PR を、コアが先に取り込まれるのを待たずに検証できるようにする。同名ブランチが無ければ従来どおり既定のコアを使う。 * fix: point material3 at its own version line material3 は compose-ui とは別のバージョン系列で、composeLibs(1.7.8)を流用すると存在しない material3:1.7.8 を要求して sample-app のクラスパスごと解決に失敗する。集約ビルド(android-sdk)の catalog と同じ 1.4.0 に合わせる。 --- .github/workflows/build.yml | 25 +++++++++++++++++-- gradle/libs.versions.toml | 5 +++- .../mapconductor/mappls/MapCameraPosition.kt | 11 ++++---- 3 files changed, 33 insertions(+), 8 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 79f872f..f0d3bb0 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -38,8 +38,29 @@ jobs: cache: 'gradle' - name: Build core and compose locally + env: + HEAD_REF: ${{ github.head_ref }} run: | - git clone --depth 1 https://github.com/MapConductor/android-sdk-core.git _core + # コア側に PR と同名のブランチがあるなら、そちらを組む。 + # + # ここを default ブランチ固定にしていると、**コアの未マージな変更に追随する + # PR は永久に赤いまま**になる。実際 CameraBearing をコアへ足したとき、 + # プロバイダ側の PR が 10 本まとめて Unresolved reference で落ちた。 + # コアが先にマージされるまで待つ、という運用は取り込み順の事故を呼ぶので、 + # 同名ブランチがあれば拾う形にしてある(無ければ従来どおり default)。 + clone_matching() { + repo="$1"; dir="$2" + url="https://github.com/MapConductor/$repo.git" + if [ -n "$HEAD_REF" ] && git ls-remote --exit-code --heads "$url" "$HEAD_REF" >/dev/null 2>&1; then + echo "$repo: matching branch $HEAD_REF" + git clone --depth 1 --branch "$HEAD_REF" "$url" "$dir" + else + echo "$repo: default branch" + git clone --depth 1 "$url" "$dir" + fi + } + + clone_matching android-sdk-core _core cd _core ./gradlew --no-daemon publishToMavenLocal cd .. @@ -53,7 +74,7 @@ jobs: } EOF - git clone --depth 1 https://github.com/MapConductor/android-sdk-compose.git _compose + clone_matching android-sdk-compose _compose cd _compose ./gradlew --no-daemon publishToMavenLocal cd .. diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index dfa0ddf..1f9ef83 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -1,5 +1,8 @@ [versions] composeLibs = "1.7.8" +# material3 は compose-ui とは別のバージョン系列。composeLibs(ui 系)を流用すると +# 存在しない material3:1.7.8 を要求してクラスパスごと解決に失敗する。 +material3 = "1.4.0" mapplsSdk = "9.0.3" coroutines = "1.9.0" agp = "9.2.1" @@ -37,7 +40,7 @@ play-services-maps = { module = "com.google.android.gms:play-services-maps", ver # Sample app androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" } -androidx-material3 = { group = "androidx.compose.material3", name = "material3", version.ref = "composeLibs" } +androidx-material3 = { group = "androidx.compose.material3", name = "material3", version.ref = "material3" } androidx-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling", version.ref = "composeLibs" } # Test diff --git a/src/main/java/com/mapconductor/mappls/MapCameraPosition.kt b/src/main/java/com/mapconductor/mappls/MapCameraPosition.kt index fb61f11..c17ae2f 100644 --- a/src/main/java/com/mapconductor/mappls/MapCameraPosition.kt +++ b/src/main/java/com/mapconductor/mappls/MapCameraPosition.kt @@ -1,6 +1,7 @@ package com.mapconductor.mappls import com.mapconductor.core.features.GeoPoint +import com.mapconductor.core.map.CameraBearing import com.mapconductor.core.map.MapCameraPosition import com.mapconductor.core.map.MapCameraPositionInterface import com.mapconductor.core.spherical.Spherical @@ -21,7 +22,7 @@ fun MapCameraPosition.toCameraPosition(): CameraPosition { .target(GeoPoint.from(position).toLatLng()) .zoom(ZoomAltitudeConverter.googleZoomToMapplsZoom(zoom)) .tilt(tilt) - .bearing(bearing) + .bearing(CameraBearing.toNativeHeading(bearing)) // TODO: // .padding(paddings?.toEdgeInsects()) .build() @@ -37,7 +38,7 @@ fun MapCameraPosition.toCameraPosition(): CameraPosition { cos(tiltAbsRad) * tan(tiltAbsRad) * NEGATIVE_TILT_TARGET_DISTANCE_SCALE - val target = Spherical.computeOffset(position, distanceForward, bearing) + val target = Spherical.computeOffset(position, distanceForward, CameraBearing.toNativeHeading(bearing)) val adjustedZoom = zoom + NEGATIVE_TILT_ZOOM_OFFSET_AT_MAX_TILT * (tiltAbsDeg / 60.0) return CameraPosition @@ -45,7 +46,7 @@ fun MapCameraPosition.toCameraPosition(): CameraPosition { .target(target.toLatLng()) .zoom(ZoomAltitudeConverter.googleZoomToMapplsZoom(adjustedZoom)) .tilt(tiltAbsDeg) - .bearing(bearing) + .bearing(CameraBearing.toNativeHeading(bearing)) // TODO: // .padding(paddings?.toEdgeInsects()) .build() @@ -82,7 +83,7 @@ internal fun CameraPosition.toMapCameraPosition(logicalTiltHint: Double?): MapCa return MapCameraPosition( position = target?.toGeoPoint() ?: GeoPoint.fromLongLat(0.0, 0.0), zoom = ZoomAltitudeConverter.mapplsZoomToGoogleZoom(zoom), - bearing = bearing, + bearing = CameraBearing.bearingFromNativeHeading(bearing), tilt = pitch, visibleRegion = null, ) @@ -104,7 +105,7 @@ internal fun CameraPosition.toMapCameraPosition(logicalTiltHint: Double?): MapCa return MapCameraPosition( position = originalPosition, zoom = originalGoogleZoom, - bearing = bear, + bearing = CameraBearing.bearingFromNativeHeading(bear), tilt = -pitchAbsDeg, visibleRegion = null, ) From 7951b9b004d041f6b899e3148c0c9ea244c51454 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Mon, 21 Sep 2026 23:44:25 +0900 Subject: [PATCH 02/27] Pass declutterPx through to the marker tile renderer MarkerTilingOptions.declutterPx existed and samples set it, but every controller dropped it on the floor when constructing MarkerTileRenderer, so the renderer ran with 0 and drew every marker on every tile. On a slow device that is the difference between an overview tile costing 538ms and 79ms (SO-02L, 144k markers, z10, MarkerTileRenderBenchmark) -- and the drawn result now actually matches what iOS and react show for the same options. --- .../mappls/marker/MapplsMarkerController.kt | 637 +++++++++--------- 1 file changed, 319 insertions(+), 318 deletions(-) diff --git a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt index 8c8ee8d..1ff4d72 100644 --- a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt +++ b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt @@ -1,318 +1,319 @@ -package com.mapconductor.mappls.marker - -import com.mapconductor.core.controller.OnCameraChangeReceiverInterface -import com.mapconductor.core.map.MapCameraPosition -import com.mapconductor.core.marker.AbstractMarkerController -import com.mapconductor.core.marker.BitmapIcon -import com.mapconductor.core.marker.DefaultMarkerIcon -import com.mapconductor.core.marker.MarkerEntity -import com.mapconductor.core.marker.MarkerEntityInterface -import com.mapconductor.core.marker.MarkerIngestionEngine -import com.mapconductor.core.marker.MarkerOverlayRendererInterface -import com.mapconductor.core.marker.MarkerState -import com.mapconductor.core.marker.MarkerTileRasterLayerCallback -import com.mapconductor.core.marker.MarkerTileRenderer -import com.mapconductor.core.marker.MarkerTilingOptions -import com.mapconductor.core.marker.MarkerViewportSwitch -import com.mapconductor.core.raster.RasterLayerSource -import com.mapconductor.core.raster.RasterLayerState -import com.mapconductor.core.raster.TileScheme -import com.mapconductor.core.tileserver.TileServerRegistry -import com.mapconductor.mappls.MapplsActualMarker -import java.util.UUID -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.launch -import kotlinx.coroutines.sync.withPermit - -class MapplsMarkerController( - renderer: MapplsMarkerOverlayRenderer, - private val markerTiling: MarkerTilingOptions = MarkerTilingOptions.Default, - private val coroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), -) : AbstractMarkerController( - markerManager = renderer.markerManager, - renderer = renderer, - ), - OnCameraChangeReceiverInterface { - private val defaultMarkerIcon: BitmapIcon = DefaultMarkerIcon().toBitmapIcon() - private val tiledMarkerIds = LinkedHashSet() - - private lateinit var lastCameraPosition: MapCameraPosition - - private val tileServer = TileServerRegistry.get() - private var markerTileRenderer: MarkerTileRenderer? = null - private var markerTileGroupId: String? = null - private var markerTileRasterLayerState: RasterLayerState? = null - private var rasterLayerCallback: MarkerTileRasterLayerCallback? = null - private var cacheVersion: Int = 0 - - /** - * ビューポート内が少ないときだけタイルをやめてネイティブマーカーで描く切り替え器。 - * - * レンダラ/マネージャ/semaphore を共有するので、コントローラと同じ排他の下で動く。 - */ - private val viewportSwitch = - MarkerViewportSwitch( - markerManager = markerManager, - renderer = renderer, - defaultMarkerIcon = defaultMarkerIcon, - semaphore = semaphore, - policy = markerTiling.viewport, - setTileLayerVisible = ::setTileLayerVisible, - invalidateTiles = ::updateRasterLayerSource, - ) - - fun setRasterLayerCallback(callback: MarkerTileRasterLayerCallback?) { - rasterLayerCallback = callback - } - - override suspend fun add(data: List) { - // ingest はタイル担当 entity を marker = null で登録し直すので、先に昇格を戻す。 - // semaphore は再入不可なので withPermit の外で呼ぶこと。 - viewportSwitch.retract() - semaphore.withPermit { - val tilingEnabled = - markerTiling.enabled && data.size >= markerManager.minMarkerCount - val result = - MarkerIngestionEngine.ingest( - data = data, - markerManager = markerManager, - renderer = renderer, - defaultMarkerIcon = defaultMarkerIcon, - tilingEnabled = tilingEnabled, - tiledMarkerIds = tiledMarkerIds, - shouldTile = { state -> !state.draggable && state.getAnimation() == null }, - ) - - if (result.tiledDataChanged) { - syncTiledOverlay() - } else if (result.hasTiledMarkers) { - if (markerTileRenderer == null || markerTileRasterLayerState == null) { - syncTiledOverlay() - } - } else { - removeTileOverlay() - } - } - viewportSwitch.requestReapply() - } - - override suspend fun update(state: MarkerState) { - if (!markerManager.hasEntity(state.id)) return - - // 昇格中の 1 件なら先に取り下げる(下で marker = null 登録があるため)。 - // 昇格していないマーカー(ドラッグ中など)では何もしないので、ドラッグは素通りする。 - if (viewportSwitch.isPromoted(state.id)) viewportSwitch.release(state.id) - - val prevEntity = markerManager.getEntity(state.id) ?: return - val currentFinger = state.fingerPrint() - val prevFinger = prevEntity.fingerPrint - if (currentFinger == prevFinger) return - - semaphore.withPermit { - val tilingEnabled = - markerTiling.enabled && markerManager.allEntities().size >= markerManager.minMarkerCount - val wantsTiled = tilingEnabled && !state.draggable && state.getAnimation() == null - val wasTiled = tiledMarkerIds.contains(state.id) - val markerIcon = state.icon?.toBitmapIcon() ?: defaultMarkerIcon - - if (wantsTiled) { - if (!wasTiled) { - prevEntity.marker?.let { renderer.onRemove(listOf(prevEntity)) } - tiledMarkerIds.add(state.id) - } - markerManager.updateEntity( - MarkerEntity( - marker = null, - state = state, - visible = prevEntity.visible, - isRendered = true, - // tiling を立てないと MarkerTileRenderer の絞り込みから漏れ、 - // タイル昇格したのにタイルへ描かれないマーカーになる。 - tiling = true, - ), - ) - renderer.onPostProcess() - syncTiledOverlay() - return@withPermit - } - - if (wasTiled) { - tiledMarkerIds.remove(state.id) - } - - val params = - object : MarkerOverlayRendererInterface.ChangeParamsInterface { - override val current: MarkerEntityInterface = - MarkerEntity( - marker = prevEntity.marker, - state = state, - visible = prevEntity.visible, - isRendered = true, - ) - override val bitmapIcon: BitmapIcon = markerIcon - override val prev: MarkerEntityInterface = prevEntity - } - val markers = renderer.onChange(listOf(params)) - markers.firstOrNull()?.let { actual -> - markerManager.updateEntity( - MarkerEntity( - marker = actual, - state = state, - visible = prevEntity.visible, - isRendered = true, - ), - ) - if (prevFinger.animation != currentFinger.animation) { - state.getAnimation()?.let { renderer.onAnimate(markerManager.getEntity(state.id)!!) } - } - } - renderer.onPostProcess() - - if (tiledMarkerIds.isNotEmpty()) { - syncTiledOverlay() - } else { - removeTileOverlay() - } - } - viewportSwitch.requestReapply() - } - - override suspend fun clear() { - viewportSwitch.destroy() - semaphore.withPermit { - val entities = markerManager.allEntities() - val toRemove = entities.filter { it.marker != null } - if (toRemove.isNotEmpty()) { - renderer.onRemove(toRemove) - } - markerManager.clear() - tiledMarkerIds.clear() - removeTileOverlay() - } - } - - override suspend fun onCameraChanged(mapCameraPosition: MapCameraPosition) { - lastCameraPosition = mapCameraPosition - // 判定と昇格は debounce したうえで切り替え器の中で走る(パン中は動かない)。 - viewportSwitch.onCameraChanged(mapCameraPosition) - } - - /** - * マーカータイルのラスターレイヤの表示だけを切り替える。 - * - * source(URL)には触らない。触るとタイルを取り直すことになり、切り替えのたびに - * タイルキャッシュを捨てるのと同じになる。 - */ - private suspend fun setTileLayerVisible(visible: Boolean) { - val current = markerTileRasterLayerState ?: return - if (current.visible == visible) return - val newState = current.copy(visible = visible) - markerTileRasterLayerState = newState - rasterLayerCallback?.onRasterLayerUpdate(newState) - } - - override fun destroy() { - viewportSwitch.destroy() - // Clean up tile server registration - // Unregister this map's route only. Never stop the server here: it is - // a process-wide singleton shared by all map controllers and overlay - // modules; stopping it breaks tile loading for every other live map. - markerTileGroupId?.let { groupId -> - tileServer.unregister(groupId) - } - markerTileGroupId = null - markerTileRenderer = null - - coroutine.launch { - rasterLayerCallback?.onRasterLayerUpdate(null) - } - markerTileRasterLayerState = null - super.destroy() - } - - private suspend fun updateRasterLayerSource() { - val groupId = markerTileGroupId ?: return - val tileRenderer = markerTileRenderer ?: return - val oldState = markerTileRasterLayerState ?: return - cacheVersion = (cacheVersion + 1) and 0x7fffffff - tileRenderer.invalidate() - - val newState = - oldState.copy( - source = - RasterLayerSource.UrlTemplate( - template = "${tileServer.urlTemplate(groupId, tileRenderer.tileSize)}?v=$cacheVersion", - tileSize = tileRenderer.tileSize, - maxZoom = 22, - scheme = TileScheme.XYZ, - ), - id = oldState.id, - ) - markerTileRasterLayerState = newState - rasterLayerCallback?.onRasterLayerUpdate(newState) - } - - private suspend fun syncTiledOverlay() { - if (tiledMarkerIds.isEmpty()) { - removeTileOverlay() - return - } - if (!markerTiling.enabled) { - removeTileOverlay() - tiledMarkerIds.clear() - return - } - - getOrCreateTileRenderer() - updateRasterLayerSource() - } - - private fun getOrCreateTileRenderer(): MarkerTileRenderer { - synchronized(this) { - markerTileRenderer?.let { return it } - - val groupId = UUID.randomUUID().toString() - markerTileGroupId = groupId - - val tileRenderer = - MarkerTileRenderer( - markerManager = markerManager, - tileSize = 256, - cacheSizeBytes = markerTiling.cacheSize, - debugTileOverlay = markerTiling.debugTileOverlay, - iconScaleCallback = markerTiling.iconScaleCallback, - ) - markerTileRenderer = tileRenderer - - tileServer.register(groupId, tileRenderer) - - markerTileRasterLayerState = - RasterLayerState( - id = "marker-tile-$groupId", - source = - RasterLayerSource.UrlTemplate( - template = tileServer.urlTemplate(groupId, tileRenderer.tileSize), - tileSize = tileRenderer.tileSize, - maxZoom = 22, - scheme = TileScheme.XYZ, - ), - opacity = 1.0f, - visible = true, - ) - - return tileRenderer - } - } - - private suspend fun removeTileOverlay() { - markerTileGroupId?.let { groupId -> - tileServer.unregister(groupId) - } - markerTileGroupId = null - markerTileRenderer = null - - rasterLayerCallback?.onRasterLayerUpdate(null) - markerTileRasterLayerState = null - } -} +package com.mapconductor.mappls.marker + +import com.mapconductor.core.controller.OnCameraChangeReceiverInterface +import com.mapconductor.core.map.MapCameraPosition +import com.mapconductor.core.marker.AbstractMarkerController +import com.mapconductor.core.marker.BitmapIcon +import com.mapconductor.core.marker.DefaultMarkerIcon +import com.mapconductor.core.marker.MarkerEntity +import com.mapconductor.core.marker.MarkerEntityInterface +import com.mapconductor.core.marker.MarkerIngestionEngine +import com.mapconductor.core.marker.MarkerOverlayRendererInterface +import com.mapconductor.core.marker.MarkerState +import com.mapconductor.core.marker.MarkerTileRasterLayerCallback +import com.mapconductor.core.marker.MarkerTileRenderer +import com.mapconductor.core.marker.MarkerTilingOptions +import com.mapconductor.core.marker.MarkerViewportSwitch +import com.mapconductor.core.raster.RasterLayerSource +import com.mapconductor.core.raster.RasterLayerState +import com.mapconductor.core.raster.TileScheme +import com.mapconductor.core.tileserver.TileServerRegistry +import com.mapconductor.mappls.MapplsActualMarker +import java.util.UUID +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.sync.withPermit + +class MapplsMarkerController( + renderer: MapplsMarkerOverlayRenderer, + private val markerTiling: MarkerTilingOptions = MarkerTilingOptions.Default, + private val coroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), +) : AbstractMarkerController( + markerManager = renderer.markerManager, + renderer = renderer, + ), + OnCameraChangeReceiverInterface { + private val defaultMarkerIcon: BitmapIcon = DefaultMarkerIcon().toBitmapIcon() + private val tiledMarkerIds = LinkedHashSet() + + private lateinit var lastCameraPosition: MapCameraPosition + + private val tileServer = TileServerRegistry.get() + private var markerTileRenderer: MarkerTileRenderer? = null + private var markerTileGroupId: String? = null + private var markerTileRasterLayerState: RasterLayerState? = null + private var rasterLayerCallback: MarkerTileRasterLayerCallback? = null + private var cacheVersion: Int = 0 + + /** + * ビューポート内が少ないときだけタイルをやめてネイティブマーカーで描く切り替え器。 + * + * レンダラ/マネージャ/semaphore を共有するので、コントローラと同じ排他の下で動く。 + */ + private val viewportSwitch = + MarkerViewportSwitch( + markerManager = markerManager, + renderer = renderer, + defaultMarkerIcon = defaultMarkerIcon, + semaphore = semaphore, + policy = markerTiling.viewport, + setTileLayerVisible = ::setTileLayerVisible, + invalidateTiles = ::updateRasterLayerSource, + ) + + fun setRasterLayerCallback(callback: MarkerTileRasterLayerCallback?) { + rasterLayerCallback = callback + } + + override suspend fun add(data: List) { + // ingest はタイル担当 entity を marker = null で登録し直すので、先に昇格を戻す。 + // semaphore は再入不可なので withPermit の外で呼ぶこと。 + viewportSwitch.retract() + semaphore.withPermit { + val tilingEnabled = + markerTiling.enabled && data.size >= markerManager.minMarkerCount + val result = + MarkerIngestionEngine.ingest( + data = data, + markerManager = markerManager, + renderer = renderer, + defaultMarkerIcon = defaultMarkerIcon, + tilingEnabled = tilingEnabled, + tiledMarkerIds = tiledMarkerIds, + shouldTile = { state -> !state.draggable && state.getAnimation() == null }, + ) + + if (result.tiledDataChanged) { + syncTiledOverlay() + } else if (result.hasTiledMarkers) { + if (markerTileRenderer == null || markerTileRasterLayerState == null) { + syncTiledOverlay() + } + } else { + removeTileOverlay() + } + } + viewportSwitch.requestReapply() + } + + override suspend fun update(state: MarkerState) { + if (!markerManager.hasEntity(state.id)) return + + // 昇格中の 1 件なら先に取り下げる(下で marker = null 登録があるため)。 + // 昇格していないマーカー(ドラッグ中など)では何もしないので、ドラッグは素通りする。 + if (viewportSwitch.isPromoted(state.id)) viewportSwitch.release(state.id) + + val prevEntity = markerManager.getEntity(state.id) ?: return + val currentFinger = state.fingerPrint() + val prevFinger = prevEntity.fingerPrint + if (currentFinger == prevFinger) return + + semaphore.withPermit { + val tilingEnabled = + markerTiling.enabled && markerManager.allEntities().size >= markerManager.minMarkerCount + val wantsTiled = tilingEnabled && !state.draggable && state.getAnimation() == null + val wasTiled = tiledMarkerIds.contains(state.id) + val markerIcon = state.icon?.toBitmapIcon() ?: defaultMarkerIcon + + if (wantsTiled) { + if (!wasTiled) { + prevEntity.marker?.let { renderer.onRemove(listOf(prevEntity)) } + tiledMarkerIds.add(state.id) + } + markerManager.updateEntity( + MarkerEntity( + marker = null, + state = state, + visible = prevEntity.visible, + isRendered = true, + // tiling を立てないと MarkerTileRenderer の絞り込みから漏れ、 + // タイル昇格したのにタイルへ描かれないマーカーになる。 + tiling = true, + ), + ) + renderer.onPostProcess() + syncTiledOverlay() + return@withPermit + } + + if (wasTiled) { + tiledMarkerIds.remove(state.id) + } + + val params = + object : MarkerOverlayRendererInterface.ChangeParamsInterface { + override val current: MarkerEntityInterface = + MarkerEntity( + marker = prevEntity.marker, + state = state, + visible = prevEntity.visible, + isRendered = true, + ) + override val bitmapIcon: BitmapIcon = markerIcon + override val prev: MarkerEntityInterface = prevEntity + } + val markers = renderer.onChange(listOf(params)) + markers.firstOrNull()?.let { actual -> + markerManager.updateEntity( + MarkerEntity( + marker = actual, + state = state, + visible = prevEntity.visible, + isRendered = true, + ), + ) + if (prevFinger.animation != currentFinger.animation) { + state.getAnimation()?.let { renderer.onAnimate(markerManager.getEntity(state.id)!!) } + } + } + renderer.onPostProcess() + + if (tiledMarkerIds.isNotEmpty()) { + syncTiledOverlay() + } else { + removeTileOverlay() + } + } + viewportSwitch.requestReapply() + } + + override suspend fun clear() { + viewportSwitch.destroy() + semaphore.withPermit { + val entities = markerManager.allEntities() + val toRemove = entities.filter { it.marker != null } + if (toRemove.isNotEmpty()) { + renderer.onRemove(toRemove) + } + markerManager.clear() + tiledMarkerIds.clear() + removeTileOverlay() + } + } + + override suspend fun onCameraChanged(mapCameraPosition: MapCameraPosition) { + lastCameraPosition = mapCameraPosition + // 判定と昇格は debounce したうえで切り替え器の中で走る(パン中は動かない)。 + viewportSwitch.onCameraChanged(mapCameraPosition) + } + + /** + * マーカータイルのラスターレイヤの表示だけを切り替える。 + * + * source(URL)には触らない。触るとタイルを取り直すことになり、切り替えのたびに + * タイルキャッシュを捨てるのと同じになる。 + */ + private suspend fun setTileLayerVisible(visible: Boolean) { + val current = markerTileRasterLayerState ?: return + if (current.visible == visible) return + val newState = current.copy(visible = visible) + markerTileRasterLayerState = newState + rasterLayerCallback?.onRasterLayerUpdate(newState) + } + + override fun destroy() { + viewportSwitch.destroy() + // Clean up tile server registration + // Unregister this map's route only. Never stop the server here: it is + // a process-wide singleton shared by all map controllers and overlay + // modules; stopping it breaks tile loading for every other live map. + markerTileGroupId?.let { groupId -> + tileServer.unregister(groupId) + } + markerTileGroupId = null + markerTileRenderer = null + + coroutine.launch { + rasterLayerCallback?.onRasterLayerUpdate(null) + } + markerTileRasterLayerState = null + super.destroy() + } + + private suspend fun updateRasterLayerSource() { + val groupId = markerTileGroupId ?: return + val tileRenderer = markerTileRenderer ?: return + val oldState = markerTileRasterLayerState ?: return + cacheVersion = (cacheVersion + 1) and 0x7fffffff + tileRenderer.invalidate() + + val newState = + oldState.copy( + source = + RasterLayerSource.UrlTemplate( + template = "${tileServer.urlTemplate(groupId, tileRenderer.tileSize)}?v=$cacheVersion", + tileSize = tileRenderer.tileSize, + maxZoom = 22, + scheme = TileScheme.XYZ, + ), + id = oldState.id, + ) + markerTileRasterLayerState = newState + rasterLayerCallback?.onRasterLayerUpdate(newState) + } + + private suspend fun syncTiledOverlay() { + if (tiledMarkerIds.isEmpty()) { + removeTileOverlay() + return + } + if (!markerTiling.enabled) { + removeTileOverlay() + tiledMarkerIds.clear() + return + } + + getOrCreateTileRenderer() + updateRasterLayerSource() + } + + private fun getOrCreateTileRenderer(): MarkerTileRenderer { + synchronized(this) { + markerTileRenderer?.let { return it } + + val groupId = UUID.randomUUID().toString() + markerTileGroupId = groupId + + val tileRenderer = + MarkerTileRenderer( + markerManager = markerManager, + tileSize = 256, + cacheSizeBytes = markerTiling.cacheSize, + debugTileOverlay = markerTiling.debugTileOverlay, + iconScaleCallback = markerTiling.iconScaleCallback, + declutterPx = markerTiling.declutterPx, + ) + markerTileRenderer = tileRenderer + + tileServer.register(groupId, tileRenderer) + + markerTileRasterLayerState = + RasterLayerState( + id = "marker-tile-$groupId", + source = + RasterLayerSource.UrlTemplate( + template = tileServer.urlTemplate(groupId, tileRenderer.tileSize), + tileSize = tileRenderer.tileSize, + maxZoom = 22, + scheme = TileScheme.XYZ, + ), + opacity = 1.0f, + visible = true, + ) + + return tileRenderer + } + } + + private suspend fun removeTileOverlay() { + markerTileGroupId?.let { groupId -> + tileServer.unregister(groupId) + } + markerTileGroupId = null + markerTileRenderer = null + + rasterLayerCallback?.onRasterLayerUpdate(null) + markerTileRasterLayerState = null + } +} From 6f8ee2787ec50c8449251462fcb662d4238fbedf Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 26 Sep 2026 22:26:14 -0700 Subject: [PATCH 03/27] Put raster overlays under the basemap's labels A raster overlay was appended at the top of the style, above the place names, road names and shields the backend draws. The vector tile sample showed what that costs: our own roads run straight through the district names, which reads as "the labels are drawn under the lines". A heatmap or a satellite layer hid them outright. Anchoring to the style's first symbol layer puts the overlay above the basemap's geometry and below its labels, which is where a tile overlay belongs. Inserting successive layers below the same anchor preserves their order, so the z-order among our own raster layers is unchanged. Our own layers are skipped when looking for the anchor: markers are a symbol layer too, and anchoring to them would put the raster back above the labels -- and only once a marker existed. Marker tiles keep their own rule (below the marker symbol layer), so native markers still draw above everything. --- .../MapplsRasterLayerOverlayRenderer.kt | 50 ++++++++++++++++++- 1 file changed, 48 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt index 92eff24..60512e3 100644 --- a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt @@ -97,7 +97,7 @@ class MapplsRasterLayerOverlayRenderer( if (isMarkerTileRaster(state)) { addLayerForMarkerTile(style, layer) } else { - style.addLayer(layer) + addBelowBasemapLabels(style, layer) } } catch (e: Exception) { Log.w("Mappls", "Failed to add raster layer: ${e.message}") @@ -181,12 +181,58 @@ class MapplsRasterLayerOverlayRenderer( ), ) try { - style.addLayer(layer) + addBelowBasemapLabels(style, layer) } catch (_: Exception) { } } } + /** + * Puts a raster layer above the basemap's geometry but **below its labels**. + * + * Appended at the top of the style instead, a raster overlay covers the + * place names, road names and shields the backend draws -- a vector tile + * layer's own roads run straight through them, which is what "the labels + * are under the lines" looks like. Every raster overlay we add has the + * same problem, so the rule lives here rather than in each of them. + * + * Inserting successive layers below the same anchor keeps their order: + * each one lands directly below the anchor, which is directly above the + * one inserted before it. + * + * Anything of ours is skipped when looking for the anchor. Markers are a + * symbol layer too, and anchoring to them would put the raster back above + * the labels -- with the added twist of only doing so once a marker exists. + */ + private fun addBelowBasemapLabels( + style: com.mappls.sdk.maps.Style, + layer: com.mappls.sdk.maps.style.layers.Layer, + ) { + val anchor = + style.layers.firstOrNull { + it is com.mappls.sdk.maps.style.layers.SymbolLayer && !isOursById(it.id) + } + if (anchor == null) { + style.addLayer(layer) + return + } + try { + style.addLayerBelow(layer, anchor.id) + } catch (_: Exception) { + style.addLayer(layer) + } + } + + /** True for layers this SDK adds, as opposed to the design's own. */ + private fun isOursById(id: String): Boolean = + id.startsWith("raster-layer-") || + id.startsWith("org.maplibre.annotations") || + id.startsWith("com.mappls.annotations") || + id.startsWith(MARKERS_LAYER_ID) || + id.startsWith("marker-drag-layer") || + id.startsWith(POLYLINE_LAYER_ID) || + id.startsWith("circle-layer") + private fun buildSource( sourceId: String, source: RasterLayerSource, From acf8da8d6da9eff531361b1a10a8108df91d8331 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Mon, 5 Oct 2026 14:53:15 -0700 Subject: [PATCH 04/27] update dependencies (#6) --- gradle.properties | 2 +- gradle/libs.versions.toml | 22 +++++++++++----------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/gradle.properties b/gradle.properties index 26d9949..c018eb9 100644 --- a/gradle.properties +++ b/gradle.properties @@ -3,7 +3,7 @@ android.useAndroidX=true kotlin.code.style=official android.nonTransitiveRClass=true -compileSdk=35 +compileSdk=37 minSdk=26 javaVersion=17 jvmTarget=17 diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 1f9ef83..30f9c02 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -1,19 +1,19 @@ [versions] -composeLibs = "1.7.8" +composeLibs = "1.12.1" # material3 は compose-ui とは別のバージョン系列。composeLibs(ui 系)を流用すると # 存在しない material3:1.7.8 を要求してクラスパスごと解決に失敗する。 material3 = "1.4.0" -mapplsSdk = "9.0.3" -coroutines = "1.9.0" -agp = "9.2.1" -kotlin = "2.0.21" - -composeBom = "2025.02.00" -coreKtx = "1.16.0" -lifecycleRuntimeKtx = "2.8.7" -okhttp = "5.3.2" +mapplsSdk = "9.0.4" +coroutines = "1.11.0" +agp = "9.4.1" +kotlin = "2.4.20" + +composeBom = "2026.09.00" +coreKtx = "1.19.1" +lifecycleRuntimeKtx = "2.11.0" +okhttp = "5.5.0" playServicesMaps = "20.0.0" -activityCompose = "1.9.3" +activityCompose = "1.13.0" ktLint = "14.2.0" junit = "4.13.2" From 45f71e66fc46ed51f85fe9d0093bcff824c1f4fa Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 24 Oct 2026 01:59:02 -0700 Subject: [PATCH 05/27] Update Play Services Maps to 20.1.0 and OkHttp to 5.5.1 (#7) --- gradle/libs.versions.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 30f9c02..0a9be4b 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -11,8 +11,8 @@ kotlin = "2.4.20" composeBom = "2026.09.00" coreKtx = "1.19.1" lifecycleRuntimeKtx = "2.11.0" -okhttp = "5.5.0" -playServicesMaps = "20.0.0" +okhttp = "5.5.1" +playServicesMaps = "20.1.0" activityCompose = "1.13.0" ktLint = "14.2.0" From de90ac88b2e937d11353b8bb06cb64255b94e5b8 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 24 Oct 2026 10:52:52 -0700 Subject: [PATCH 06/27] Vector style support (#8) * feat: integrate vector style support and pending map fixes * Keep each file's line endings as they are on develop The checkpoint commit rewrote whole files between LF and CRLF, which buried its real changes under line-ending noise. Content is unchanged. --- api/android-for-mappls.api | 2 +- build.gradle.kts | 8 ++++---- settings.gradle.kts | 1 - .../java/com/mapconductor/mappls/MapplsMapView.kt | 12 ++++++++++++ 4 files changed, 17 insertions(+), 6 deletions(-) diff --git a/api/android-for-mappls.api b/api/android-for-mappls.api index df63c9f..7e0bddd 100644 --- a/api/android-for-mappls.api +++ b/api/android-for-mappls.api @@ -86,7 +86,7 @@ public final class com.mapconductor.mappls.MapplsMapViewHolderInterface$DefaultI public static com.mapconductor.core.features.GeoPoint fromScreenOffsetSync-k-4lQ0M(com.mapconductor.mappls.MapplsMapViewHolderInterface, long); } public final class com.mapconductor.mappls.MapplsMapViewKt { - public static final void MapplsMapView(com.mapconductor.mappls.MapplsViewState, androidx.compose.ui.Modifier, com.mapconductor.core.marker.MarkerTilingOptions, com.mapconductor.core.map.CameraRestriction, kotlin.jvm.functions.Function2, ? extends java.lang.Object>, kotlin.jvm.functions.Function1, kotlin.Unit>, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function3, androidx.compose.runtime.Composer, int, int, int); + public static final void MapplsMapView(com.mapconductor.mappls.MapplsViewState, androidx.compose.ui.Modifier, com.mapconductor.core.marker.MarkerTilingOptions, com.mapconductor.core.map.CameraRestriction, kotlin.jvm.functions.Function2, ? extends java.lang.Object>, kotlin.jvm.functions.Function1, kotlin.Unit>, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, com.mapconductor.core.map.MapViewStyle, kotlin.jvm.functions.Function1, kotlin.Unit>, kotlin.jvm.functions.Function3, androidx.compose.runtime.Composer, int, int, int); public static final com.mapconductor.mappls.MapplsViewController createMapplsViewController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.marker.MarkerTilingOptions, com.mapconductor.core.map.MutableMapServiceRegistry); public static final com.mapconductor.mappls.marker.MapplsMarkerController getMarkerController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.marker.MarkerTilingOptions); public static final com.mapconductor.mappls.polyline.MapplsPolylineController getPolylineController(com.mapconductor.mappls.MapplsMapViewHolderInterface); diff --git a/build.gradle.kts b/build.gradle.kts index 4fd12f6..92281d1 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -84,7 +84,6 @@ dependencies { testImplementation(libs.junit) } - // Set project version for NMCP plugin version = libraryVersion val libraryName = "MapConductor for Mappls" @@ -92,9 +91,10 @@ val libraryDescription = "Mappls (MapmyIndia) implementation for MapConductor un // Gradle 9.6 で `by tasks.registering` は非推奨(スクリプトコンパイルエラーになる)。 // googlemaps 等の既存モジュールは古い形のままなので、再コンパイル時に同じ問題が出る。 -val javadocJar = tasks.register("javadocJar") { - archiveClassifier.set("javadoc") -} +val javadocJar = + tasks.register("javadocJar") { + archiveClassifier.set("javadoc") + } afterEvaluate { publishing { diff --git a/settings.gradle.kts b/settings.gradle.kts index 981619a..68da554 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -46,4 +46,3 @@ dependencyResolutionManagement { } rootProject.name = "android-for-mappls" - diff --git a/src/main/java/com/mapconductor/mappls/MapplsMapView.kt b/src/main/java/com/mapconductor/mappls/MapplsMapView.kt index 150f80e..862b41f 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsMapView.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsMapView.kt @@ -12,6 +12,7 @@ import com.mapconductor.core.OnMapLoadedHandler import com.mapconductor.core.circle.CircleManager import com.mapconductor.core.map.CameraRestriction import com.mapconductor.core.map.MapCameraPositionInterface +import com.mapconductor.core.map.MapViewStyle import com.mapconductor.core.map.MutableMapServiceRegistry import com.mapconductor.core.marker.MarkerEventControllerInterface import com.mapconductor.core.marker.MarkerManager @@ -65,6 +66,15 @@ fun MapplsMapView( onCameraMoveStart: OnCameraMoveHandler? = null, onCameraMove: OnCameraMoveHandler? = null, onCameraMoveEnd: OnCameraMoveHandler? = null, + /** + * How the map looks, when the app states it rather than naming a design. + * + * A vector style *is* the basemap. `com.mapconductor:vectorstyle` builds + * one; what happens underneath depends on this backend and the app does + * not have to know. + */ + style: MapViewStyle? = null, + onStyleDiagnostics: ((List) -> Unit)? = null, content: (@Composable MapplsMapViewScope.() -> Unit)? = null, ) { val context = LocalContext.current @@ -175,6 +185,8 @@ fun MapplsMapView( // Pass content if it needs to be rendered within the overlay providers in MapViewBase, // or handle it here if it's specific to MapplsMapView structure before calling MapViewBase. // For now, assuming content relates to overlay definitions. + style = style, + onStyleDiagnostics = onStyleDiagnostics, content = content, // This might need adjustment based on how overlays are handled ) } From 4e5599b1246199c4f1cd373953624dee432f69ab Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Wed, 28 Oct 2026 13:47:12 -0700 Subject: [PATCH 07/27] Add .claude/settings.json --- .claude/settings.json | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 .claude/settings.json diff --git a/.claude/settings.json b/.claude/settings.json new file mode 100644 index 0000000..671a084 --- /dev/null +++ b/.claude/settings.json @@ -0,0 +1,6 @@ +{ + "attribution": { + "commit": "", + "pr": "" + } +} From 7e655f796c5c8cd643bd7ab69a72aeae13e71d14 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Thu, 29 Oct 2026 01:37:56 -0700 Subject: [PATCH 08/27] Use the core reapplyStyle() for raster layers MapplsRasterLayerController.reapplyStyle() read the manager outside the controller lock and registered what it read again. Drop it and use the one in android-sdk-core's RasterLayerController (MapConductor/android-sdk-core#17), which runs under the lock. --- api/android-for-mappls.api | 1 - .../raster/MapplsRasterLayerController.kt | 25 ------------------- 2 files changed, 26 deletions(-) diff --git a/api/android-for-mappls.api b/api/android-for-mappls.api index 7e0bddd..31bc400 100644 --- a/api/android-for-mappls.api +++ b/api/android-for-mappls.api @@ -462,7 +462,6 @@ public final class com.mapconductor.mappls.raster.MapplsRasterLayerController ex public java.lang.Object update(com.mapconductor.core.raster.RasterLayerState, kotlin.coroutines.Continuation); public java.lang.Object clear(kotlin.coroutines.Continuation); public void destroy(); - public final java.lang.Object reapplyStyle(kotlin.coroutines.Continuation); public java.lang.Object update(java.lang.Object, kotlin.coroutines.Continuation); } public final class com.mapconductor.mappls.raster.MapplsRasterLayerHandle { diff --git a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerController.kt b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerController.kt index d75fad1..bc865f5 100644 --- a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerController.kt +++ b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerController.kt @@ -1,10 +1,8 @@ package com.mapconductor.mappls.raster import com.mapconductor.core.raster.RasterLayerController -import com.mapconductor.core.raster.RasterLayerEntity import com.mapconductor.core.raster.RasterLayerManager import com.mapconductor.core.raster.RasterLayerManagerInterface -import com.mapconductor.core.raster.RasterLayerOverlayRendererInterface import com.mapconductor.core.raster.RasterLayerState class MapplsRasterLayerController( @@ -35,27 +33,4 @@ class MapplsRasterLayerController( MapplsRasterHeaderInjector.remove(this) super.destroy() } - - suspend fun reapplyStyle() { - val states = rasterLayerManager.allEntities().map { it.state } - if (states.isEmpty()) return - val addParams = - states.map { state -> - object : RasterLayerOverlayRendererInterface.AddParamsInterface { - override val state: RasterLayerState = state - } - } - val layers = renderer.onAdd(addParams) - layers.forEachIndexed { index, layer -> - layer?.let { - rasterLayerManager.registerEntity( - RasterLayerEntity( - layer = it, - state = states[index], - ), - ) - } - } - renderer.onPostProcess() - } } From 131a70c1d0f1aefa437f1d08159c5b58c086b3b6 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Thu, 5 Nov 2026 14:58:14 -0800 Subject: [PATCH 09/27] Redraw tiles once per burst of tiled-marker changes Same change as android-for-maplibre: relabelling street trees changes a few dozen tiled markers at once, and each update() replaced the raster source, so the map fetched every visible tile again per marker (on MapLibre, Pixel 5a: 45 replacements, 494 tile renders, last tile 6.1 s after the change). - Changes arriving within a frame share one tile refresh; a pending refresh is cancelled on destroy() so it cannot register the tile route again. - The tiling check reads the entity count without copying all entities. - The icon is baked only when the marker is drawn natively. - onPostProcess runs only when a native marker became tiled (it copies every entity to redraw the native ones). --- .../mappls/marker/MapplsMarkerController.kt | 45 ++++++++++++++++--- 1 file changed, 40 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt index 1ff4d72..b0c87d7 100644 --- a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt +++ b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt @@ -20,8 +20,11 @@ import com.mapconductor.core.raster.TileScheme import com.mapconductor.core.tileserver.TileServerRegistry import com.mapconductor.mappls.MapplsActualMarker import java.util.UUID +import kotlin.time.Duration.Companion.milliseconds import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay import kotlinx.coroutines.launch import kotlinx.coroutines.sync.withPermit @@ -110,11 +113,12 @@ class MapplsMarkerController( if (currentFinger == prevFinger) return semaphore.withPermit { + // 件数だけが要る。allEntities() は全件の写しを作るので、ラベルの付け替えのように + // 数十本が続けて変わると、そのたびに 14 万件を写すことになる。 val tilingEnabled = - markerTiling.enabled && markerManager.allEntities().size >= markerManager.minMarkerCount + markerTiling.enabled && markerManager.getMemoryStats().entityCount >= markerManager.minMarkerCount val wantsTiled = tilingEnabled && !state.draggable && state.getAnimation() == null val wasTiled = tiledMarkerIds.contains(state.id) - val markerIcon = state.icon?.toBitmapIcon() ?: defaultMarkerIcon if (wantsTiled) { if (!wasTiled) { @@ -132,14 +136,19 @@ class MapplsMarkerController( tiling = true, ), ) - renderer.onPostProcess() - syncTiledOverlay() + // タイル担当のままなら、ネイティブのマーカーには何も起きていない。onPostProcess は + // 全件を写してネイティブ分を描き直すので(14 万件で 1 回 50ms)、ネイティブから + // タイルへ移ったときだけ呼ぶ。 + if (!wasTiled) renderer.onPostProcess() + scheduleTileRefresh() return@withPermit } if (wasTiled) { tiledMarkerIds.remove(state.id) } + // ネイティブマーカーとして描くときだけ焼き込む。タイル担当なら要らない。 + val markerIcon = state.icon?.toBitmapIcon() ?: defaultMarkerIcon val params = object : MarkerOverlayRendererInterface.ChangeParamsInterface { @@ -170,7 +179,7 @@ class MapplsMarkerController( renderer.onPostProcess() if (tiledMarkerIds.isNotEmpty()) { - syncTiledOverlay() + scheduleTileRefresh() } else { removeTileOverlay() } @@ -178,6 +187,25 @@ class MapplsMarkerController( viewportSwitch.requestReapply() } + private var tileRefreshJob: Job? = null + + /** + * 1 本ずつの変更からの描き直しを 1 回にまとめる。 + * + * ラベルの付け替えのように数十本が続けて変わると、1 本ごとにラスターソースを差し替え、 + * そのたびに地図が見えているタイルを全部取り直していた(MapLibre・Pixel 5a で 45 回、 + * 描き直したタイル 494 枚、最後のタイルまで 6 秒)。続けて来た変更は + * [TILE_REFRESH_COALESCE] の間に受けて、まとめて 1 回だけ差し替える。 + */ + private fun scheduleTileRefresh() { + if (tileRefreshJob?.isActive == true) return + tileRefreshJob = + coroutine.launch { + delay(TILE_REFRESH_COALESCE) + semaphore.withPermit { syncTiledOverlay() } + } + } + override suspend fun clear() { viewportSwitch.destroy() semaphore.withPermit { @@ -214,6 +242,8 @@ class MapplsMarkerController( override fun destroy() { viewportSwitch.destroy() + // 待っている描き直しが後から走ると、外したタイル経路をまた登録してしまう。 + tileRefreshJob?.cancel() // Clean up tile server registration // Unregister this map's route only. Never stop the server here: it is // a process-wide singleton shared by all map controllers and overlay @@ -316,4 +346,9 @@ class MapplsMarkerController( rasterLayerCallback?.onRasterLayerUpdate(null) markerTileRasterLayerState = null } + + private companion object { + /** 続けて来る変更を 1 回の描き直しにまとめる窓。1 フレーム分。 */ + val TILE_REFRESH_COALESCE = 16.milliseconds + } } From 5d220543eb273258db69e37cbfd0b9c3b60f17f7 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Fri, 6 Nov 2026 19:25:12 -0800 Subject: [PATCH 10/27] Keep the whole map design across configuration changes MapplsMapViewSaver saved only styleName, so the id came back as "default" and attribution rules were lost. Adds a device round-trip test. --- build.gradle.kts | 5 ++ .../mappls/MapplsMapViewSaverTest.kt | 79 +++++++++++++++++++ .../mappls/MapplsViewStateImpl.kt | 7 +- 3 files changed, 90 insertions(+), 1 deletion(-) create mode 100644 src/androidTest/java/com/mapconductor/mappls/MapplsMapViewSaverTest.kt diff --git a/build.gradle.kts b/build.gradle.kts index 92281d1..8b66e67 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -29,6 +29,7 @@ android { defaultConfig { minSdk = project.property("minSdk").toString().toInt() + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" consumerProguardFiles("consumer-rules.pro") } @@ -82,6 +83,10 @@ dependencies { } testImplementation(libs.junit) + + // Saver の保存 → 復元を実機の Bundle / Parcel で確かめる(SaverRoundTripTest)。 + androidTestImplementation(libs.androidx.junit) + androidTestImplementation(libs.androidx.espresso.core) } // Set project version for NMCP plugin diff --git a/src/androidTest/java/com/mapconductor/mappls/MapplsMapViewSaverTest.kt b/src/androidTest/java/com/mapconductor/mappls/MapplsMapViewSaverTest.kt new file mode 100644 index 0000000..05b1bf4 --- /dev/null +++ b/src/androidTest/java/com/mapconductor/mappls/MapplsMapViewSaverTest.kt @@ -0,0 +1,79 @@ +package com.mapconductor.mappls + +import androidx.compose.runtime.saveable.Saver +import androidx.compose.runtime.saveable.SaverScope +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.mapconductor.core.features.GeoPoint +import com.mapconductor.core.map.AttributionRule +import com.mapconductor.core.map.MapCameraPosition +import com.mapconductor.core.map.MapUISettings +import org.junit.Assert.assertEquals +import org.junit.Assert.assertSame +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import android.os.Bundle +import android.os.Parcel + +/** + * 回転などの構成変更で state が [MapplsMapViewSaver] を通って作り直されても、デザイン(id・ + * attributionRules ほか)と uiSettings・カメラが落ちないこと。Bundle は実機の Parcel を一度通す。 + */ +@RunWith(AndroidJUnit4::class) +class MapplsMapViewSaverTest { + private val rules = + listOf(AttributionRule("© test"), AttributionRule("© ranged", minZoom = 3, maxZoom = 15)) + + private val camera = + MapCameraPosition( + position = GeoPoint(21.38, -157.93), + zoom = 12.0, + bearing = 20.0, + tilt = 10.0, + ) + + @Test + fun keepsDesignWithAttributionRules() { + val design = MapplsDesign(id = "contract-style", styleName = "contract_style_name", attributionRules = rules) + val state = MapplsViewState(mapDesignType = design, id = "mappls-1", cameraPosition = camera) + state.uiSettings = MapUISettings(rotateGesture = false, tiltGesture = false) + + val restored = roundTrip(MapplsMapViewSaver().createSaver(), state) + + // 以前は styleName しか保存しておらず、id は default に戻っていた。 + assertEquals(design, restored.mapDesignType) + assertCommon(restored, "mappls-1") + } + + @Test + fun keepsPresetDesign() { + val state = MapplsViewState(mapDesignType = MapplsDesign.StandardDay, id = "mappls-2") + assertEquals(MapplsDesign.StandardDay, roundTrip(MapplsMapViewSaver().createSaver(), state).mapDesignType) + } + + private fun assertCommon(restored: com.mapconductor.core.map.MapViewStateInterface<*>, id: String) { + assertEquals(id, restored.id) + assertEquals(false, restored.uiSettings.rotateGesture) + assertEquals(false, restored.uiSettings.tiltGesture) + assertEquals(true, restored.uiSettings.scrollGesture) + assertEquals(12.0, restored.cameraPosition.zoom, 1e-9) + assertEquals(20.0, restored.cameraPosition.bearing, 1e-9) + assertEquals(21.38, restored.cameraPosition.position.latitude, 1e-9) + } + + private fun roundTrip( + saver: Saver, + value: T, + ): T { + val saved = with(saver) { SaverScope { true }.save(value) }!! + // 一度 Parcel に書いて読み戻す(プロセスが落ちたあとの復元と同じ経路)。 + val parcel = Parcel.obtain() + try { + parcel.writeBundle(saved) + parcel.setDataPosition(0) + return saver.restore(parcel.readBundle(javaClass.classLoader)!!)!! + } finally { + parcel.recycle() + } + } +} diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewStateImpl.kt b/src/main/java/com/mapconductor/mappls/MapplsViewStateImpl.kt index 50dac25..6e73d5b 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewStateImpl.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewStateImpl.kt @@ -8,6 +8,7 @@ import com.mapconductor.compose.map.BaseMapViewSaver import com.mapconductor.core.map.MapCameraPosition import com.mapconductor.core.map.MapCameraPositionInterface import com.mapconductor.core.map.MapViewState +import com.mapconductor.core.map.MapViewStateBundle import com.mapconductor.core.map.MapViewStateInterface import java.util.UUID import android.os.Bundle @@ -53,7 +54,10 @@ class MapplsMapViewSaver : BaseMapViewSaver() { state: MapplsViewState, bundle: Bundle, ) { - bundle.putString("styleName", state.mapDesignType.styleName) + val design = state.mapDesignType + bundle.putString("id", design.id) + bundle.putString("styleName", design.styleName) + MapViewStateBundle.putAttributionRules(bundle, design.attributionRules) } override fun createState( @@ -71,6 +75,7 @@ class MapplsMapViewSaver : BaseMapViewSaver() { styleName = mapDesignBundle?.getString("styleName") ?: MapplsDesign.Default.styleName, + attributionRules = MapViewStateBundle.getAttributionRules(mapDesignBundle), ), cameraPosition = cameraPosition, ) From 18f5187ae2f09fa16c3bd7f6809537b6cec2434c Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 05:40:54 -0800 Subject: [PATCH 11/27] Draw large polygon sets as raster tiles (PolygonTiler) The polygon controller gets a PolygonTiler, whose tiles are shown through the raster layer path the marker tiles use (upsert / removeById, outside the app's RasterLayer composition). Tiled polygons stay registered for taps and give the map SDK nothing. The polygon tile layer goes where the SDK's polygon layers do: over the basemap, under polylines and markers. --- api/android-for-mappls.api | 2 ++ .../mappls/MapplsViewController.kt | 16 +++++++++ .../mappls/polygon/MapplsPolygonConductor.kt | 33 +++++++++++++++++++ .../MapplsRasterLayerOverlayRenderer.kt | 31 ++++++++++++++++- 4 files changed, 81 insertions(+), 1 deletion(-) diff --git a/api/android-for-mappls.api b/api/android-for-mappls.api index 31bc400..80ab732 100644 --- a/api/android-for-mappls.api +++ b/api/android-for-mappls.api @@ -370,6 +370,8 @@ public final class com.mapconductor.mappls.polygon.MapplsPolygonConductor implem public final com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer getPolygonOverlay(); public final com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer getPolylineOverlay(); public int getZIndex(); + public final com.mapconductor.core.polygon.PolygonTiler getTiler(); + public final void setTiler(com.mapconductor.core.polygon.PolygonTiler); public final kotlin.jvm.functions.Function1 getClickListener(); public final void setClickListener(kotlin.jvm.functions.Function1); public java.lang.Object add(java.util.List, kotlin.coroutines.Continuation); diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt index e14a612..708c16c 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt @@ -17,7 +17,10 @@ import com.mapconductor.core.marker.OnMarkerEventHandler import com.mapconductor.core.marker.StrategyMarkerController import com.mapconductor.core.marker.dispatchGeoMarkerClick import com.mapconductor.core.polygon.OnPolygonEventHandler +import com.mapconductor.core.polygon.POLYGON_TILE_LAYER_ID import com.mapconductor.core.polygon.PolygonState +import com.mapconductor.core.polygon.PolygonTiler +import com.mapconductor.core.polygon.polygonTileRasterLayerState import com.mapconductor.core.polyline.OnPolylineEventHandler import com.mapconductor.mappls.circle.MapplsCircleController import com.mapconductor.mappls.groundimage.MapplsGroundImageController @@ -105,6 +108,19 @@ class MapplsViewController( markerTileLayers.forEach { entity -> rasterLayerController.removeById(entity.state.id) } } } + + // Many polygons are drawn as raster tiles, shown through the same RasterLayer + // controller as the marker tiles (upsert / removeById, never the app's layers). + polygonController.tiler = + PolygonTiler().apply { + onTemplate = { template, tileSize -> + if (template != null) { + rasterLayerController.upsert(polygonTileRasterLayerState(template, tileSize)) + } else { + rasterLayerController.removeById(POLYGON_TILE_LAYER_ID) + } + } + } } fun setupListeners() { diff --git a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt index 25bb1a9..25c5bfd 100644 --- a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt +++ b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt @@ -8,9 +8,12 @@ import com.mapconductor.core.polygon.PolygonEntity import com.mapconductor.core.polygon.PolygonEntityInterface import com.mapconductor.core.polygon.PolygonEvent import com.mapconductor.core.polygon.PolygonState +import com.mapconductor.core.polygon.PolygonTiler import com.mapconductor.core.polyline.PolylineEntity import com.mapconductor.core.polyline.PolylineState import com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext class MapplsPolygonConductor( val polygonOverlay: MapplsPolygonOverlayRenderer, @@ -21,6 +24,13 @@ class MapplsPolygonConductor( > { override val zIndex: Int = 2 + /** + * Set by the view controller to draw many polygons as tiles (see + * [PolygonTiler]). Tiled polygons stay in the manager, for taps, and give + * the GeoJSON layers nothing. + */ + var tiler: PolygonTiler? = null + var clickListener: ((PolygonEvent) -> Unit)? = null override suspend fun add(data: List) { @@ -38,7 +48,19 @@ class MapplsPolygonConductor( polylineOverlay.polylineManager.removeEntity("outline-$id") } + val tiled = tiler?.route(data) ?: emptySet() + if (tiled.isNotEmpty()) { + // Still registered, so taps resolve against the original shape. + withContext(Dispatchers.Default) { + for (polygonState in data) { + if (polygonState.id !in tiled) continue + polygonOverlay.polygonManager.registerEntity(PolygonEntity(polygon = IN_TILES, state = polygonState)) + polylineOverlay.polylineManager.removeEntity("outline-${polygonState.id}") + } + } + } data.forEach { polygonState -> + if (polygonState.id in tiled) return@forEach polygonOverlay.createPolygon(polygonState)?.let { polygon -> val polygonEntity = @@ -64,6 +86,13 @@ class MapplsPolygonConductor( } override suspend fun update(state: PolygonState) { + tiler?.let { tiler -> + if (tiler.isTiled(state.id)) { + polygonOverlay.polygonManager.registerEntity(PolygonEntity(polygon = IN_TILES, state = state)) + tiler.update(state) + return + } + } polygonOverlay.createPolygon(state)?.let { polygon -> val polygonEntity = PolygonEntity( @@ -97,6 +126,7 @@ class MapplsPolygonConductor( polygonOverlay.polygonManager.find(position) as? PolygonEntityInterface override suspend fun clear() { + tiler?.clear() polygonOverlay.polygonManager.clear() polylineOverlay.polylineManager.clear() polygonOverlay.onPostProcess() @@ -134,6 +164,9 @@ class MapplsPolygonConductor( } } +/** What a tiled polygon hands the GeoJSON layers: nothing. It is in the tiles. */ +private val IN_TILES: List = emptyList() + private fun PolygonState.toPolylineState(): PolylineState { val closedPoints = if (points.first() != points.last()) { diff --git a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt index 60512e3..ad7c352 100644 --- a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt @@ -1,5 +1,6 @@ package com.mapconductor.mappls.raster +import com.mapconductor.core.polygon.POLYGON_TILE_LAYER_ID import com.mapconductor.core.raster.RasterLayerEntityInterface import com.mapconductor.core.raster.RasterLayerOverlayRendererInterface import com.mapconductor.core.raster.RasterLayerSource @@ -24,6 +25,8 @@ class MapplsRasterLayerOverlayRenderer( private fun isMarkerTileRaster(state: RasterLayerState): Boolean = state.id.startsWith(MARKER_TILE_RASTER_ID_PREFIX) + private fun isPolygonTileRaster(state: RasterLayerState): Boolean = state.id == POLYGON_TILE_LAYER_ID + override suspend fun onAdd( data: List, ): List = @@ -96,6 +99,8 @@ class MapplsRasterLayerOverlayRenderer( try { if (isMarkerTileRaster(state)) { addLayerForMarkerTile(style, layer) + } else if (isPolygonTileRaster(state)) { + addLayerForPolygonTile(style, layer) } else { addBelowBasemapLabels(style, layer) } @@ -105,6 +110,26 @@ class MapplsRasterLayerOverlayRenderer( return handle } + /** + * The polygon tiles are polygons drawn as images, not imagery: they go + * where the SDK's own polygon layers do, over the basemap and under + * polylines and markers -- below the first of those in the style. + */ + private fun addLayerForPolygonTile( + style: com.mappls.sdk.maps.Style, + layer: com.mappls.sdk.maps.style.layers.Layer, + ) { + val anchor = style.layers.map { it.id }.firstOrNull { id -> POLYGON_TILE_ANCHOR_PREFIXES.any { id.startsWith(it) } } + if (anchor != null) { + try { + style.addLayerBelow(layer, anchor) + return + } catch (_: Exception) { + } + } + style.addLayer(layer) + } + private fun addLayerForMarkerTile( style: com.mappls.sdk.maps.Style, layer: RasterLayer, @@ -159,7 +184,7 @@ class MapplsRasterLayerOverlayRenderer( val ordered = stateById.values .asSequence() - .filter { !isMarkerTileRaster(it) } + .filter { !isMarkerTileRaster(it) && !isPolygonTileRaster(it) } .sortedBy { it.zIndex } .mapNotNull { state -> handleById[state.id]?.let { handle -> state to handle } } .toList() @@ -262,6 +287,10 @@ class MapplsRasterLayerOverlayRenderer( private const val MARKER_TILE_RASTER_ID_PREFIX = "marker-tile-" private const val MARKERS_LAYER_ID = "markers-layer" private const val POLYLINE_LAYER_ID = "polyline-layer" + + /** The SDK's own layers the polygon tiles go below, whichever comes first in the style. */ + private val POLYGON_TILE_ANCHOR_PREFIXES = + listOf("polygon-fill-layer", "polygon-outline-layer", POLYLINE_LAYER_ID, "raster-layer-marker-tile-", MARKERS_LAYER_ID) } } From 172c814d5357ffad0137526483dfac6bcce0eb08 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 13:16:50 -0800 Subject: [PATCH 12/27] Destroy the MapView when the map leaves the composition Nothing destroyed the MapView, so its render thread kept the old controller with every overlay. It is now destroyed through MapViewBase's onDestroyMapView (not stopped first: it was never started). --- src/main/java/com/mapconductor/mappls/MapplsMapView.kt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/main/java/com/mapconductor/mappls/MapplsMapView.kt b/src/main/java/com/mapconductor/mappls/MapplsMapView.kt index 862b41f..4bcc1c3 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsMapView.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsMapView.kt @@ -187,6 +187,11 @@ fun MapplsMapView( // For now, assuming content relates to overlay definitions. style = style, onStyleDiagnostics = onStyleDiagnostics, + // Never started (onStart is not called), so it is not stopped either -- + // MapView.onStop() would deactivate the shared FileSource the next map + // still uses. Destroying it ends the render thread, whose camera + // listeners otherwise keep the controller and every overlay alive. + onDestroyMapView = { mapView -> mapView.onDestroy() }, content = content, // This might need adjustment based on how overlays are handled ) } From f02f6416c93db2e44e3c98006463d8f81fa8c376 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 13:33:12 -0800 Subject: [PATCH 13/27] Dispose the polygon tiler when the conductor is destroyed core's PolygonController.destroy() releases its tiler (02369fa), but this provider's own polygon conductor does not extend it and its destroy() was empty, so the tile server kept every destroyed map's tiled polygons. --- .../mapconductor/mappls/polygon/MapplsPolygonConductor.kt | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt index 25c5bfd..5ebf667 100644 --- a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt +++ b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt @@ -160,7 +160,10 @@ class MapplsPolygonConductor( } override fun destroy() { - // No native resources to clean up for polygons + // The tile server outlives the map; without this its route keeps every + // tiled polygon (and the renderer's copies of them) alive. Same as + // core's PolygonController.destroy(), which this conductor does not extend. + tiler?.dispose() } } From f557259444a6b313b2cfea72787f354f2ef228a4 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 16:20:26 -0800 Subject: [PATCH 14/27] Read the controller through the state base, which MapViewBase clears The state kept its own controller field, set on attach and never cleared, so a state the app keeps held the destroyed controller and every overlay of the old map. It now reads the base's attached controller, which MapViewBase detaches when the map is torn down. The polygon conductor's destroy() clears its polygon and outline managers, as core's PolygonController now does. --- .../java/com/mapconductor/mappls/MapplsViewStateImpl.kt | 6 ++++-- .../mapconductor/mappls/polygon/MapplsPolygonConductor.kt | 5 ++++- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewStateImpl.kt b/src/main/java/com/mapconductor/mappls/MapplsViewStateImpl.kt index 6e73d5b..64c1656 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewStateImpl.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewStateImpl.kt @@ -21,7 +21,10 @@ class MapplsViewState( cameraPosition: MapCameraPosition = MapCameraPosition.Default, ) : MapViewState(cameraPosition), MapplsViewStateInterface { - private var controller: MapplsViewControllerInterface? = null + // Read through the base so that letting go of the controller there (MapViewBase + // does it when the map is torn down) leaves nothing behind here. + private val controller: MapplsViewControllerInterface? + get() = attachedMapController as? MapplsViewControllerInterface private var _mapDesignType: MapplsMapDesignTypeInterface = mapDesignType override var mapDesignType: MapplsMapDesignTypeInterface @@ -32,7 +35,6 @@ class MapplsViewState( get() = _mapDesignType internal fun setController(controller: MapplsViewControllerInterface) { - this.controller = controller attachController(controller) } diff --git a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt index 25bb1a9..18cd0df 100644 --- a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt +++ b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt @@ -130,7 +130,10 @@ class MapplsPolygonConductor( } override fun destroy() { - // No native resources to clean up for polygons + // A destroyed conductor can still be referenced (by its map controller, + // or a state that has not let go yet); without this it keeps every entity. + polygonOverlay.polygonManager.clear() + polylineOverlay.polylineManager.clear() } } From 2056aad452eeb9bec879c52b3144a9fd78f299fd Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 17:05:15 -0800 Subject: [PATCH 15/27] Extend core PolygonController for Mappls polygons MapplsPolygonConductor implemented SlottedOverlayController by hand because it drives two renderers (fill + a polyline per outline, since a fill layer cannot draw a stroke wider than 1 px). Every change to core's PolygonController had to be copied over, and it was missed twice. Replace it with MapplsPolygonController, which extends core's PolygonController, and MapplsPolygonCompositeRenderer, which presents the existing fill and outline renderers as one renderer. The fill renderer's onRemove now redraws without the removed polygons, since core's clear() does not call onPostProcess. --- api/android-for-mappls.api | 41 +++-- .../com/mapconductor/mappls/MapplsMapView.kt | 14 +- .../mappls/MapplsViewController.kt | 4 +- .../mappls/MapplsViewControllerStyle.kt | 12 +- .../polygon/MapplsPolygonCompositeRenderer.kt | 78 +++++++++ .../mappls/polygon/MapplsPolygonConductor.kt | 153 ------------------ .../mappls/polygon/MapplsPolygonController.kt | 17 ++ .../polygon/MapplsPolygonOverlayRenderer.kt | 16 +- 8 files changed, 143 insertions(+), 192 deletions(-) create mode 100644 src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonCompositeRenderer.kt delete mode 100644 src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt create mode 100644 src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonController.kt diff --git a/api/android-for-mappls.api b/api/android-for-mappls.api index 31bc400..8fe3338 100644 --- a/api/android-for-mappls.api +++ b/api/android-for-mappls.api @@ -90,7 +90,7 @@ public final class com.mapconductor.mappls.MapplsMapViewKt { public static final com.mapconductor.mappls.MapplsViewController createMapplsViewController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.marker.MarkerTilingOptions, com.mapconductor.core.map.MutableMapServiceRegistry); public static final com.mapconductor.mappls.marker.MapplsMarkerController getMarkerController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.marker.MarkerTilingOptions); public static final com.mapconductor.mappls.polyline.MapplsPolylineController getPolylineController(com.mapconductor.mappls.MapplsMapViewHolderInterface); - public static final com.mapconductor.mappls.polygon.MapplsPolygonConductor getPolygonController(com.mapconductor.mappls.MapplsMapViewHolderInterface); + public static final com.mapconductor.mappls.polygon.MapplsPolygonController getPolygonController(com.mapconductor.mappls.MapplsMapViewHolderInterface); public static final com.mapconductor.mappls.circle.MapplsCircleController getCircleController(com.mapconductor.mappls.MapplsMapViewHolderInterface); public static final com.mapconductor.mappls.raster.MapplsRasterLayerController getRasterLayerController(com.mapconductor.mappls.MapplsMapViewHolderInterface); public static final com.mapconductor.mappls.groundimage.MapplsGroundImageController getGroundImageController(com.mapconductor.mappls.MapplsMapViewHolderInterface); @@ -116,8 +116,8 @@ public final class com.mapconductor.mappls.MapplsPolyUtilsKt { public final class com.mapconductor.mappls.MapplsTypeAliasKt { } public final class com.mapconductor.mappls.MapplsViewController extends com.mapconductor.core.controller.BaseMapViewController implements com.mapconductor.mappls.MapplsViewControllerInterface,com.mappls.sdk.maps.MapplsMap$OnMapClickListener,com.mappls.sdk.maps.MapplsMap$OnMapLongClickListener,com.mappls.sdk.maps.MapplsMap$OnMoveListener,com.mappls.sdk.maps.MapplsMap$OnCameraMoveListener,com.mappls.sdk.maps.MapplsMap$OnCameraIdleListener { - public com.mapconductor.mappls.MapplsViewController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.mappls.marker.MapplsMarkerController, com.mapconductor.mappls.polyline.MapplsPolylineController, com.mapconductor.mappls.polygon.MapplsPolygonConductor, com.mapconductor.mappls.groundimage.MapplsGroundImageController, com.mapconductor.mappls.circle.MapplsCircleController, com.mapconductor.mappls.raster.MapplsRasterLayerController, kotlinx.coroutines.CoroutineScope, kotlinx.coroutines.CoroutineScope); - public com.mapconductor.mappls.MapplsViewController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.mappls.marker.MapplsMarkerController, com.mapconductor.mappls.polyline.MapplsPolylineController, com.mapconductor.mappls.polygon.MapplsPolygonConductor, com.mapconductor.mappls.groundimage.MapplsGroundImageController, com.mapconductor.mappls.circle.MapplsCircleController, com.mapconductor.mappls.raster.MapplsRasterLayerController, kotlinx.coroutines.CoroutineScope, kotlinx.coroutines.CoroutineScope, int, kotlin.jvm.internal.DefaultConstructorMarker); + public com.mapconductor.mappls.MapplsViewController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.mappls.marker.MapplsMarkerController, com.mapconductor.mappls.polyline.MapplsPolylineController, com.mapconductor.mappls.polygon.MapplsPolygonController, com.mapconductor.mappls.groundimage.MapplsGroundImageController, com.mapconductor.mappls.circle.MapplsCircleController, com.mapconductor.mappls.raster.MapplsRasterLayerController, kotlinx.coroutines.CoroutineScope, kotlinx.coroutines.CoroutineScope); + public com.mapconductor.mappls.MapplsViewController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.mappls.marker.MapplsMarkerController, com.mapconductor.mappls.polyline.MapplsPolylineController, com.mapconductor.mappls.polygon.MapplsPolygonController, com.mapconductor.mappls.groundimage.MapplsGroundImageController, com.mapconductor.mappls.circle.MapplsCircleController, com.mapconductor.mappls.raster.MapplsRasterLayerController, kotlinx.coroutines.CoroutineScope, kotlinx.coroutines.CoroutineScope, int, kotlin.jvm.internal.DefaultConstructorMarker); public com.mapconductor.mappls.MapplsMapViewHolderInterface getHolder(); public kotlinx.coroutines.CoroutineScope getMainCoroutine(); public kotlinx.coroutines.CoroutineScope getDefaultCoroutine(); @@ -365,27 +365,22 @@ public class com.mapconductor.mappls.marker.MarkerLayer { public final boolean wouldSkipDraw(java.util.List>); public final void draw(java.util.List>, com.mappls.sdk.maps.Style); } -public final class com.mapconductor.mappls.polygon.MapplsPolygonConductor implements com.mapconductor.core.controller.SlottedOverlayController> { - public com.mapconductor.mappls.polygon.MapplsPolygonConductor(com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer, com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer); - public final com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer getPolygonOverlay(); - public final com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer getPolylineOverlay(); - public int getZIndex(); - public final kotlin.jvm.functions.Function1 getClickListener(); - public final void setClickListener(kotlin.jvm.functions.Function1); - public java.lang.Object add(java.util.List, kotlin.coroutines.Continuation); - public java.lang.Object update(com.mapconductor.core.polygon.PolygonState, kotlin.coroutines.Continuation); - public final void dispatchClick(com.mapconductor.core.polygon.PolygonEvent); - public com.mapconductor.core.polygon.PolygonEntityInterface find(com.mapconductor.core.features.GeoPointInterface); - public java.lang.Object clear(kotlin.coroutines.Continuation); - public com.mapconductor.core.controller.OverlayKind getKind(); - public boolean has(java.lang.String); - public void setClickListenerAny(java.lang.Object); - public com.mapconductor.core.controller.OverlayHit resolveTap(com.mapconductor.core.features.GeoPointInterface); - public void destroy(); - public java.lang.Object update(java.lang.Object, kotlin.coroutines.Continuation); - public java.lang.Object find(com.mapconductor.core.features.GeoPointInterface); +public final class com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer implements com.mapconductor.core.polygon.PolygonOverlayRendererInterface> { + public com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer(com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer, com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer); + public final com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer getFill(); + public final com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer getOutline(); + public java.lang.Object onAdd(java.util.List, kotlin.coroutines.Continuation>>); + public java.lang.Object onChange(java.util.List>>, kotlin.coroutines.Continuation>>); + public java.lang.Object onRemove(java.util.List>>, kotlin.coroutines.Continuation); + public java.lang.Object onPostProcess(kotlin.coroutines.Continuation); } -public final class com.mapconductor.mappls.polygon.MapplsPolygonConductorKt { +public final class com.mapconductor.mappls.polygon.MapplsPolygonCompositeRendererKt { +} +public final class com.mapconductor.mappls.polygon.MapplsPolygonController extends com.mapconductor.core.polygon.PolygonController> { + public com.mapconductor.mappls.polygon.MapplsPolygonController(com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer); + public com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer getRenderer(); + public int getZIndex(); + public com.mapconductor.core.polygon.PolygonOverlayRendererInterface getRenderer(); } public final class com.mapconductor.mappls.polygon.MapplsPolygonLayer { public com.mapconductor.mappls.polygon.MapplsPolygonLayer(java.lang.String, java.lang.String); diff --git a/src/main/java/com/mapconductor/mappls/MapplsMapView.kt b/src/main/java/com/mapconductor/mappls/MapplsMapView.kt index 862b41f..22f52a0 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsMapView.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsMapView.kt @@ -33,7 +33,8 @@ import com.mapconductor.mappls.marker.MapplsMarkerController import com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer import com.mapconductor.mappls.marker.MarkerDragLayer import com.mapconductor.mappls.marker.MarkerLayer -import com.mapconductor.mappls.polygon.MapplsPolygonConductor +import com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer +import com.mapconductor.mappls.polygon.MapplsPolygonController import com.mapconductor.mappls.polygon.MapplsPolygonLayer import com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer import com.mapconductor.mappls.polyline.MapplsPolylineController @@ -302,7 +303,7 @@ fun getPolylineController(holder: MapplsMapViewHolderInterface): MapplsPolylineC return controller } -fun getPolygonController(holder: MapplsMapViewHolderInterface): MapplsPolygonConductor { +fun getPolygonController(holder: MapplsMapViewHolderInterface): MapplsPolygonController { val polylineLayer = MapplsPolylineLayer( sourceId = "polygon-outline-source", @@ -329,9 +330,12 @@ fun getPolygonController(holder: MapplsMapViewHolderInterface): MapplsPolygonCon holder = holder, ) - return MapplsPolygonConductor( - polygonOverlay = polygonOverlayRenderer, - polylineOverlay = polylineOverlayRenderer, + return MapplsPolygonController( + renderer = + MapplsPolygonCompositeRenderer( + fill = polygonOverlayRenderer, + outline = polylineOverlayRenderer, + ), ) } diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt index e14a612..c7791b2 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt @@ -25,7 +25,7 @@ import com.mapconductor.mappls.marker.MapplsMarkerController import com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer import com.mapconductor.mappls.marker.MarkerDragLayer import com.mapconductor.mappls.marker.MarkerLayer -import com.mapconductor.mappls.polygon.MapplsPolygonConductor +import com.mapconductor.mappls.polygon.MapplsPolygonController import com.mapconductor.mappls.polyline.MapplsPolylineController import com.mapconductor.mappls.raster.MapplsRasterLayerController import com.mappls.sdk.gestures.MoveGestureDetector @@ -47,7 +47,7 @@ class MapplsViewController( override val holder: MapplsMapViewHolderInterface, internal val markerController: MapplsMarkerController, internal val polylineController: MapplsPolylineController, - internal val polygonController: MapplsPolygonConductor, + internal val polygonController: MapplsPolygonController, internal val groundImageController: MapplsGroundImageController, internal val circleController: MapplsCircleController, internal val rasterLayerController: MapplsRasterLayerController, diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewControllerStyle.kt b/src/main/java/com/mapconductor/mappls/MapplsViewControllerStyle.kt index 91af46a..74b8d03 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewControllerStyle.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewControllerStyle.kt @@ -81,8 +81,8 @@ internal fun MapplsViewController.setupStyle(style: Style) { (markerController.renderer as MapplsMarkerOverlayRenderer).ensureDefaultIcon(style) // Polygon sources only (layers will be added per zIndex) - ensureGeoJsonSource(style, polygonController.polylineOverlay.layer.sourceId) - ensureGeoJsonSource(style, polygonController.polygonOverlay.layer.sourceId) + ensureGeoJsonSource(style, polygonController.renderer.outline.layer.sourceId) + ensureGeoJsonSource(style, polygonController.renderer.fill.layer.sourceId) // Circle cts as anchor above polygons ensureGeoJsonSource(style, circleController.renderer.layer.sourceId) @@ -157,7 +157,7 @@ internal fun MapplsViewController.setupStyle(style: Style) { (markerController.renderer as MapplsMarkerOverlayRenderer).redraw() circleController.renderer.redraw() polylineController.renderer.redraw() -// polygonController.polygonOverlay.onPostProcess() +// polygonController.renderer.fill.onPostProcess() mainCoroutine.launch { groundImageController.reapplyStyle() rasterLayerController.reapplyStyle() @@ -165,12 +165,12 @@ internal fun MapplsViewController.setupStyle(style: Style) { } internal fun MapplsViewController.ensurePolygonZLayers(style: Style) { - val fillSourceId = polygonController.polygonOverlay.layer.sourceId - val outlineSourceId = polygonController.polylineOverlay.layer.sourceId + val fillSourceId = polygonController.renderer.fill.layer.sourceId + val outlineSourceId = polygonController.renderer.outline.layer.sourceId val anchorId = polylineController.renderer.layer.layerId val zSet = - polygonController.polygonOverlay.polygonManager + polygonController.polygonManager .allEntities() .map { it.state.zIndex } .toSet() diff --git a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonCompositeRenderer.kt b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonCompositeRenderer.kt new file mode 100644 index 0000000..b64ecca --- /dev/null +++ b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonCompositeRenderer.kt @@ -0,0 +1,78 @@ +package com.mapconductor.mappls.polygon + +import com.mapconductor.core.polygon.PolygonEntityInterface +import com.mapconductor.core.polygon.PolygonOverlayRendererInterface +import com.mapconductor.core.polygon.PolygonState +import com.mapconductor.core.polyline.PolylineEntity +import com.mapconductor.core.polyline.PolylineState +import com.mapconductor.mappls.MapplsActualPolygon +import com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer + +/** + * 塗りと輪郭を 1 つのレンダラとして [com.mapconductor.core.polygon.PolygonController] に渡すための合成レンダラ。 + * + * fill レイヤーは幅 1 px の輪郭しか描けないので、`strokeWidth` を守るために輪郭は + * 別のポリライン(`outline-`)として [outline] で描く。差分計算はコアの + * PolygonController に任せ、ここは「塗りへの指示を輪郭にも写す」ことだけをする。 + * + * 塗りのエンティティはコントローラと同じ [fill] の polygonManager に載る。輪郭は + * [outline] の polylineManager に載り、コントローラからは見えない。 + */ +class MapplsPolygonCompositeRenderer( + val fill: MapplsPolygonOverlayRenderer, + val outline: MapplsPolylineOverlayRenderer, +) : PolygonOverlayRendererInterface { + override suspend fun onAdd(data: List): List { + val polygons = fill.onAdd(data) + data.forEachIndexed { index, params -> + if (polygons[index] != null) putOutline(params.state) + } + return polygons + } + + override suspend fun onChange( + data: List>, + ): List { + val polygons = fill.onChange(data) + data.forEachIndexed { index, params -> + if (polygons[index] != null) putOutline(params.current.state) + } + return polygons + } + + override suspend fun onRemove(data: List>) { + data.forEach { outline.polylineManager.removeEntity(outlineId(it.state.id)) } + // clear() は onPostProcess を呼ばないので、消した結果はここで描き直す。 + fill.onRemove(data) + outline.onPostProcess() + } + + override suspend fun onPostProcess() { + fill.onPostProcess() + outline.onPostProcess() + } + + private suspend fun putOutline(state: PolygonState) { + val outlineState = state.toOutlineState() ?: return + outline.createPolyline(outlineState)?.let { polyline -> + outline.polylineManager.registerEntity(PolylineEntity(polyline = polyline, state = outlineState)) + } + } +} + +private fun outlineId(polygonId: String): String = "outline-$polygonId" + +/** 外周だけを閉じたポリラインにする(穴の輪郭は描かない)。 */ +private fun PolygonState.toOutlineState(): PolylineState? { + if (points.isEmpty()) return null + val closedPoints = if (points.first() != points.last()) points + points.first() else points + return PolylineState( + points = closedPoints, + id = outlineId(id), + strokeColor = strokeColor, + strokeWidth = strokeWidth, + geodesic = geodesic, + zIndex = zIndex, + extra = extra, + ) +} diff --git a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt deleted file mode 100644 index 25bb1a9..0000000 --- a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt +++ /dev/null @@ -1,153 +0,0 @@ -package com.mapconductor.mappls.polygon - -import com.mapconductor.core.controller.OverlayHit -import com.mapconductor.core.controller.OverlayKind -import com.mapconductor.core.controller.SlottedOverlayController -import com.mapconductor.core.features.GeoPointInterface -import com.mapconductor.core.polygon.PolygonEntity -import com.mapconductor.core.polygon.PolygonEntityInterface -import com.mapconductor.core.polygon.PolygonEvent -import com.mapconductor.core.polygon.PolygonState -import com.mapconductor.core.polyline.PolylineEntity -import com.mapconductor.core.polyline.PolylineState -import com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer - -class MapplsPolygonConductor( - val polygonOverlay: MapplsPolygonOverlayRenderer, - val polylineOverlay: MapplsPolylineOverlayRenderer, -) : SlottedOverlayController< - PolygonState, - PolygonEntityInterface, - > { - override val zIndex: Int = 2 - - var clickListener: ((PolygonEvent) -> Unit)? = null - - override suspend fun add(data: List) { - val nextIds = data.asSequence().map { it.id }.toSet() - val prevIds = - polygonOverlay.polygonManager - .allEntities() - .asSequence() - .map { it.state.id } - .toSet() - val removeIds = prevIds - nextIds - - removeIds.forEach { id -> - polygonOverlay.polygonManager.removeEntity(id) - polylineOverlay.polylineManager.removeEntity("outline-$id") - } - - data.forEach { polygonState -> - - polygonOverlay.createPolygon(polygonState)?.let { polygon -> - val polygonEntity = - PolygonEntity( - polygon = polygon, - state = polygonState, - ) - polygonOverlay.polygonManager.registerEntity(polygonEntity) - } - - val polylineState = polygonState.toPolylineState() - polylineOverlay.createPolyline(polylineState)?.let { polyline -> - val polylineEntity = - PolylineEntity( - polyline = polyline, - state = polylineState, - ) - polylineOverlay.polylineManager.registerEntity(polylineEntity) - } - } - polygonOverlay.onPostProcess() - polylineOverlay.onPostProcess() - } - - override suspend fun update(state: PolygonState) { - polygonOverlay.createPolygon(state)?.let { polygon -> - val polygonEntity = - PolygonEntity( - polygon = polygon, - state = state, - ) - polygonOverlay.polygonManager.registerEntity(polygonEntity) - } - - val polylineState = state.toPolylineState() - polylineOverlay.createPolyline(polylineState)?.let { polyline -> - val polylineEntity = - PolylineEntity( - polyline = polyline, - state = polylineState, - ) - polylineOverlay.polylineManager.registerEntity(polylineEntity) - } - polygonOverlay.onPostProcess() - polylineOverlay.onPostProcess() - } - - fun dispatchClick(event: PolygonEvent) { - // 配送座標の wrap は PolygonEvent の生成時に一元化済み。 - event.state.onClick?.invoke(event) - clickListener?.invoke(event) - } - - @Suppress("UNCHECKED_CAST") - override fun find(position: GeoPointInterface): PolygonEntityInterface? = - polygonOverlay.polygonManager.find(position) as? PolygonEntityInterface - - override suspend fun clear() { - polygonOverlay.polygonManager.clear() - polylineOverlay.polylineManager.clear() - polygonOverlay.onPostProcess() - polylineOverlay.onPostProcess() - } - - // ── Capable ファサードのスロットとクリックカスケードへの参加 ────────── - // - // このコンダクタはコアの PolygonController を継承していない(ポリゴンの輪郭を - // ポリラインとして描くために polygon と polyline の 2 レンダラを束ねている)。 - // それでも扱いは他プロバイダのポリゴンと同じでなければならないので、 - // スロットの契約はここで自前で満たす。 - // - // 実際、Step 4 でこれを実装し忘れて `hasPolygon` が常に false になり、 - // ポリゴン単体の状態更新が黙って捨てられていた。 - - override val kind: OverlayKind = OverlayKind.Polygon - - override fun has(id: String): Boolean = polygonOverlay.polygonManager.hasEntity(id) - - @Suppress("UNCHECKED_CAST") - override fun setClickListenerAny(listener: Any?) { - clickListener = listener as? ((PolygonEvent) -> Unit) - } - - override fun resolveTap(position: GeoPointInterface): OverlayHit? = - find(position)?.let { entity -> - OverlayHit(OverlayKind.Polygon, position) { - dispatchClick(PolygonEvent(entity.state, position)) - } - } - - override fun destroy() { - // No native resources to clean up for polygons - } -} - -private fun PolygonState.toPolylineState(): PolylineState { - val closedPoints = - if (points.first() != points.last()) { - points + points.first() - } else { - points - } - return PolylineState( - points = closedPoints, - id = "outline-${this.id}", - strokeColor = this.strokeColor, - strokeWidth = this.strokeWidth, - geodesic = this.geodesic, - zIndex = this.zIndex, - extra = this.extra, - ) -} diff --git a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonController.kt b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonController.kt new file mode 100644 index 0000000..28bbc57 --- /dev/null +++ b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonController.kt @@ -0,0 +1,17 @@ +package com.mapconductor.mappls.polygon + +import com.mapconductor.core.polygon.PolygonController +import com.mapconductor.mappls.MapplsActualPolygon + +/** + * Mappls 用のポリゴンコントローラ。 + * + * 追加・更新・削除の差分計算、`has`、クリックカスケードはコアの [PolygonController] が担う。 + * 塗りと輪郭(幅のある LineLayer)の 2 系統の描画は [MapplsPolygonCompositeRenderer] が束ねる。 + */ +class MapplsPolygonController( + override val renderer: MapplsPolygonCompositeRenderer, +) : PolygonController(renderer.fill.polygonManager, renderer) { + // 旧 MapplsPolygonConductor と同じ値を保つ。 + override val zIndex: Int = 2 +} diff --git a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonOverlayRenderer.kt index 15f49de..1d15776 100644 --- a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonOverlayRenderer.kt @@ -23,10 +23,13 @@ class MapplsPolygonOverlayRenderer( override val holder: MapplsMapViewHolderInterface, override val coroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), ) : AbstractPolygonOverlayRenderer() { + // 消えた分を除いた残りで描き直す。コントローラはこの呼び出しの後で polygonManager から + // 外すので(clear() では onPostProcess も来ない)、ここで除外しておかないと消えずに残る。 override suspend fun onRemove(data: List>) { - coroutine.launch { - holder.map.style?.let { - layer.draw(getAllPolygonEntities(), it) + val polygons = getRemainingPolygonEntities(data) + holder.map.style?.let { + coroutine.launch { + layer.draw(polygons, it) } } } @@ -79,4 +82,11 @@ class MapplsPolygonOverlayRenderer( private fun getAllPolygonEntities(): List> = polygonManager.allEntities() + + private fun getRemainingPolygonEntities( + removed: List>, + ): List> { + val removedIds = removed.mapTo(HashSet()) { it.state.id } + return polygonManager.allEntities().filter { it.state.id !in removedIds } + } } From eafdc6e19466f551c0c8839318437d21951953ff Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 20:07:32 -0800 Subject: [PATCH 16/27] Polygon conductor: move a tiled polygon to the GeoJSON layers when a change makes it untileable Setting geodesic on a tiled polygon in place, or giving it points that span half the world or fewer than three, kept it in the tiles. update() now checks canTile and, when it fails, takes the polygon out of the tiles and draws it natively. It stays on the map, so this is not an add. --- .../mappls/polygon/MapplsPolygonConductor.kt | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt index 5ebf667..87f5881 100644 --- a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt +++ b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt @@ -8,6 +8,7 @@ import com.mapconductor.core.polygon.PolygonEntity import com.mapconductor.core.polygon.PolygonEntityInterface import com.mapconductor.core.polygon.PolygonEvent import com.mapconductor.core.polygon.PolygonState +import com.mapconductor.core.polygon.PolygonTileSet import com.mapconductor.core.polygon.PolygonTiler import com.mapconductor.core.polyline.PolylineEntity import com.mapconductor.core.polyline.PolylineState @@ -88,9 +89,15 @@ class MapplsPolygonConductor( override suspend fun update(state: PolygonState) { tiler?.let { tiler -> if (tiler.isTiled(state.id)) { - polygonOverlay.polygonManager.registerEntity(PolygonEntity(polygon = IN_TILES, state = state)) - tiler.update(state) - return + if (PolygonTileSet.canTile(state)) { + polygonOverlay.polygonManager.registerEntity(PolygonEntity(polygon = IN_TILES, state = state)) + tiler.update(state) + return + } + // No longer drawable in a tile (geodesic, half the world wide, or + // under 3 points): the GeoJSON layers draw it from now on. Still + // on the map, so this is not an add. + tiler.remove(state.id) } } polygonOverlay.createPolygon(state)?.let { polygon -> From 848ba1d85f00a050224e6900891b9a2f5923e35a Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 20:52:54 -0800 Subject: [PATCH 17/27] Redraw markers after clearing them The marker controller's clear() emptied the manager, but onRemove only drops icon references; the GeoJSON source is rewritten from the manager in onPostProcess, which clear() never called. The markers stayed on the map after clearOverlays(). Call it once the manager is empty, the same order the core controllers use. --- .../com/mapconductor/mappls/marker/MapplsMarkerController.kt | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt index b0c87d7..45ef10c 100644 --- a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt +++ b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt @@ -217,6 +217,10 @@ class MapplsMarkerController( markerManager.clear() tiledMarkerIds.clear() removeTileOverlay() + // onRemove はアイコンの参照数を減らすだけで、地図のソースは onPostProcess が + // manager の中身から描き直すまで変わらない。空にした後で呼ばないと、 + // clearOverlays() の後もマーカーが地図に残る。 + renderer.onPostProcess() } } From 011fcf8a1def944edb72c70791c0b766a28c0f39 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 23:10:01 -0800 Subject: [PATCH 18/27] Clear strategy markers in clearOverlays() Markers drawn through a StrategyMarkerController (clustering and other extension modules register these with registerOverlayController) were left on the map by clearOverlays(), which only cleared this provider's own controllers. Call BaseMapViewController.clearStrategyMarkerControllers(). Needs android-sdk-core with clearStrategyMarkerControllers() (fix/clear-strategy). --- src/main/java/com/mapconductor/mappls/MapplsViewController.kt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt index c7791b2..d679641 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt @@ -128,6 +128,8 @@ class MapplsViewController( groundImageController.clear() circleController.clear() rasterLayerController.clear() + // 拡張モジュール(クラスタリングなど)が登録した Strategy のマーカーも消す。 + clearStrategyMarkerControllers() } override fun moveCamera(position: MapCameraPosition) = handleMoveCamera(position) From 53d00f31c01052f2a3dfbfff144a501297f194f1 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 23:55:27 -0800 Subject: [PATCH 19/27] Stack overlays by band, independent of add order and style reloads Before: circles were added first (bottom), polygon z-layers were inserted below the polyline layer (so above circles), ground images went directly below the polyline layer (above polygons, and above every polygon added earlier), and a raster added after the style was set went to the very top until the next rebuild put it under the labels. MapplsOverlayStacking records the band and zIndex of every layer the SDK adds and inserts each one below the lowest SDK layer with a higher key, reading the style's current layer list every time. Rasters additionally stay below the basemap's first label layer (as before). Marker tiles go to the bottom of the marker band, the drag layer to the top. Stacking order (all providers, all platforms), bottom to top: raster layers < ground images < polygons < circles < polylines < markers. Needs android-sdk-core with OverlayStacking (fix/overlay-stacking-order). --- api/android-for-mappls.api | 9 ++ .../mappls/MapplsOverlayStacking.kt | 86 ++++++++++++++ .../mappls/MapplsViewController.kt | 17 +-- .../mappls/MapplsViewControllerStyle.kt | 97 +++++----------- .../MapplsGroundImageOverlayRenderer.kt | 28 ++--- .../MapplsRasterLayerOverlayRenderer.kt | 107 ++++-------------- 6 files changed, 161 insertions(+), 183 deletions(-) create mode 100644 src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt diff --git a/api/android-for-mappls.api b/api/android-for-mappls.api index 8fe3338..c052daa 100644 --- a/api/android-for-mappls.api +++ b/api/android-for-mappls.api @@ -108,6 +108,15 @@ public final class com.mapconductor.mappls.MapplsMapViewSaver extends com.mapcon public final class com.mapconductor.mappls.MapplsMapViewScope extends com.mapconductor.compose.MapViewScope { public com.mapconductor.mappls.MapplsMapViewScope(); } +public final class com.mapconductor.mappls.MapplsOverlayStacking { + public static final com.mapconductor.mappls.MapplsOverlayStacking INSTANCE; + public final com.mapconductor.core.controller.OverlayLayerStack stackOf(com.mappls.sdk.maps.MapplsMap); + public final com.mapconductor.core.controller.OverlayStacking$Key key(com.mapconductor.core.controller.OverlayKind, int); + public final com.mapconductor.core.controller.OverlayStacking$Key getMARKER_TILE(); + public final com.mapconductor.core.controller.OverlayStacking$Key getMARKER_DRAG(); + public final void add(com.mappls.sdk.maps.MapplsMap, com.mappls.sdk.maps.Style, com.mappls.sdk.maps.style.layers.Layer, com.mapconductor.core.controller.OverlayStacking$Key); + public final void remove(com.mappls.sdk.maps.MapplsMap, com.mappls.sdk.maps.Style, java.lang.String); +} public final class com.mapconductor.mappls.MapplsPolyUtilsKt { public static final java.util.List createMapplsLines-rXlOB7A(java.lang.String, java.util.List, boolean, long, float, int); public static final java.lang.String toMapplsColorString-8_81llA(long); diff --git a/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt b/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt new file mode 100644 index 0000000..047d039 --- /dev/null +++ b/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt @@ -0,0 +1,86 @@ +package com.mapconductor.mappls + +import android.util.Log +import com.mapconductor.core.controller.OverlayKind +import com.mapconductor.core.controller.OverlayLayerStack +import com.mapconductor.core.controller.OverlayStacking +import com.mappls.sdk.maps.MapplsMap +import com.mappls.sdk.maps.Style +import com.mappls.sdk.maps.style.layers.Layer +import com.mappls.sdk.maps.style.layers.SymbolLayer +import java.util.WeakHashMap + +/** + * オーバーレイの層をスタイルのどこへ入れるか([OverlayStacking] の帯の順)。 + * + * 下から: ラスター < GroundImage < ポリゴン < サークル < ポリライン < マーカー + * (マーカーのタイルはマーカーの帯の一番下、ドラッグ中の層は一番上)。 + * + * 位置は毎回スタイルの今の並びから決めるので、追加した順・送り直し・ + * スタイルの読み直し(デザイン変更)に左右されない。 + * + * ラスターだけはベースマップのラベル(SDK の層でない最初の symbol 層)の下に入れる。 + * それ以外の帯はラベルの上に乗る(従来どおり)。 + */ +internal object MapplsOverlayStacking { + private val stacks = WeakHashMap() + + fun stackOf(map: MapplsMap): OverlayLayerStack = synchronized(stacks) { stacks.getOrPut(map) { OverlayLayerStack() } } + + fun key( + kind: OverlayKind, + zIndex: Int = 0, + ) = OverlayStacking.Key(kind, zIndex) + + /** マーカーのタイル(ラスター): マーカーの帯の一番下。 */ + val MARKER_TILE = key(OverlayKind.Marker, Int.MIN_VALUE) + + /** ドラッグ中のマーカーの層: マーカーの帯の一番上。 */ + val MARKER_DRAG = key(OverlayKind.Marker, Int.MAX_VALUE) + + /** + * [layer] を [key] の位置へ足す。同じ id の層が既にあれば何もしない + * (位置を変えたいときは先に [remove] する)。 + */ + fun add( + map: MapplsMap, + style: Style, + layer: Layer, + key: OverlayStacking.Key, + ) { + val stack = stackOf(map) + stack.put(layer.id, key) + if (style.getLayer(layer.id) != null) return + val layers = style.layers + val ids = layers.map { it.id } + var before = stack.beforeId(ids, key) + if (key.kind == OverlayKind.RasterLayer) { + val label = layers.firstOrNull { it is SymbolLayer && stack.keyOf(it.id) == null }?.id + if (label != null && (before == null || ids.indexOf(label) < ids.indexOf(before))) { + before = label + } + } + try { + if (before != null) style.addLayerBelow(layer, before) else style.addLayer(layer) + } catch (e: Exception) { + if (style.getLayer(layer.id) != null) return + try { + style.addLayer(layer) + } catch (e2: Exception) { + Log.w("Mappls", "Failed to add layer: ${layer.id} (${e2.message})") + } + } + } + + fun remove( + map: MapplsMap, + style: Style?, + layerId: String, + ) { + stackOf(map).remove(layerId) + try { + style?.removeLayer(layerId) + } catch (_: Exception) { + } + } +} diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt index c7791b2..f05951c 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt @@ -337,19 +337,14 @@ class MapplsViewController( styleInstance?.let { style -> renderer.ensureDefaultIcon(style) ensureGeoJsonSource(style, renderer.markerLayer.sourceId) - addLayerAboveSafely( - style = style, - layer = renderer.markerLayer.layer, - layerId = renderer.markerLayer.layerId, - aboveId = polylineController.renderer.layer.layerId, + MapplsOverlayStacking.add( + holder.map, + style, + renderer.markerLayer.layer, + MapplsOverlayStacking.key(com.mapconductor.core.controller.OverlayKind.Marker), ) ensureGeoJsonSource(style, renderer.dragLayer.sourceId) - addLayerAboveSafely( - style = style, - layer = renderer.dragLayer.layer, - layerId = renderer.dragLayer.layerId, - aboveId = renderer.markerLayer.layerId, - ) + MapplsOverlayStacking.add(holder.map, style, renderer.dragLayer.layer, MapplsOverlayStacking.MARKER_DRAG) renderer.redraw() renderer.drawDragLayer() } diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewControllerStyle.kt b/src/main/java/com/mapconductor/mappls/MapplsViewControllerStyle.kt index 74b8d03..177c03f 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewControllerStyle.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewControllerStyle.kt @@ -1,5 +1,6 @@ package com.mapconductor.mappls +import com.mapconductor.core.controller.OverlayKind import com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer import com.mappls.sdk.maps.Style import com.mappls.sdk.maps.style.expressions.Expression @@ -17,7 +18,9 @@ import kotlinx.coroutines.launch * * Mappls はスタイルが読み込み直されるたびにレイヤーが全部消えるため、ここは * 何度呼ばれても同じ状態になるように書いてある(`ensureGeoJsonSource` / - * `addLayerSafely` はいずれも既存があれば作らない)。 + * [MapplsOverlayStacking.add] はいずれも既存があれば作らない)。層の位置は + * [MapplsOverlayStacking] が帯の順(ラスター < GroundImage < ポリゴン < サークル < + * ポリライン < マーカー)で決める。 * * ポリゴンの z 順は**レイヤーを z 値ごとに用意して**表現する。Mappls には * フィーチャー単位の z 指定が無く、レイヤーの並び順だけが順序を決めるため。 @@ -34,6 +37,7 @@ internal fun MapplsViewController.ensureGeoJsonSource( } } +// 層の位置は MapplsOverlayStacking が決める。以下 2 つは公開 API の互換のために残している(SDK 内では未使用)。 internal fun MapplsViewController.addLayerSafely( style: Style, layer: Layer, @@ -84,51 +88,28 @@ internal fun MapplsViewController.setupStyle(style: Style) { ensureGeoJsonSource(style, polygonController.renderer.outline.layer.sourceId) ensureGeoJsonSource(style, polygonController.renderer.fill.layer.sourceId) - // Circle cts as anchor above polygons + // 層の位置は MapplsOverlayStacking が帯の順で決める(追加の順に依らない)。 + val stacking = MapplsOverlayStacking + val map = holder.map + val markerRenderer = markerController.renderer as MapplsMarkerOverlayRenderer + ensureGeoJsonSource(style, circleController.renderer.layer.sourceId) - addLayerSafely( - style = style, - layer = circleController.renderer.layer.layer, - layerId = circleController.renderer.layer.layerId, - ) - // Circle stroke (LineLayer) directly above the circle fill - addLayerAboveSafely( - style = style, - layer = circleController.renderer.layer.strokeLayer, - layerId = circleController.renderer.layer.strokeLayerId, - aboveId = circleController.renderer.layer.layerId, - ) + stacking.add(map, style, circleController.renderer.layer.layer, stacking.key(OverlayKind.Circle)) + // 線は塗りの直後(同じ鍵なら後から入れたものが上)。 + stacking.add(map, style, circleController.renderer.layer.strokeLayer, stacking.key(OverlayKind.Circle)) - // Polyline (general) acts as anchor above circles ensureGeoJsonSource(style, polylineController.renderer.layer.sourceId) - addLayerSafely( - style = style, - layer = polylineController.renderer.layer.layer, - layerId = polylineController.renderer.layer.layerId, - ) + stacking.add(map, style, polylineController.renderer.layer.layer, stacking.key(OverlayKind.Polyline)) - // Add z-indexed polygon layers below general polylines ensurePolygonZLayers(style) - // Marker - add source and layer at the top - ensureGeoJsonSource(style, (markerController.renderer as MapplsMarkerOverlayRenderer).markerLayer.sourceId) - addLayerAboveSafely( - style = style, - layer = (markerController.renderer as MapplsMarkerOverlayRenderer).markerLayer.layer, - layerId = (markerController.renderer as MapplsMarkerOverlayRenderer).markerLayer.layerId, - aboveId = polylineController.renderer.layer.layerId, - ) - (markerController.renderer as MapplsMarkerOverlayRenderer).redraw() + ensureGeoJsonSource(style, markerRenderer.markerLayer.sourceId) + stacking.add(map, style, markerRenderer.markerLayer.layer, stacking.key(OverlayKind.Marker)) + markerRenderer.redraw() - // Drag layer above marker layer - ensureGeoJsonSource(style, (markerController.renderer as MapplsMarkerOverlayRenderer).dragLayer.sourceId) - addLayerAboveSafely( - style = style, - layer = (markerController.renderer as MapplsMarkerOverlayRenderer).dragLayer.layer, - layerId = (markerController.renderer as MapplsMarkerOverlayRenderer).dragLayer.layerId, - aboveId = (markerController.renderer as MapplsMarkerOverlayRenderer).markerLayer.layerId, - ) - (markerController.renderer as MapplsMarkerOverlayRenderer).redraw() + ensureGeoJsonSource(style, markerRenderer.dragLayer.sourceId) + stacking.add(map, style, markerRenderer.dragLayer.layer, stacking.MARKER_DRAG) + markerRenderer.redraw() markerEventControllers .map { it.renderer as MapplsMarkerOverlayRenderer } @@ -136,19 +117,9 @@ internal fun MapplsViewController.setupStyle(style: Style) { .forEach { renderer -> renderer.ensureDefaultIcon(style) ensureGeoJsonSource(style, renderer.markerLayer.sourceId) - addLayerAboveSafely( - style = style, - layer = renderer.markerLayer.layer, - layerId = renderer.markerLayer.layerId, - aboveId = polylineController.renderer.layer.layerId, - ) + stacking.add(map, style, renderer.markerLayer.layer, stacking.key(OverlayKind.Marker)) ensureGeoJsonSource(style, renderer.dragLayer.sourceId) - addLayerAboveSafely( - style = style, - layer = renderer.dragLayer.layer, - layerId = renderer.dragLayer.layerId, - aboveId = renderer.markerLayer.layerId, - ) + stacking.add(map, style, renderer.dragLayer.layer, stacking.MARKER_DRAG) renderer.redraw() renderer.drawDragLayer() } @@ -167,7 +138,6 @@ internal fun MapplsViewController.setupStyle(style: Style) { internal fun MapplsViewController.ensurePolygonZLayers(style: Style) { val fillSourceId = polygonController.renderer.fill.layer.sourceId val outlineSourceId = polygonController.renderer.outline.layer.sourceId - val anchorId = polylineController.renderer.layer.layerId val zSet = polygonController.polygonManager @@ -180,14 +150,8 @@ internal fun MapplsViewController.ensurePolygonZLayers(style: Style) { toRemove.forEach { z -> val fillId = "polygon-fill-layer-$z" val outlineId = "polygon-outline-layer-$z" - try { - style.removeLayer(outlineId) - } catch (_: Exception) { - } - try { - style.removeLayer(fillId) - } catch (_: Exception) { - } + MapplsOverlayStacking.remove(holder.map, style, outlineId) + MapplsOverlayStacking.remove(holder.map, style, fillId) } val zList = zSet.toList().sorted() @@ -213,11 +177,7 @@ internal fun MapplsViewController.ensurePolygonZLayers(style: Style) { ), ) } - try { - style.addLayerBelow(fill, anchorId) - } catch (_: Exception) { - style.addLayer(fill) - } + MapplsOverlayStacking.add(holder.map, style, fill, MapplsOverlayStacking.key(OverlayKind.Polygon, z)) } if (style.getLayer(outlineId) == null) { @@ -246,11 +206,8 @@ internal fun MapplsViewController.ensurePolygonZLayers(style: Style) { ), ) } - try { - style.addLayerAbove(outline, fillId) - } catch (_: Exception) { - style.addLayer(outline) - } + // 塗りの直後(同じ鍵なら後から入れたものが上)。 + MapplsOverlayStacking.add(holder.map, style, outline, MapplsOverlayStacking.key(OverlayKind.Polygon, z)) } } polygonZLayers.clear() diff --git a/src/main/java/com/mapconductor/mappls/groundimage/MapplsGroundImageOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/groundimage/MapplsGroundImageOverlayRenderer.kt index 0dcc9eb..1b7059e 100644 --- a/src/main/java/com/mapconductor/mappls/groundimage/MapplsGroundImageOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/groundimage/MapplsGroundImageOverlayRenderer.kt @@ -1,5 +1,6 @@ package com.mapconductor.mappls.groundimage +import com.mapconductor.core.controller.OverlayKind import com.mapconductor.core.features.GeoRectBounds import com.mapconductor.core.groundimage.AbstractGroundImageOverlayRenderer import com.mapconductor.core.groundimage.GroundImageEntityInterface @@ -7,6 +8,7 @@ import com.mapconductor.core.groundimage.GroundImageFingerPrint import com.mapconductor.core.groundimage.GroundImageState import com.mapconductor.mappls.MapplsActualGroundImage import com.mapconductor.mappls.MapplsMapViewHolderInterface +import com.mapconductor.mappls.MapplsOverlayStacking import com.mappls.sdk.maps.Style import com.mappls.sdk.maps.geometry.LatLng import com.mappls.sdk.maps.geometry.LatLngQuad @@ -104,25 +106,20 @@ class MapplsGroundImageOverlayRenderer( Log.w("Mappls", "Failed to add ground image source: ${e.message}") } - try { - style.addLayerBelow(layer, BELOW_LAYER_ID) - } catch (_: Exception) { - try { - style.addLayer(layer) - } catch (e: Exception) { - Log.w("Mappls", "Failed to add ground image layer: ${e.message}") - } - } + // GroundImage の帯(ラスターの上、ポリゴンの下)。送り直しても同じ位置。 + MapplsOverlayStacking.add( + holder.map, + style, + layer, + MapplsOverlayStacking.key(OverlayKind.GroundImage), + ) } private fun removeSourceAndLayerIfExists( style: Style, handle: MapplsGroundImageHandle, ) { - try { - style.removeLayer(handle.layerId) - } catch (_: Exception) { - } + MapplsOverlayStacking.remove(holder.map, style, handle.layerId) try { style.removeSource(handle.sourceId) } catch (_: Exception) { @@ -185,7 +182,6 @@ class MapplsGroundImageOverlayRenderer( opacity = opacity, ) - companion object { - private const val BELOW_LAYER_ID = "polyline-layer" - } + // 公開 API(Companion)の互換のために残している。 + companion object } diff --git a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt index 60512e3..fc2c8ac 100644 --- a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt @@ -1,11 +1,13 @@ package com.mapconductor.mappls.raster +import com.mapconductor.core.controller.OverlayKind import com.mapconductor.core.raster.RasterLayerEntityInterface import com.mapconductor.core.raster.RasterLayerOverlayRendererInterface import com.mapconductor.core.raster.RasterLayerSource import com.mapconductor.core.raster.RasterLayerState import com.mapconductor.core.raster.TileScheme import com.mapconductor.mappls.MapplsMapViewHolderInterface +import com.mapconductor.mappls.MapplsOverlayStacking import com.mappls.sdk.maps.style.layers.Property import com.mappls.sdk.maps.style.layers.PropertyFactory import com.mappls.sdk.maps.style.layers.RasterLayer @@ -93,38 +95,26 @@ class MapplsRasterLayerOverlayRenderer( } catch (e: Exception) { Log.w("Mappls", "Failed to add raster source: ${e.message}") } - try { - if (isMarkerTileRaster(state)) { - addLayerForMarkerTile(style, layer) - } else { - addBelowBasemapLabels(style, layer) - } - } catch (e: Exception) { - Log.w("Mappls", "Failed to add raster layer: ${e.message}") - } + addToStack(style, layer, state) return handle } - private fun addLayerForMarkerTile( + /** + * 帯の順([MapplsOverlayStacking])で足す。アプリのラスターはラスターの帯 + * (一番下、ベースマップのラベルの下)、マーカーのタイルはマーカーの帯の一番下。 + */ + private fun addToStack( style: com.mappls.sdk.maps.Style, layer: RasterLayer, + state: RasterLayerState, ) { - // Insert the raster tiles below the marker symbol layer so they don't cover markers, - // but remain above vector overlays that are anchored below markers (polyline/circle/etc). - try { - style.addLayerBelow(layer, MARKERS_LAYER_ID) - return - } catch (_: Exception) { - } - - // Best-effort fallback: place above polylines if marker layer isn't present yet. - try { - style.addLayerAbove(layer, POLYLINE_LAYER_ID) - return - } catch (_: Exception) { - } - - style.addLayer(layer) + val key = + if (isMarkerTileRaster(state)) { + MapplsOverlayStacking.MARKER_TILE + } else { + MapplsOverlayStacking.key(OverlayKind.RasterLayer, state.zIndex) + } + MapplsOverlayStacking.add(holder.map, style, layer, key) } private fun updateLayer( @@ -145,10 +135,7 @@ class MapplsRasterLayerOverlayRenderer( private fun removeLayer(entity: RasterLayerEntityInterface) { val style = holder.map.style ?: return val handle = entity.layer - try { - style.removeLayer(handle.layerId) - } catch (_: Exception) { - } + MapplsOverlayStacking.remove(holder.map, style, handle.layerId) try { style.removeSource(handle.sourceId) } catch (_: Exception) { @@ -164,11 +151,10 @@ class MapplsRasterLayerOverlayRenderer( .mapNotNull { state -> handleById[state.id]?.let { handle -> state to handle } } .toList() + // zIndex が変わったときのために、いったん外して zIndex の順に入れ直す + // (同じ zIndex なら渡された順)。位置は帯の順で決まる。 ordered.forEach { (_, handle) -> - try { - style.removeLayer(handle.layerId) - } catch (_: Exception) { - } + MapplsOverlayStacking.remove(holder.map, style, handle.layerId) } ordered.forEach { (state, handle) -> @@ -180,59 +166,10 @@ class MapplsRasterLayerOverlayRenderer( if (state.visible) Property.VISIBLE else Property.NONE, ), ) - try { - addBelowBasemapLabels(style, layer) - } catch (_: Exception) { - } - } - } - - /** - * Puts a raster layer above the basemap's geometry but **below its labels**. - * - * Appended at the top of the style instead, a raster overlay covers the - * place names, road names and shields the backend draws -- a vector tile - * layer's own roads run straight through them, which is what "the labels - * are under the lines" looks like. Every raster overlay we add has the - * same problem, so the rule lives here rather than in each of them. - * - * Inserting successive layers below the same anchor keeps their order: - * each one lands directly below the anchor, which is directly above the - * one inserted before it. - * - * Anything of ours is skipped when looking for the anchor. Markers are a - * symbol layer too, and anchoring to them would put the raster back above - * the labels -- with the added twist of only doing so once a marker exists. - */ - private fun addBelowBasemapLabels( - style: com.mappls.sdk.maps.Style, - layer: com.mappls.sdk.maps.style.layers.Layer, - ) { - val anchor = - style.layers.firstOrNull { - it is com.mappls.sdk.maps.style.layers.SymbolLayer && !isOursById(it.id) - } - if (anchor == null) { - style.addLayer(layer) - return - } - try { - style.addLayerBelow(layer, anchor.id) - } catch (_: Exception) { - style.addLayer(layer) + addToStack(style, layer, state) } } - /** True for layers this SDK adds, as opposed to the design's own. */ - private fun isOursById(id: String): Boolean = - id.startsWith("raster-layer-") || - id.startsWith("org.maplibre.annotations") || - id.startsWith("com.mappls.annotations") || - id.startsWith(MARKERS_LAYER_ID) || - id.startsWith("marker-drag-layer") || - id.startsWith(POLYLINE_LAYER_ID) || - id.startsWith("circle-layer") - private fun buildSource( sourceId: String, source: RasterLayerSource, @@ -260,8 +197,6 @@ class MapplsRasterLayerOverlayRenderer( private companion object { private const val MARKER_TILE_RASTER_ID_PREFIX = "marker-tile-" - private const val MARKERS_LAYER_ID = "markers-layer" - private const val POLYLINE_LAYER_ID = "polyline-layer" } } From 1d52e9d1f0043aea748b8ee3822dcf636550714f Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Mon, 9 Nov 2026 06:55:03 -0800 Subject: [PATCH 20/27] Update the API baseline Additions only: the polygon tiles' stacking key, and declarations develop added without running apiDump (TILE_REFRESH_COALESCE, and on ArcGIS the marker controller's constructor that takes a boolean). --- api/android-for-mappls.api | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/api/android-for-mappls.api b/api/android-for-mappls.api index c052daa..4db1462 100644 --- a/api/android-for-mappls.api +++ b/api/android-for-mappls.api @@ -113,6 +113,7 @@ public final class com.mapconductor.mappls.MapplsOverlayStacking { public final com.mapconductor.core.controller.OverlayLayerStack stackOf(com.mappls.sdk.maps.MapplsMap); public final com.mapconductor.core.controller.OverlayStacking$Key key(com.mapconductor.core.controller.OverlayKind, int); public final com.mapconductor.core.controller.OverlayStacking$Key getMARKER_TILE(); + public final com.mapconductor.core.controller.OverlayStacking$Key getPOLYGON_TILE(); public final com.mapconductor.core.controller.OverlayStacking$Key getMARKER_DRAG(); public final void add(com.mappls.sdk.maps.MapplsMap, com.mappls.sdk.maps.Style, com.mappls.sdk.maps.style.layers.Layer, com.mapconductor.core.controller.OverlayStacking$Key); public final void remove(com.mappls.sdk.maps.MapplsMap, com.mappls.sdk.maps.Style, java.lang.String); @@ -312,6 +313,9 @@ public final class com.mapconductor.mappls.marker.MapplsMarkerController extends public void destroy(); public java.lang.Object update(java.lang.Object, kotlin.coroutines.Continuation); } +final class com.mapconductor.mappls.marker.MapplsMarkerController$Companion { + public final long getTILE_REFRESH_COALESCE-UwyO8pc(); +} public final class com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer extends com.mapconductor.core.marker.AbstractMarkerOverlayRenderer { public com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.marker.MarkerManager, com.mapconductor.mappls.marker.MarkerLayer, com.mapconductor.mappls.marker.MarkerDragLayer, kotlinx.coroutines.CoroutineScope); public com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.marker.MarkerManager, com.mapconductor.mappls.marker.MarkerLayer, com.mapconductor.mappls.marker.MarkerDragLayer, kotlinx.coroutines.CoroutineScope, int, kotlin.jvm.internal.DefaultConstructorMarker); @@ -389,6 +393,7 @@ public final class com.mapconductor.mappls.polygon.MapplsPolygonController exten public com.mapconductor.mappls.polygon.MapplsPolygonController(com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer); public com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer getRenderer(); public int getZIndex(); + public void destroy(); public com.mapconductor.core.polygon.PolygonOverlayRendererInterface getRenderer(); } public final class com.mapconductor.mappls.polygon.MapplsPolygonLayer { From 87cddcc87b7cd613d3c235ea91fe853e507fba0e Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Mon, 9 Nov 2026 09:38:06 -0800 Subject: [PATCH 21/27] Draw large polyline sets as raster tiles (PolylineTiler) The polyline controller gets a PolylineTiler, shown through the same raster layer path as the polygon tiles. Stacking key (Polyline, Int.MIN_VALUE): over circles, under native polylines and markers. Whatever redraws from the polyline manager skips tiled entities (no native line). --- api/android-for-mappls.api | 1 + .../mapconductor/mappls/MapplsOverlayStacking.kt | 3 +++ .../mapconductor/mappls/MapplsViewController.kt | 15 +++++++++++++++ .../polyline/MapplsPolylineOverlayRenderer.kt | 4 ++-- .../raster/MapplsRasterLayerOverlayRenderer.kt | 7 ++++++- 5 files changed, 27 insertions(+), 3 deletions(-) diff --git a/api/android-for-mappls.api b/api/android-for-mappls.api index 4db1462..a0beb78 100644 --- a/api/android-for-mappls.api +++ b/api/android-for-mappls.api @@ -114,6 +114,7 @@ public final class com.mapconductor.mappls.MapplsOverlayStacking { public final com.mapconductor.core.controller.OverlayStacking$Key key(com.mapconductor.core.controller.OverlayKind, int); public final com.mapconductor.core.controller.OverlayStacking$Key getMARKER_TILE(); public final com.mapconductor.core.controller.OverlayStacking$Key getPOLYGON_TILE(); + public final com.mapconductor.core.controller.OverlayStacking$Key getPOLYLINE_TILE(); public final com.mapconductor.core.controller.OverlayStacking$Key getMARKER_DRAG(); public final void add(com.mappls.sdk.maps.MapplsMap, com.mappls.sdk.maps.Style, com.mappls.sdk.maps.style.layers.Layer, com.mapconductor.core.controller.OverlayStacking$Key); public final void remove(com.mappls.sdk.maps.MapplsMap, com.mappls.sdk.maps.Style, java.lang.String); diff --git a/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt b/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt index 7cb7e2d..bb8ed1f 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt @@ -39,6 +39,9 @@ internal object MapplsOverlayStacking { /** ポリゴンのタイル(ラスター): ポリゴンの帯の一番下。 */ val POLYGON_TILE = key(OverlayKind.Polygon, Int.MIN_VALUE) + /** ポリラインのタイル(ラスター): ポリラインの帯の一番下(サークルの上、ネイティブのポリラインの下)。 */ + val POLYLINE_TILE = key(OverlayKind.Polyline, Int.MIN_VALUE) + /** ドラッグ中のマーカーの層: マーカーの帯の一番上。 */ val MARKER_DRAG = key(OverlayKind.Marker, Int.MAX_VALUE) diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt index 17c3a7f..01c4b61 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt @@ -22,6 +22,9 @@ import com.mapconductor.core.polygon.PolygonState import com.mapconductor.core.polygon.PolygonTiler import com.mapconductor.core.polygon.polygonTileRasterLayerState import com.mapconductor.core.polyline.OnPolylineEventHandler +import com.mapconductor.core.polyline.POLYLINE_TILE_LAYER_ID +import com.mapconductor.core.polyline.PolylineTiler +import com.mapconductor.core.polyline.polylineTileRasterLayerState import com.mapconductor.mappls.circle.MapplsCircleController import com.mapconductor.mappls.groundimage.MapplsGroundImageController import com.mapconductor.mappls.marker.MapplsMarkerController @@ -121,6 +124,18 @@ class MapplsViewController( } } } + + // Many polylines too: the same raster layer path, in the polyline band. + polylineController.tiler = + PolylineTiler().apply { + onTemplate = { template, tileSize -> + if (template != null) { + rasterLayerController.upsert(polylineTileRasterLayerState(template, tileSize)) + } else { + rasterLayerController.removeById(POLYLINE_TILE_LAYER_ID) + } + } + } } fun setupListeners() { diff --git a/src/main/java/com/mapconductor/mappls/polyline/MapplsPolylineOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/polyline/MapplsPolylineOverlayRenderer.kt index 89bc4cf..55f89f8 100644 --- a/src/main/java/com/mapconductor/mappls/polyline/MapplsPolylineOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/polyline/MapplsPolylineOverlayRenderer.kt @@ -67,11 +67,11 @@ class MapplsPolylineOverlayRenderer( private fun getAllPolylineEntities(): List> { // This would need access to the polyline manager // For now, we'll implement a simple workaround - return polylineManager.allEntities() + return polylineManager.allEntities().filter { (it.polyline as MapplsActualPolyline?) != null } } fun redraw() { - val entities = polylineManager.allEntities() + val entities = polylineManager.allEntities().filter { (it.polyline as MapplsActualPolyline?) != null } holder.map.style?.let { coroutine.launch { layer.draw(entities, it) diff --git a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt index 5a7d98a..a5dbb39 100644 --- a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt @@ -2,6 +2,7 @@ package com.mapconductor.mappls.raster import com.mapconductor.core.controller.OverlayKind import com.mapconductor.core.polygon.POLYGON_TILE_LAYER_ID +import com.mapconductor.core.polyline.POLYLINE_TILE_LAYER_ID import com.mapconductor.core.raster.RasterLayerEntityInterface import com.mapconductor.core.raster.RasterLayerOverlayRendererInterface import com.mapconductor.core.raster.RasterLayerSource @@ -29,6 +30,8 @@ class MapplsRasterLayerOverlayRenderer( private fun isPolygonTileRaster(state: RasterLayerState): Boolean = state.id == POLYGON_TILE_LAYER_ID + private fun isPolylineTileRaster(state: RasterLayerState): Boolean = state.id == POLYLINE_TILE_LAYER_ID + override suspend fun onAdd( data: List, ): List = @@ -117,6 +120,8 @@ class MapplsRasterLayerOverlayRenderer( MapplsOverlayStacking.MARKER_TILE } else if (isPolygonTileRaster(state)) { MapplsOverlayStacking.POLYGON_TILE + } else if (isPolylineTileRaster(state)) { + MapplsOverlayStacking.POLYLINE_TILE } else { MapplsOverlayStacking.key(OverlayKind.RasterLayer, state.zIndex) } @@ -152,7 +157,7 @@ class MapplsRasterLayerOverlayRenderer( val ordered = stateById.values .asSequence() - .filter { !isMarkerTileRaster(it) && !isPolygonTileRaster(it) } + .filter { !isMarkerTileRaster(it) && !isPolygonTileRaster(it) && !isPolylineTileRaster(it) } .sortedBy { it.zIndex } .mapNotNull { state -> handleById[state.id]?.let { handle -> state to handle } } .toList() From d31f26d3132253b25f5834c122d4369bc2f8fe52 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Tue, 10 Nov 2026 16:16:50 -0800 Subject: [PATCH 22/27] Support bulk Circles with raster tiles --- .../mapconductor/mappls/MapplsOverlayStacking.kt | 3 +++ .../mapconductor/mappls/MapplsViewController.kt | 15 +++++++++++++++ .../mappls/circle/MapplsCircleOverlayRenderer.kt | 2 +- .../raster/MapplsRasterLayerOverlayRenderer.kt | 7 ++++++- 4 files changed, 25 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt b/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt index bb8ed1f..46c0ec8 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt @@ -39,6 +39,9 @@ internal object MapplsOverlayStacking { /** ポリゴンのタイル(ラスター): ポリゴンの帯の一番下。 */ val POLYGON_TILE = key(OverlayKind.Polygon, Int.MIN_VALUE) + /** 円のタイル(ラスター): サークルの帯の一番下(ポリゴンの上、ネイティブの円とポリラインのタイルの下)。 */ + val CIRCLE_TILE = key(OverlayKind.Circle, Int.MIN_VALUE) + /** ポリラインのタイル(ラスター): ポリラインの帯の一番下(サークルの上、ネイティブのポリラインの下)。 */ val POLYLINE_TILE = key(OverlayKind.Polyline, Int.MIN_VALUE) diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt index 01c4b61..4e71be3 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt @@ -1,5 +1,8 @@ package com.mapconductor.mappls +import com.mapconductor.core.circle.CIRCLE_TILE_LAYER_ID +import com.mapconductor.core.circle.CircleTiler +import com.mapconductor.core.circle.circleTileRasterLayerState import com.mapconductor.core.circle.OnCircleEventHandler import com.mapconductor.core.controller.BaseMapViewController import com.mapconductor.core.features.GeoPointInterface @@ -125,6 +128,18 @@ class MapplsViewController( } } + // Many circles too: the same raster layer path, in the circle band. + circleController.tiler = + CircleTiler().apply { + onTemplate = { template, tileSize -> + if (template != null) { + rasterLayerController.upsert(circleTileRasterLayerState(template, tileSize)) + } else { + rasterLayerController.removeById(CIRCLE_TILE_LAYER_ID) + } + } + } + // Many polylines too: the same raster layer path, in the polyline band. polylineController.tiler = PolylineTiler().apply { diff --git a/src/main/java/com/mapconductor/mappls/circle/MapplsCircleOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/circle/MapplsCircleOverlayRenderer.kt index b808576..e040fca 100644 --- a/src/main/java/com/mapconductor/mappls/circle/MapplsCircleOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/circle/MapplsCircleOverlayRenderer.kt @@ -42,7 +42,7 @@ class MapplsCircleOverlayRenderer( /** Reapply the current composition after a Mappls style is created or replaced. */ fun redraw() { - val circles = circleManager.allEntities() + val circles = circleManager.nativeEntities().filter { (it.circle as MapplsActualCircle?) != null } holder.map.style?.let { style -> coroutine.launch { layer.draw(circles, style) } } diff --git a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt index a5dbb39..d1aa328 100644 --- a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt @@ -1,5 +1,6 @@ package com.mapconductor.mappls.raster +import com.mapconductor.core.circle.CIRCLE_TILE_LAYER_ID import com.mapconductor.core.controller.OverlayKind import com.mapconductor.core.polygon.POLYGON_TILE_LAYER_ID import com.mapconductor.core.polyline.POLYLINE_TILE_LAYER_ID @@ -32,6 +33,8 @@ class MapplsRasterLayerOverlayRenderer( private fun isPolylineTileRaster(state: RasterLayerState): Boolean = state.id == POLYLINE_TILE_LAYER_ID + private fun isCircleTileRaster(state: RasterLayerState): Boolean = state.id == CIRCLE_TILE_LAYER_ID + override suspend fun onAdd( data: List, ): List = @@ -120,6 +123,8 @@ class MapplsRasterLayerOverlayRenderer( MapplsOverlayStacking.MARKER_TILE } else if (isPolygonTileRaster(state)) { MapplsOverlayStacking.POLYGON_TILE + } else if (isCircleTileRaster(state)) { + MapplsOverlayStacking.CIRCLE_TILE } else if (isPolylineTileRaster(state)) { MapplsOverlayStacking.POLYLINE_TILE } else { @@ -157,7 +162,7 @@ class MapplsRasterLayerOverlayRenderer( val ordered = stateById.values .asSequence() - .filter { !isMarkerTileRaster(it) && !isPolygonTileRaster(it) && !isPolylineTileRaster(it) } + .filter { !isMarkerTileRaster(it) && !isPolygonTileRaster(it) && !isPolylineTileRaster(it) && !isCircleTileRaster(it) } .sortedBy { it.zIndex } .mapNotNull { state -> handleById[state.id]?.let { handle -> state to handle } } .toList() From aa3964311e48688e200810aed2c6320a324d5ec0 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Wed, 11 Nov 2026 11:41:05 -0800 Subject: [PATCH 23/27] Order markers with MarkerDrawOrder The symbol sort key is now zIndex first, then south and west, recomputed from the current state on every change. Unspecified markers in the southern hemisphere no longer outrank an explicit zIndex. --- .../marker/MapplsMarkerOverlayRenderer.kt | 40 ++----------------- 1 file changed, 4 insertions(+), 36 deletions(-) diff --git a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerOverlayRenderer.kt index fbae120..2e99a89 100644 --- a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerOverlayRenderer.kt @@ -3,12 +3,12 @@ package com.mapconductor.mappls.marker import com.google.gson.JsonArray import com.google.gson.JsonObject import com.mapconductor.core.ResourceProvider -import com.mapconductor.core.calculateZIndex import com.mapconductor.core.features.GeoPoint import com.mapconductor.core.features.GeoPointInterface import com.mapconductor.core.marker.AbstractMarkerOverlayRenderer import com.mapconductor.core.marker.BitmapIcon import com.mapconductor.core.marker.DefaultMarkerIcon +import com.mapconductor.core.marker.MarkerDrawOrder import com.mapconductor.core.marker.MarkerEntityInterface import com.mapconductor.core.marker.MarkerIconInterface import com.mapconductor.core.marker.MarkerManager @@ -149,17 +149,7 @@ class MapplsMarkerOverlayRenderer( ) { val entities = markerManager.allEntities() val props = (markerEntity.marker?.properties() ?: JsonObject()).deepCopy() - val previousZIndex = - props - .get(Prop.Z_INDEX) - ?.takeIf { it.isJsonPrimitive && it.asJsonPrimitive.isNumber } - ?.asInt - props.addProperty( - Prop.Z_INDEX, - markerEntity.state.zIndex - ?: previousZIndex - ?: calculateZIndex(position), - ) + props.addProperty(Prop.Z_INDEX, MarkerDrawOrder.of(markerEntity.state.zIndex, position)) val feature = Feature.fromGeometry( position.toPoint(), @@ -219,7 +209,7 @@ class MapplsMarkerOverlayRenderer( } // We don't use the Mappls SDK's scaling system // addProperty(Prop.SCALE, 1.0) - addProperty(Prop.Z_INDEX, it.state.zIndex ?: calculateZIndex(it.state.position)) + addProperty(Prop.Z_INDEX, MarkerDrawOrder.of(it.state.zIndex, it.state.position)) } Feature.fromGeometry(position, properties, featureId) } @@ -366,11 +356,7 @@ class MapplsMarkerOverlayRenderer( } addProperty( Prop.Z_INDEX, - resolveZIndexForChange( - current = params.current, - prev = params.prev, - prevProperties = prevProperties, - ), + MarkerDrawOrder.of(params.current.state.zIndex, params.current.state.position), ) } @@ -381,24 +367,6 @@ class MapplsMarkerOverlayRenderer( } } - private fun resolveZIndexForChange( - current: MarkerEntityInterface, - prev: MarkerEntityInterface, - prevProperties: JsonObject?, - ): Int { - current.state.zIndex?.let { return it } - - if (current.fingerPrint.zIndex == prev.fingerPrint.zIndex) { - prevProperties - ?.get(Prop.Z_INDEX) - ?.takeIf { it.isJsonPrimitive && it.asJsonPrimitive.isNumber } - ?.asInt - ?.let { return it } - } - - return calculateZIndex(current.state.position) - } - /** * ドラッグ対象の入れ替え。 * From 10ba512de659f548b051183e292e105470e849ee Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Wed, 11 Nov 2026 15:00:56 -0800 Subject: [PATCH 24/27] Reorder markers when the map rotates Same-zIndex markers follow the screen position (lower in front) and are re-sorted after rotation settles. --- api/android-for-mappls.api | 1 + .../marker/MapplsMarkerOverlayRenderer.kt | 822 +++++++++--------- 2 files changed, 418 insertions(+), 405 deletions(-) diff --git a/api/android-for-mappls.api b/api/android-for-mappls.api index a0beb78..52d9c9b 100644 --- a/api/android-for-mappls.api +++ b/api/android-for-mappls.api @@ -332,6 +332,7 @@ public final class com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer ex public java.lang.Object onRemove(java.util.List>, kotlin.coroutines.Continuation); public final void drawDragLayer(); public final void redraw(); + protected java.lang.Object applyDrawOrder(java.util.List>, kotlin.coroutines.Continuation); public java.lang.Object onPostProcess(kotlin.coroutines.Continuation); public java.lang.Object onChange(java.util.List>, kotlin.coroutines.Continuation>); public void onDragSelectionChanged(com.mapconductor.core.marker.MarkerEntityInterface, com.mapconductor.core.marker.MarkerEntityInterface); diff --git a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerOverlayRenderer.kt index 2e99a89..e1fb8fb 100644 --- a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerOverlayRenderer.kt @@ -1,405 +1,417 @@ -package com.mapconductor.mappls.marker - -import com.google.gson.JsonArray -import com.google.gson.JsonObject -import com.mapconductor.core.ResourceProvider -import com.mapconductor.core.features.GeoPoint -import com.mapconductor.core.features.GeoPointInterface -import com.mapconductor.core.marker.AbstractMarkerOverlayRenderer -import com.mapconductor.core.marker.BitmapIcon -import com.mapconductor.core.marker.DefaultMarkerIcon -import com.mapconductor.core.marker.MarkerDrawOrder -import com.mapconductor.core.marker.MarkerEntityInterface -import com.mapconductor.core.marker.MarkerIconInterface -import com.mapconductor.core.marker.MarkerManager -import com.mapconductor.core.marker.MarkerOverlayRendererInterface -import com.mapconductor.mappls.MapplsActualMarker -import com.mapconductor.mappls.MapplsMapViewHolderInterface -import com.mapconductor.mappls.toPoint -import com.mappls.sdk.geojson.Feature -import com.mappls.sdk.geojson.FeatureCollection -import android.graphics.Bitmap -import android.os.SystemClock -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.launch -import kotlinx.coroutines.withContext -import kotlinx.coroutines.yield - -class MapplsMarkerOverlayRenderer( - holder: MapplsMapViewHolderInterface, - val markerManager: MarkerManager, - val markerLayer: MarkerLayer, - val dragLayer: MarkerDragLayer, - coroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), -) : AbstractMarkerOverlayRenderer( - holder = holder, - coroutine = coroutine, - ) { - override val supportsAnimationOverlay: Boolean = true - - private val iconRefCounter: MutableMap = mutableMapOf() - private val pendingStyleImageRemovals: MutableMap = mutableMapOf() - private val iconBitmapCache: MutableMap = mutableMapOf() - private val defaultMarkerIcon: BitmapIcon = DefaultMarkerIcon().toBitmapIcon() - - object Prop { - const val ICON_ID = "icon_id" - const val DEFAULT_MARKER_ID = "default" - const val SCALE = "scale" - const val ICON_ANCHOR = "icon-offset" - const val Z_INDEX = "zIndex" - } - - object IconAnchor { - const val CENTER = "center" - const val LEFT = "left" - const val RIGHT = "right" - const val BOTTOM = "bottom" - const val TOP_LEFT = "top-left" - const val TOP_RIGHT = "top-right" - const val BOTTOM_LEFT = "bottom-left" - const val BOTTOM_RIGHT = "bottom-right" - } - - object IconTranslateAnchor { - const val MAP = "map" - const val VIEWPORT = "viewport" - } - - init { - val style = holder.map.style - if (style != null) { - style.addImage(Prop.DEFAULT_MARKER_ID, defaultMarkerIcon.bitmap) - } else { - holder.map.getStyle { style -> - style.addImage(Prop.DEFAULT_MARKER_ID, defaultMarkerIcon.bitmap) - } - } - } - - // Ensure marker images exist on the given style (used after style reload). - fun ensureDefaultIcon(style: com.mappls.sdk.maps.Style) { - ensureStyleImages(style) - } - - fun ensureStyleImages(style: com.mappls.sdk.maps.Style) { - val startedAt = SystemClock.elapsedRealtime() - try { - style.addImage(Prop.DEFAULT_MARKER_ID, defaultMarkerIcon.bitmap) - } catch (_: Exception) { - } - - val entities = markerManager.allEntities() - val styleIcons = linkedMapOf() - var nativeMarkerCount = 0 - entities.forEach { entity -> - // Tiled markers have no Mappls Feature and are drawn by MarkerTileRenderer. - // Registering their images with the style is both unnecessary and extremely - // expensive for large data sets (the same bitmap may otherwise be added tens of - // thousands of times during a style reload). - if (entity.marker == null) return@forEach - nativeMarkerCount++ - val icon = entity.state.icon ?: return@forEach - val iconKey = icon.hashCode().toString() - if (!styleIcons.containsKey(iconKey)) { - styleIcons[iconKey] = iconBitmapCache[iconKey] ?: icon.toBitmapIcon().bitmap - } - } - - styleIcons.forEach { (iconKey, bitmap) -> - try { - style.addImage(iconKey, bitmap, false) - } catch (_: Exception) { - } - iconBitmapCache[iconKey] = bitmap - } - } - - private fun decrementIconRef(iconKey: String) { - if (iconKey == Prop.DEFAULT_MARKER_ID) return - val next = (iconRefCounter[iconKey] ?: 0) - 1 - if (next <= 0) { - iconRefCounter.remove(iconKey) - // Mappls can render one frame behind GeoJSON source updates during marker animation. - // Keep images briefly after last use so icon-image references never point at a missing image. - pendingStyleImageRemovals[iconKey] = System.currentTimeMillis() + STYLE_IMAGE_REMOVAL_GRACE_MS - } else { - iconRefCounter[iconKey] = next - } - } - - private fun incrementIconRef(iconKey: String) { - if (iconKey == Prop.DEFAULT_MARKER_ID) return - pendingStyleImageRemovals.remove(iconKey) - iconRefCounter[iconKey] = (iconRefCounter[iconKey] ?: 0) + 1 - } - - override fun setMarkerVisible( - markerEntity: MarkerEntityInterface, - visible: Boolean, - ) { - markerEntity.visible = visible - redraw() - } - - override fun setMarkerPosition( - markerEntity: MarkerEntityInterface, - position: GeoPoint, - ) { - val entities = markerManager.allEntities() - val props = (markerEntity.marker?.properties() ?: JsonObject()).deepCopy() - props.addProperty(Prop.Z_INDEX, MarkerDrawOrder.of(markerEntity.state.zIndex, position)) - val feature = - Feature.fromGeometry( - position.toPoint(), - props, - "marker-${markerEntity.state.id}", - ) - markerEntity.marker = feature - val features = - entities.map { - if (it.state.id == markerEntity.state.id) { - feature - } else { - it.marker - } - } - // Execute directly instead of launching a new coroutine - holder.map.style?.let { style -> - val styleSource = style.getSourceAs(markerLayer.sourceId) - styleSource?.setGeoJson(FeatureCollection.fromFeatures(features)) - } - } - - override suspend fun onAdd( - data: List, - ): List = - withContext(Dispatchers.Main) { - val style = holder.map.style ?: return@withContext emptyList() - - data.forEach { - it.state.icon?.let { icon -> - val iconKey = icon.hashCode().toString() - try { - style.addImage(iconKey, it.bitmapIcon.bitmap, false) - } catch (_: Exception) { - } - iconBitmapCache[iconKey] = it.bitmapIcon.bitmap - if (!iconRefCounter.contains(iconKey)) iconRefCounter[iconKey] = 0 - } - } - - data.map { - val featureId = "marker-${it.state.id}" - val position = GeoPoint.from(it.state.position).toPoint() - val properties = - JsonObject().apply { - if (it.state.icon != null) { - it.state.icon?.let { icon -> - val iconKey = icon.hashCode().toString() - incrementIconRef(iconKey) - addProperty(Prop.ICON_ID, iconKey) - // icon offset property - add(Prop.ICON_ANCHOR, createIconOffset(icon)) - } - } else { - addProperty(Prop.ICON_ID, Prop.DEFAULT_MARKER_ID) - add(Prop.ICON_ANCHOR, getDefaultIconOffsetProperty()) - } - // We don't use the Mappls SDK's scaling system - // addProperty(Prop.SCALE, 1.0) - addProperty(Prop.Z_INDEX, MarkerDrawOrder.of(it.state.zIndex, it.state.position)) - } - Feature.fromGeometry(position, properties, featureId) - } - } - - private fun getDefaultIconOffsetProperty(): JsonArray = createIconOffset(defaultMarkerIcon) - - private fun createIconOffset(icon: BitmapIcon): JsonArray = - JsonArray().apply { - add(-(icon.size.width * icon.anchor.x) / ResourceProvider.getDensity()) - add(-(icon.size.height * icon.anchor.y) / ResourceProvider.getDensity()) - } - - private fun createIconOffset(icon: MarkerIconInterface): JsonArray = createIconOffset(icon.toBitmapIcon()) - - override suspend fun onRemove(data: List>) { - data.forEach { entity -> - val iconKey = - entity.marker - ?.properties() - ?.get(Prop.ICON_ID) - ?.asString - ?: entity.state.icon - ?.hashCode() - ?.toString() - if (iconKey != null) { - decrementIconRef(iconKey) - } - } - } - - fun drawDragLayer() { - holder.map.style?.let { - coroutine.launch { - dragLayer.draw(it) - } - } - } - - fun redraw() { - val entities = markerManager.allEntities() - // Get style from controller to use the same instance - holder.map.style?.let { - coroutine.launch { - markerLayer.draw(entities, it) - } - } - } - - override suspend fun onPostProcess() { - val target = markerManager.allEntities().filter { !it.tiling } - - // withContext(Dispatchers.Main) below is a real cross-thread hop when onPostProcess() - // is invoked from a background ingest dispatcher (as the React Native wrapper does for - // large marker batches) rather than already running on Main (as the native Compose - // sample does). That hop, immediately following a large tiled-marker ingest, lines up - // with severe GC stalls on-device even though the Main-side work below is a few ms at - // most - so skip the hop entirely when there's nothing for it to do. - if (markerLayer.wouldSkipDraw(target) && pendingStyleImageRemovals.isEmpty()) { - return - } - - return withContext(Dispatchers.Main) { - val style = holder.map.style ?: return@withContext - markerLayer.draw(target, style) - yield() - - val now = System.currentTimeMillis() - val expired = - pendingStyleImageRemovals - .asSequence() - .filter { (_, deadline) -> deadline <= now } - .map { (key, _) -> key } - .toList() - - expired.forEach { iconKey -> - if (iconRefCounter.containsKey(iconKey)) { - pendingStyleImageRemovals.remove(iconKey) - return@forEach - } - try { - style.removeImage(iconKey) - } catch (_: Exception) { - } finally { - pendingStyleImageRemovals.remove(iconKey) - iconBitmapCache.remove(iconKey) - } - } - } - } - - override suspend fun onChange( - data: List>, - ): List = - withContext(Dispatchers.Main) { - val style = holder.map.style ?: return@withContext emptyList() - - data.map { params -> - val prevFinger = params.prev.fingerPrint - val currFinger = params.current.fingerPrint - val prevProperties = params.prev.marker?.properties() - - val properties = - JsonObject().apply { - // No additional scaling needed - bitmap is created with device density - // and Bitmap.density is set to prevent Mappls's automatic scaling - // addProperty(Prop.SCALE, 1.0) - if (currFinger.icon == prevFinger.icon) { - addProperty( - Prop.ICON_ID, - prevProperties?.get(Prop.ICON_ID)?.asString ?: Prop.DEFAULT_MARKER_ID, - ) - - add( - Prop.ICON_ANCHOR, - prevProperties?.get(Prop.ICON_ANCHOR) ?: getDefaultIconOffsetProperty(), - ) - } else { - val prevIconKey = - prevProperties - ?.get(Prop.ICON_ID) - ?.asString - ?: params.prev.state.icon - ?.hashCode() - ?.toString() - ?: Prop.DEFAULT_MARKER_ID - decrementIconRef(prevIconKey) - - if (currFinger.icon == null) { - addProperty(Prop.ICON_ID, Prop.DEFAULT_MARKER_ID) - add(Prop.ICON_ANCHOR, getDefaultIconOffsetProperty()) - } else { - params.current.state.icon?.let { icon -> - // icon id - val iconKey = icon.hashCode().toString() - style.addImage(iconKey, params.bitmapIcon.bitmap, false) - iconBitmapCache[iconKey] = params.bitmapIcon.bitmap - if (!iconRefCounter.contains(iconKey)) iconRefCounter[iconKey] = 0 - incrementIconRef(iconKey) - addProperty(Prop.ICON_ID, iconKey) - add(Prop.ICON_ANCHOR, createIconOffset(icon)) - } - } - } - addProperty( - Prop.Z_INDEX, - MarkerDrawOrder.of(params.current.state.zIndex, params.current.state.position), - ) - } - - val position = - GeoPoint.from(params.current.state.position).toPoint() - val featureId = "marker-${params.current.state.id}" - Feature.fromGeometry(position, properties, featureId) - } - } - - /** - * ドラッグ対象の入れ替え。 - * - * ドラッグ中のマーカーは通常のレイヤ([markerLayer])から外して専用の - * [dragLayer] へ移す。そうしないと GeoJSON ソースを丸ごと描き直すたびに - * 指の位置と食い違う。以前は各プロバイダのマーカーコントローラと - * ストラテジ用イベントコントローラに同じものが 2 本ずつあった。 - */ - override fun onDragSelectionChanged( - previous: MarkerEntityInterface?, - current: MarkerEntityInterface?, - ) { - if (current == null) { - previous?.let { - dragLayer.updatePosition(GeoPoint.from(it.state.position)) - dragLayer.selected = null - drawDragLayer() - markerManager.registerEntity(it) - redraw() - } - return - } - markerManager.removeEntity(current.state.id) - dragLayer.selected = current - dragLayer.updatePosition(GeoPoint.from(current.state.position)) - redraw() - drawDragLayer() - } - - override fun onDragPositionChanged(position: GeoPointInterface) { - dragLayer.updatePosition(GeoPoint.from(position)) - drawDragLayer() - } -} - -private const val STYLE_IMAGE_REMOVAL_GRACE_MS: Long = 1500L +package com.mapconductor.mappls.marker + +import com.google.gson.JsonArray +import com.google.gson.JsonObject +import com.mapconductor.core.ResourceProvider +import com.mapconductor.core.features.GeoPoint +import com.mapconductor.core.features.GeoPointInterface +import com.mapconductor.core.marker.AbstractMarkerOverlayRenderer +import com.mapconductor.core.marker.BitmapIcon +import com.mapconductor.core.marker.DefaultMarkerIcon +import com.mapconductor.core.marker.MarkerDrawOrder +import com.mapconductor.core.marker.MarkerEntityInterface +import com.mapconductor.core.marker.MarkerIconInterface +import com.mapconductor.core.marker.MarkerManager +import com.mapconductor.core.marker.MarkerOverlayRendererInterface +import com.mapconductor.mappls.MapplsActualMarker +import com.mapconductor.mappls.MapplsMapViewHolderInterface +import com.mapconductor.mappls.toPoint +import com.mappls.sdk.geojson.Feature +import com.mappls.sdk.geojson.FeatureCollection +import android.graphics.Bitmap +import android.os.SystemClock +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import kotlinx.coroutines.yield + +class MapplsMarkerOverlayRenderer( + holder: MapplsMapViewHolderInterface, + val markerManager: MarkerManager, + val markerLayer: MarkerLayer, + val dragLayer: MarkerDragLayer, + coroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), +) : AbstractMarkerOverlayRenderer( + holder = holder, + coroutine = coroutine, + ) { + override val supportsAnimationOverlay: Boolean = true + + private val iconRefCounter: MutableMap = mutableMapOf() + private val pendingStyleImageRemovals: MutableMap = mutableMapOf() + private val iconBitmapCache: MutableMap = mutableMapOf() + private val defaultMarkerIcon: BitmapIcon = DefaultMarkerIcon().toBitmapIcon() + + object Prop { + const val ICON_ID = "icon_id" + const val DEFAULT_MARKER_ID = "default" + const val SCALE = "scale" + const val ICON_ANCHOR = "icon-offset" + const val Z_INDEX = "zIndex" + } + + object IconAnchor { + const val CENTER = "center" + const val LEFT = "left" + const val RIGHT = "right" + const val BOTTOM = "bottom" + const val TOP_LEFT = "top-left" + const val TOP_RIGHT = "top-right" + const val BOTTOM_LEFT = "bottom-left" + const val BOTTOM_RIGHT = "bottom-right" + } + + object IconTranslateAnchor { + const val MAP = "map" + const val VIEWPORT = "viewport" + } + + init { + val style = holder.map.style + if (style != null) { + style.addImage(Prop.DEFAULT_MARKER_ID, defaultMarkerIcon.bitmap) + } else { + holder.map.getStyle { style -> + style.addImage(Prop.DEFAULT_MARKER_ID, defaultMarkerIcon.bitmap) + } + } + } + + // Ensure marker images exist on the given style (used after style reload). + fun ensureDefaultIcon(style: com.mappls.sdk.maps.Style) { + ensureStyleImages(style) + } + + fun ensureStyleImages(style: com.mappls.sdk.maps.Style) { + val startedAt = SystemClock.elapsedRealtime() + try { + style.addImage(Prop.DEFAULT_MARKER_ID, defaultMarkerIcon.bitmap) + } catch (_: Exception) { + } + + val entities = markerManager.allEntities() + val styleIcons = linkedMapOf() + var nativeMarkerCount = 0 + entities.forEach { entity -> + // Tiled markers have no Mappls Feature and are drawn by MarkerTileRenderer. + // Registering their images with the style is both unnecessary and extremely + // expensive for large data sets (the same bitmap may otherwise be added tens of + // thousands of times during a style reload). + if (entity.marker == null) return@forEach + nativeMarkerCount++ + val icon = entity.state.icon ?: return@forEach + val iconKey = icon.hashCode().toString() + if (!styleIcons.containsKey(iconKey)) { + styleIcons[iconKey] = iconBitmapCache[iconKey] ?: icon.toBitmapIcon().bitmap + } + } + + styleIcons.forEach { (iconKey, bitmap) -> + try { + style.addImage(iconKey, bitmap, false) + } catch (_: Exception) { + } + iconBitmapCache[iconKey] = bitmap + } + } + + private fun decrementIconRef(iconKey: String) { + if (iconKey == Prop.DEFAULT_MARKER_ID) return + val next = (iconRefCounter[iconKey] ?: 0) - 1 + if (next <= 0) { + iconRefCounter.remove(iconKey) + // Mappls can render one frame behind GeoJSON source updates during marker animation. + // Keep images briefly after last use so icon-image references never point at a missing image. + pendingStyleImageRemovals[iconKey] = System.currentTimeMillis() + STYLE_IMAGE_REMOVAL_GRACE_MS + } else { + iconRefCounter[iconKey] = next + } + } + + private fun incrementIconRef(iconKey: String) { + if (iconKey == Prop.DEFAULT_MARKER_ID) return + pendingStyleImageRemovals.remove(iconKey) + iconRefCounter[iconKey] = (iconRefCounter[iconKey] ?: 0) + 1 + } + + override fun setMarkerVisible( + markerEntity: MarkerEntityInterface, + visible: Boolean, + ) { + markerEntity.visible = visible + redraw() + } + + override fun setMarkerPosition( + markerEntity: MarkerEntityInterface, + position: GeoPoint, + ) { + val entities = markerManager.allEntities() + val props = (markerEntity.marker?.properties() ?: JsonObject()).deepCopy() + props.addProperty(Prop.Z_INDEX, MarkerDrawOrder.of(markerEntity.state.zIndex, position, drawOrderFrame)) + val feature = + Feature.fromGeometry( + position.toPoint(), + props, + "marker-${markerEntity.state.id}", + ) + markerEntity.marker = feature + val features = + entities.map { + if (it.state.id == markerEntity.state.id) { + feature + } else { + it.marker + } + } + // Execute directly instead of launching a new coroutine + holder.map.style?.let { style -> + val styleSource = style.getSourceAs(markerLayer.sourceId) + styleSource?.setGeoJson(FeatureCollection.fromFeatures(features)) + } + } + + override suspend fun onAdd( + data: List, + ): List = + withContext(Dispatchers.Main) { + val style = holder.map.style ?: return@withContext emptyList() + + data.forEach { + it.state.icon?.let { icon -> + val iconKey = icon.hashCode().toString() + try { + style.addImage(iconKey, it.bitmapIcon.bitmap, false) + } catch (_: Exception) { + } + iconBitmapCache[iconKey] = it.bitmapIcon.bitmap + if (!iconRefCounter.contains(iconKey)) iconRefCounter[iconKey] = 0 + } + } + + data.map { + val featureId = "marker-${it.state.id}" + val position = GeoPoint.from(it.state.position).toPoint() + val properties = + JsonObject().apply { + if (it.state.icon != null) { + it.state.icon?.let { icon -> + val iconKey = icon.hashCode().toString() + incrementIconRef(iconKey) + addProperty(Prop.ICON_ID, iconKey) + // icon offset property + add(Prop.ICON_ANCHOR, createIconOffset(icon)) + } + } else { + addProperty(Prop.ICON_ID, Prop.DEFAULT_MARKER_ID) + add(Prop.ICON_ANCHOR, getDefaultIconOffsetProperty()) + } + // We don't use the Mappls SDK's scaling system + // addProperty(Prop.SCALE, 1.0) + addProperty(Prop.Z_INDEX, drawOrderOf(it.state)) + } + Feature.fromGeometry(position, properties, featureId) + } + } + + private fun getDefaultIconOffsetProperty(): JsonArray = createIconOffset(defaultMarkerIcon) + + private fun createIconOffset(icon: BitmapIcon): JsonArray = + JsonArray().apply { + add(-(icon.size.width * icon.anchor.x) / ResourceProvider.getDensity()) + add(-(icon.size.height * icon.anchor.y) / ResourceProvider.getDensity()) + } + + private fun createIconOffset(icon: MarkerIconInterface): JsonArray = createIconOffset(icon.toBitmapIcon()) + + override suspend fun onRemove(data: List>) { + data.forEach { entity -> + val iconKey = + entity.marker + ?.properties() + ?.get(Prop.ICON_ID) + ?.asString + ?: entity.state.icon + ?.hashCode() + ?.toString() + if (iconKey != null) { + decrementIconRef(iconKey) + } + } + } + + fun drawDragLayer() { + holder.map.style?.let { + coroutine.launch { + dragLayer.draw(it) + } + } + } + + fun redraw() { + val entities = markerManager.allEntities() + // Get style from controller to use the same instance + holder.map.style?.let { + coroutine.launch { + markerLayer.draw(entities, it) + } + } + } + + // 地図が回ったら、各フィーチャーの並び順キー(symbol-sort-key)を付け直して流し直す。 + override suspend fun applyDrawOrder(entities: List>) { + val target = entities.filter { !it.tiling } + withContext(Dispatchers.Main) { + target.forEach { entity -> + entity.marker?.properties()?.addProperty(Prop.Z_INDEX, drawOrderOf(entity.state)) + } + val style = holder.map.style ?: return@withContext + markerLayer.draw(target, style) + } + } + + override suspend fun onPostProcess() { + val target = markerManager.allEntities().filter { !it.tiling } + + // withContext(Dispatchers.Main) below is a real cross-thread hop when onPostProcess() + // is invoked from a background ingest dispatcher (as the React Native wrapper does for + // large marker batches) rather than already running on Main (as the native Compose + // sample does). That hop, immediately following a large tiled-marker ingest, lines up + // with severe GC stalls on-device even though the Main-side work below is a few ms at + // most - so skip the hop entirely when there's nothing for it to do. + if (markerLayer.wouldSkipDraw(target) && pendingStyleImageRemovals.isEmpty()) { + return + } + + return withContext(Dispatchers.Main) { + val style = holder.map.style ?: return@withContext + markerLayer.draw(target, style) + yield() + + val now = System.currentTimeMillis() + val expired = + pendingStyleImageRemovals + .asSequence() + .filter { (_, deadline) -> deadline <= now } + .map { (key, _) -> key } + .toList() + + expired.forEach { iconKey -> + if (iconRefCounter.containsKey(iconKey)) { + pendingStyleImageRemovals.remove(iconKey) + return@forEach + } + try { + style.removeImage(iconKey) + } catch (_: Exception) { + } finally { + pendingStyleImageRemovals.remove(iconKey) + iconBitmapCache.remove(iconKey) + } + } + } + } + + override suspend fun onChange( + data: List>, + ): List = + withContext(Dispatchers.Main) { + val style = holder.map.style ?: return@withContext emptyList() + + data.map { params -> + val prevFinger = params.prev.fingerPrint + val currFinger = params.current.fingerPrint + val prevProperties = params.prev.marker?.properties() + + val properties = + JsonObject().apply { + // No additional scaling needed - bitmap is created with device density + // and Bitmap.density is set to prevent Mappls's automatic scaling + // addProperty(Prop.SCALE, 1.0) + if (currFinger.icon == prevFinger.icon) { + addProperty( + Prop.ICON_ID, + prevProperties?.get(Prop.ICON_ID)?.asString ?: Prop.DEFAULT_MARKER_ID, + ) + + add( + Prop.ICON_ANCHOR, + prevProperties?.get(Prop.ICON_ANCHOR) ?: getDefaultIconOffsetProperty(), + ) + } else { + val prevIconKey = + prevProperties + ?.get(Prop.ICON_ID) + ?.asString + ?: params.prev.state.icon + ?.hashCode() + ?.toString() + ?: Prop.DEFAULT_MARKER_ID + decrementIconRef(prevIconKey) + + if (currFinger.icon == null) { + addProperty(Prop.ICON_ID, Prop.DEFAULT_MARKER_ID) + add(Prop.ICON_ANCHOR, getDefaultIconOffsetProperty()) + } else { + params.current.state.icon?.let { icon -> + // icon id + val iconKey = icon.hashCode().toString() + style.addImage(iconKey, params.bitmapIcon.bitmap, false) + iconBitmapCache[iconKey] = params.bitmapIcon.bitmap + if (!iconRefCounter.contains(iconKey)) iconRefCounter[iconKey] = 0 + incrementIconRef(iconKey) + addProperty(Prop.ICON_ID, iconKey) + add(Prop.ICON_ANCHOR, createIconOffset(icon)) + } + } + } + addProperty( + Prop.Z_INDEX, + drawOrderOf(params.current.state), + ) + } + + val position = + GeoPoint.from(params.current.state.position).toPoint() + val featureId = "marker-${params.current.state.id}" + Feature.fromGeometry(position, properties, featureId) + } + } + + /** + * ドラッグ対象の入れ替え。 + * + * ドラッグ中のマーカーは通常のレイヤ([markerLayer])から外して専用の + * [dragLayer] へ移す。そうしないと GeoJSON ソースを丸ごと描き直すたびに + * 指の位置と食い違う。以前は各プロバイダのマーカーコントローラと + * ストラテジ用イベントコントローラに同じものが 2 本ずつあった。 + */ + override fun onDragSelectionChanged( + previous: MarkerEntityInterface?, + current: MarkerEntityInterface?, + ) { + if (current == null) { + previous?.let { + dragLayer.updatePosition(GeoPoint.from(it.state.position)) + dragLayer.selected = null + drawDragLayer() + markerManager.registerEntity(it) + redraw() + } + return + } + markerManager.removeEntity(current.state.id) + dragLayer.selected = current + dragLayer.updatePosition(GeoPoint.from(current.state.position)) + redraw() + drawDragLayer() + } + + override fun onDragPositionChanged(position: GeoPointInterface) { + dragLayer.updatePosition(GeoPoint.from(position)) + drawDragLayer() + } +} + +private const val STYLE_IMAGE_REMOVAL_GRACE_MS: Long = 1500L From bf31187b89710ed008f1dc3610718525f8b378cc Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Wed, 11 Nov 2026 22:29:03 -0800 Subject: [PATCH 25/27] Apply camera paddings and report fov on Mappls Same as MapLibre: paddings go to the native camera padding (px) on move, animate and the initial camera and are read back from it. fov is 36.87 (measured 36.9 on TB520FU). --- api/android-for-mappls.api | 13 +++- .../mapconductor/mappls/MapCameraPosition.kt | 59 ++++++++++++++++--- .../com/mapconductor/mappls/MapplsMapView.kt | 2 +- .../mappls/MapplsViewControllerCamera.kt | 7 ++- 4 files changed, 69 insertions(+), 12 deletions(-) diff --git a/api/android-for-mappls.api b/api/android-for-mappls.api index a0beb78..f570eca 100644 --- a/api/android-for-mappls.api +++ b/api/android-for-mappls.api @@ -10,19 +10,27 @@ public final class com.mapconductor.mappls.GeoRectBoundsKt { public static final com.mapconductor.core.features.GeoRectBounds toGeoRectBounds(com.mappls.sdk.maps.geometry.LatLngBounds); } public final class com.mapconductor.mappls.MapCameraPositionKt { + public static final double MAPPLS_VERTICAL_FOV; + public static final double[] toMapplsPadding(com.mapconductor.core.map.MapPaddingsInterface, float); + public static final com.mapconductor.core.map.MapPaddings toMapPaddings(double[], float); public static final com.mappls.sdk.maps.camera.CameraPosition toCameraPosition(com.mapconductor.core.map.MapCameraPosition); + public static final com.mappls.sdk.maps.camera.CameraPosition toCameraPosition(com.mapconductor.core.map.MapCameraPosition, java.lang.Float); public static final com.mapconductor.core.map.MapCameraPosition from(com.mapconductor.core.map.MapCameraPosition$Companion, com.mapconductor.core.map.MapCameraPositionInterface); public static final com.mapconductor.core.map.MapCameraPosition toMapCameraPosition(com.mappls.sdk.maps.camera.CameraPosition); public static final com.mapconductor.core.map.MapCameraPosition toMapCameraPosition(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double); + public static final com.mapconductor.core.map.MapCameraPosition toMapCameraPosition(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double, java.lang.Float); } public final class com.mapconductor.mappls.MapplsCameraStateSnapshot { - public com.mapconductor.mappls.MapplsCameraStateSnapshot(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double); + public com.mapconductor.mappls.MapplsCameraStateSnapshot(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double, java.lang.Float); + public com.mapconductor.mappls.MapplsCameraStateSnapshot(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double, java.lang.Float, int, kotlin.jvm.internal.DefaultConstructorMarker); public final com.mappls.sdk.maps.camera.CameraPosition getCameraPosition(); public final java.lang.Double getLogicalTiltHint(); + public final java.lang.Float getDensity(); public final com.mapconductor.core.map.MapCameraPosition toMapCameraPosition(); public final com.mappls.sdk.maps.camera.CameraPosition component1(); public final java.lang.Double component2(); - public final com.mapconductor.mappls.MapplsCameraStateSnapshot copy(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double); + public final java.lang.Float component3(); + public final com.mapconductor.mappls.MapplsCameraStateSnapshot copy(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double, java.lang.Float); public java.lang.String toString(); public int hashCode(); public boolean equals(java.lang.Object); @@ -171,6 +179,7 @@ public final class com.mapconductor.mappls.MapplsViewController extends com.mapc } public final class com.mapconductor.mappls.MapplsViewControllerCameraKt { public static final com.mapconductor.core.map.MapCameraPosition readLogicalCameraPosition(com.mapconductor.mappls.MapplsViewController); + public static final float density(com.mapconductor.mappls.MapplsViewController); public static final com.mapconductor.core.map.MapCameraPosition getMapCameraPosition(com.mapconductor.mappls.MapplsViewController, com.mapconductor.core.map.MapCameraPositionInterface); public static final void handleMoveCamera(com.mapconductor.mappls.MapplsViewController, com.mapconductor.core.map.MapCameraPosition); public static final void handleAnimateCamera(com.mapconductor.mappls.MapplsViewController, com.mapconductor.core.map.MapCameraPosition, long); diff --git a/src/main/java/com/mapconductor/mappls/MapCameraPosition.kt b/src/main/java/com/mapconductor/mappls/MapCameraPosition.kt index c17ae2f..f4c9a81 100644 --- a/src/main/java/com/mapconductor/mappls/MapCameraPosition.kt +++ b/src/main/java/com/mapconductor/mappls/MapCameraPosition.kt @@ -4,6 +4,8 @@ import com.mapconductor.core.features.GeoPoint import com.mapconductor.core.map.CameraBearing import com.mapconductor.core.map.MapCameraPosition import com.mapconductor.core.map.MapCameraPositionInterface +import com.mapconductor.core.map.MapPaddings +import com.mapconductor.core.map.MapPaddingsInterface import com.mapconductor.core.spherical.Spherical import com.mapconductor.mappls.zoom.ZoomAltitudeConverter import com.mappls.sdk.maps.camera.CameraPosition @@ -12,10 +14,40 @@ import kotlin.math.cos import kotlin.math.tan private val converter = ZoomAltitudeConverter() + +/** + * Mappls のカメラの縦方向の視野角(度)。Mappls は MapLibre Native 派生で、既定値は地図の大きさに + * よらず一定(焦点距離 = 地図の高さ × 1.5)。TB520FU で 36.9° を実測。 + */ +internal const val MAPPLS_VERTICAL_FOV = 36.87 + +/** dp のパディング → Mappls の px のパディング(left, top, right, bottom)。 */ +internal fun MapPaddingsInterface.toMapplsPadding(density: Float): DoubleArray = + doubleArrayOf(left * density, top * density, right * density, bottom * density) + +/** Mappls の px のパディング(left, top, right, bottom)→ dp のパディング。 */ +internal fun DoubleArray.toMapPaddings(density: Float): MapPaddings? { + if (size < 4 || density <= 0f) return null + return MapPaddings( + top = this[1] / density, + left = this[0] / density, + bottom = this[3] / density, + right = this[2] / density, + ) +} + private const val NEGATIVE_TILT_TARGET_DISTANCE_SCALE = 1.83 private const val NEGATIVE_TILT_ZOOM_OFFSET_AT_MAX_TILT = -0.9 -fun MapCameraPosition.toCameraPosition(): CameraPosition { +fun MapCameraPosition.toCameraPosition(): CameraPosition = toCameraPosition(density = null) + +/** + * [density] があれば [MapCameraPosition.paddings] を Mappls のパディングとして渡す。 + * Mappls はパディングを除いた領域の中央にカメラの中心を置き、tilt の遠近もエンジンが解く。 + * Mappls のパディングは次に変えるまで残るので、null(未指定)のときは渡さない。 + */ +internal fun MapCameraPosition.toCameraPosition(density: Float?): CameraPosition { + val padding = if (density != null) paddings?.toMapplsPadding(density) else null if (tilt >= 0) { return CameraPosition .Builder() @@ -23,8 +55,7 @@ fun MapCameraPosition.toCameraPosition(): CameraPosition { .zoom(ZoomAltitudeConverter.googleZoomToMapplsZoom(zoom)) .tilt(tilt) .bearing(CameraBearing.toNativeHeading(bearing)) - // TODO: -// .padding(paddings?.toEdgeInsects()) + .apply { padding?.let { padding(it) } } .build() } else { // tilt < 0: Mappls cannot represent an upward pitch directly. @@ -47,8 +78,7 @@ fun MapCameraPosition.toCameraPosition(): CameraPosition { .zoom(ZoomAltitudeConverter.googleZoomToMapplsZoom(adjustedZoom)) .tilt(tiltAbsDeg) .bearing(CameraBearing.toNativeHeading(bearing)) - // TODO: -// .padding(paddings?.toEdgeInsects()) + .apply { padding?.let { padding(it) } } .build() } } @@ -62,7 +92,9 @@ fun MapCameraPosition.Companion.from(cameraPosition: MapCameraPositionInterface) zoom = cameraPosition.zoom, bearing = cameraPosition.bearing, tilt = cameraPosition.tilt, + paddings = cameraPosition.paddings, visibleRegion = cameraPosition.visibleRegion, + fov = cameraPosition.fov, ) } @@ -71,11 +103,20 @@ fun CameraPosition.toMapCameraPosition() = toMapCameraPosition(logicalTiltHint = internal data class MapplsCameraStateSnapshot( val cameraPosition: CameraPosition, val logicalTiltHint: Double?, + val density: Float? = null, ) { - fun toMapCameraPosition(): MapCameraPosition = cameraPosition.toMapCameraPosition(logicalTiltHint) + fun toMapCameraPosition(): MapCameraPosition = cameraPosition.toMapCameraPosition(logicalTiltHint, density) } -internal fun CameraPosition.toMapCameraPosition(logicalTiltHint: Double?): MapCameraPosition { +internal fun CameraPosition.toMapCameraPosition(logicalTiltHint: Double?): MapCameraPosition = + toMapCameraPosition(logicalTiltHint, density = null) + +/** [density] があれば Mappls のパディングを dp に直して paddings として返す。 */ +internal fun CameraPosition.toMapCameraPosition( + logicalTiltHint: Double?, + density: Float?, +): MapCameraPosition { + val paddings = density?.let { d -> padding?.toMapPaddings(d) } ?: MapPaddings.Zeros val pitch = tilt val pitchAbsDeg = abs(pitch).coerceIn(0.0, 60.0) @@ -85,7 +126,9 @@ internal fun CameraPosition.toMapCameraPosition(logicalTiltHint: Double?): MapCa zoom = ZoomAltitudeConverter.mapplsZoomToGoogleZoom(zoom), bearing = CameraBearing.bearingFromNativeHeading(bearing), tilt = pitch, + paddings = paddings, visibleRegion = null, + fov = MAPPLS_VERTICAL_FOV, ) } @@ -107,6 +150,8 @@ internal fun CameraPosition.toMapCameraPosition(logicalTiltHint: Double?): MapCa zoom = originalGoogleZoom, bearing = CameraBearing.bearingFromNativeHeading(bear), tilt = -pitchAbsDeg, + paddings = paddings, visibleRegion = null, + fov = MAPPLS_VERTICAL_FOV, ) } diff --git a/src/main/java/com/mapconductor/mappls/MapplsMapView.kt b/src/main/java/com/mapconductor/mappls/MapplsMapView.kt index e0ba6c3..1d284f3 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsMapView.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsMapView.kt @@ -89,7 +89,7 @@ fun MapplsMapView( modifier = modifier, viewProvider = { val cameraPosition = - state.cameraPosition.toCameraPosition() + state.cameraPosition.toCameraPosition(context.resources.displayMetrics.density) val mapInitOptions = MapplsMapOptions .createFromAttributes(context) diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewControllerCamera.kt b/src/main/java/com/mapconductor/mappls/MapplsViewControllerCamera.kt index 8e4e6ac..aa93959 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewControllerCamera.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewControllerCamera.kt @@ -20,8 +20,11 @@ internal fun MapplsViewController.readLogicalCameraPosition(): MapCameraPosition MapplsCameraStateSnapshot( cameraPosition = holder.map.cameraPosition, logicalTiltHint = lastLogicalCameraPosition?.tilt, + density = density(), ).toMapCameraPosition() +internal fun MapplsViewController.density(): Float = holder.mapView.resources.displayMetrics.density + internal fun MapplsViewController.getMapCameraPosition(camera: MapCameraPositionInterface): MapCameraPosition? { // 4 隅の逆投影は全プロバイダ共通なのでコアの buildVisibleRegion を使う。 val visibleRegion = holder.buildVisibleRegion() ?: return null @@ -31,7 +34,7 @@ internal fun MapplsViewController.getMapCameraPosition(camera: MapCameraPosition internal fun MapplsViewController.handleMoveCamera(position: MapCameraPosition) { lastLogicalCameraPosition = position mainCoroutine.launch { - val cameraPos = position.toCameraPosition() + val cameraPos = position.toCameraPosition(density()) val cameraUpdate = CameraUpdateFactory .newCameraPosition(cameraPos) @@ -46,7 +49,7 @@ internal fun MapplsViewController.handleAnimateCamera( ) { lastLogicalCameraPosition = position mainCoroutine.launch { - val cameraPos = position.toCameraPosition() + val cameraPos = position.toCameraPosition(density()) val cameraUpdate = CameraUpdateFactory .newCameraPosition(cameraPos) From a37cfdd42bbf104fc20d81157764ebc8292b6e2d Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Thu, 12 Nov 2026 00:55:18 -0800 Subject: [PATCH 26/27] Emulate camera paddings by shifting the centre Native padding widens the frustum upward. Under tilt a large top padding reaches past the horizon: the engine loads tiles out to it and stalls, and MapLibre also lowers the pitch (60 -> 55.4 deg) and clamps the padding. The target is now placed at the padded centre by moving the camera centre with CameraPaddingEmulation and the provider's fov; native padding is always zero. Read-back undoes the shift, and padding on the initial camera is applied once the map has a size. --- api/android-for-mappls.api | 2 + .../com/mapconductor/mappls/MapplsMapView.kt | 780 ++++++++-------- .../mappls/MapplsViewController.kt | 871 +++++++++--------- .../mappls/MapplsViewControllerCamera.kt | 77 +- 4 files changed, 901 insertions(+), 829 deletions(-) diff --git a/api/android-for-mappls.api b/api/android-for-mappls.api index 2819b26..27ae1c3 100644 --- a/api/android-for-mappls.api +++ b/api/android-for-mappls.api @@ -179,6 +179,8 @@ public final class com.mapconductor.mappls.MapplsViewController extends com.mapc } public final class com.mapconductor.mappls.MapplsViewControllerCameraKt { public static final com.mapconductor.core.map.MapCameraPosition readLogicalCameraPosition(com.mapconductor.mappls.MapplsViewController); + public static final double viewportHeightDp(com.mapconductor.mappls.MapplsViewController); + public static final com.mapconductor.core.map.MapCameraPosition toNativeCamera(com.mapconductor.mappls.MapplsViewController, com.mapconductor.core.map.MapCameraPosition); public static final float density(com.mapconductor.mappls.MapplsViewController); public static final com.mapconductor.core.map.MapCameraPosition getMapCameraPosition(com.mapconductor.mappls.MapplsViewController, com.mapconductor.core.map.MapCameraPositionInterface); public static final void handleMoveCamera(com.mapconductor.mappls.MapplsViewController, com.mapconductor.core.map.MapCameraPosition); diff --git a/src/main/java/com/mapconductor/mappls/MapplsMapView.kt b/src/main/java/com/mapconductor/mappls/MapplsMapView.kt index 1d284f3..77552ad 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsMapView.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsMapView.kt @@ -1,389 +1,391 @@ -package com.mapconductor.mappls - -import androidx.compose.runtime.Composable -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.ui.Modifier -import androidx.compose.ui.platform.LocalContext -import com.mapconductor.compose.map.MapViewBase -import com.mapconductor.core.OnCameraMoveHandler -import com.mapconductor.core.OnMapEventHandler -import com.mapconductor.core.OnMapLoadedHandler -import com.mapconductor.core.circle.CircleManager -import com.mapconductor.core.map.CameraRestriction -import com.mapconductor.core.map.MapCameraPositionInterface -import com.mapconductor.core.map.MapViewStyle -import com.mapconductor.core.map.MutableMapServiceRegistry -import com.mapconductor.core.marker.MarkerEventControllerInterface -import com.mapconductor.core.marker.MarkerManager -import com.mapconductor.core.marker.MarkerOverlayRendererInterface -import com.mapconductor.core.marker.MarkerRenderingStrategyInterface -import com.mapconductor.core.marker.MarkerRenderingSupport -import com.mapconductor.core.marker.MarkerRenderingSupportKey -import com.mapconductor.core.marker.MarkerTilingOptions -import com.mapconductor.core.marker.StrategyMarkerController -import com.mapconductor.core.polygon.PolygonManager -import com.mapconductor.core.polyline.PolylineManager -import com.mapconductor.mappls.circle.MapplsCircleController -import com.mapconductor.mappls.circle.MapplsCircleLayer -import com.mapconductor.mappls.circle.MapplsCircleOverlayRenderer -import com.mapconductor.mappls.groundimage.MapplsGroundImageController -import com.mapconductor.mappls.groundimage.MapplsGroundImageOverlayRenderer -import com.mapconductor.mappls.marker.MapplsMarkerController -import com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer -import com.mapconductor.mappls.marker.MarkerDragLayer -import com.mapconductor.mappls.marker.MarkerLayer -import com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer -import com.mapconductor.mappls.polygon.MapplsPolygonController -import com.mapconductor.mappls.polygon.MapplsPolygonLayer -import com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer -import com.mapconductor.mappls.polyline.MapplsPolylineController -import com.mapconductor.mappls.polyline.MapplsPolylineLayer -import com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer -import com.mapconductor.mappls.raster.MapplsRasterLayerController -import com.mapconductor.mappls.raster.MapplsRasterLayerOverlayRenderer -import com.mappls.sdk.maps.MapView -import com.mappls.sdk.maps.Mappls -import com.mappls.sdk.maps.MapplsMap -import com.mappls.sdk.maps.MapplsMapOptions -import com.mappls.sdk.maps.OnMapReadyCallback -import com.mappls.sdk.maps.Style -import android.app.Activity -import android.content.Context -import android.content.ContextWrapper -import android.util.Log -import kotlinx.coroutines.suspendCancellableCoroutine - -@Composable -fun MapplsMapView( - state: MapplsViewState, - modifier: Modifier = Modifier, - markerTiling: MarkerTilingOptions? = null, - cameraRestriction: CameraRestriction? = null, - sdkInitialize: (suspend (Context) -> Boolean)? = null, - onMapLoaded: OnMapLoadedHandler? = null, - onMapClick: OnMapEventHandler? = null, - onMapLongClick: OnMapEventHandler? = null, - onCameraMoveStart: OnCameraMoveHandler? = null, - onCameraMove: OnCameraMoveHandler? = null, - onCameraMoveEnd: OnCameraMoveHandler? = null, - /** - * How the map looks, when the app states it rather than naming a design. - * - * A vector style *is* the basemap. `com.mapconductor:vectorstyle` builds - * one; what happens underneath depends on this backend and the app does - * not have to know. - */ - style: MapViewStyle? = null, - onStyleDiagnostics: ((List) -> Unit)? = null, - content: (@Composable MapplsMapViewScope.() -> Unit)? = null, -) { - val context = LocalContext.current - val scope = remember { MapplsMapViewScope() } - val registry = remember { scope.buildRegistry() } - val cameraState = remember { mutableStateOf(state.cameraPosition) } - - MapViewBase( - state = state, - cameraState = cameraState, - modifier = modifier, - viewProvider = { - val cameraPosition = - state.cameraPosition.toCameraPosition(context.resources.displayMetrics.density) - val mapInitOptions = - MapplsMapOptions - .createFromAttributes(context) - .camera(cameraPosition) - .textureMode(true) - // Don't set style here - it will be set in holderProvider - - MapView(context, mapInitOptions) - }, - scope = scope, - registry = registry, - onMapLoaded = onMapLoaded, - holderProvider = { mapView -> - suspendCancellableCoroutine { continuation -> - mapView.getMapAsync( - object : OnMapReadyCallback { - override fun onMapReady(map: MapplsMap) { - // 認証が通ると SDK がアカウントの既定スタイルを読み込む。 - // 名前指定があればそのスタイルへ差し替え、読み込み完了後に resume する。 - val designName = state.mapDesignType.styleName - if (designName.isEmpty()) { - map.getStyle { - continuation.resume( - MapplsMapViewHolder(mapView, map), - ) { _, _, _ -> } - } - } else { - map.setMapplsStyle( - designName, - Style.OnStyleLoaded { - continuation.resume( - MapplsMapViewHolder(mapView, map), - ) { _, _, _ -> } - }, - ) - } - } - - override fun onMapError( - code: Int, - message: String?, - ) { - // 認証エラー(コンフィグファイル不一致など)はここへ来る。 - // resume しないので地図は表示されないまま — ログで原因を残す。 - Log.e("Mappls", "Map init error $code: $message") - } - }, - ) - } - }, - controllerProvider = { holder -> - createMapplsViewController( - holder = holder, - markerTiling = markerTiling ?: MarkerTilingOptions.Default, - serviceRegistry = state.serviceRegistry, - ).also { mapController -> - // Store controller reference in holder - mapController.setCameraMoveStartListener { - cameraState.value = it - state.updateCameraPosition(it) - onCameraMoveStart?.invoke(it) - } - mapController.setCameraMoveListener { - cameraState.value = it - state.updateCameraPosition(it) - onCameraMove?.invoke(it) - } - mapController.setCameraMoveEndListener { - cameraState.value = it - state.updateCameraPosition(it) - onCameraMoveEnd?.invoke(it) - } - mapController.setMapClickListener(onMapClick) - mapController.setMapDesignTypeChangeListener(state::onMapDesignTypeChange) - mapController.setMapLongClickListener(onMapLongClick) - cameraRestriction?.let { mapController.setCameraRestriction(it) } - state.setController(mapController) - // Post an initial camera update after layout to compute visibleRegion correctly - holder.mapView.post { mapController.sendInitialCameraUpdate() } - } - }, - sdkInitialize = { - // 外部タイルのホワイトリスト回避(MapplsHttpBridge のコメント参照)は - // 地図生成前に必ず入れる。sdkInitialize を差し替えられても失われないよう - // ここで無条件に呼ぶ。 - MapplsHttpBridge.install() - if (sdkInitialize != null) { - sdkInitialize(context) - } else { - Mappls.getInstance(context) - true - } - }, - // Pass content if it needs to be rendered within the overlay providers in MapViewBase, - // or handle it here if it's specific to MapplsMapView structure before calling MapViewBase. - // For now, assuming content relates to overlay definitions. - style = style, - onStyleDiagnostics = onStyleDiagnostics, - // Never started (onStart is not called), so it is not stopped either -- - // MapView.onStop() would deactivate the shared FileSource the next map - // still uses. Destroying it ends the render thread, whose camera - // listeners otherwise keep the controller and every overlay alive. - onDestroyMapView = { mapView -> mapView.onDestroy() }, - content = content, // This might need adjustment based on how overlays are handled - ) -} - -/** - * Creates the imperative controller graph used by both the Compose MapView and non-Compose hosts - * such as React Native. Keeping this construction here prevents provider-specific layer setup from - * being duplicated by each UI integration. - * - * @param serviceRegistry 登録先のサービスレジストリ。Compose からは `state.serviceRegistry` を渡す - * (react-sdk / ios-sdk と同じく持ち主は state)。React Native / Cordova のような非 Compose - * ホストは state を持たないので、自前のレジストリを渡す。 - */ -fun createMapplsViewController( - holder: MapplsMapViewHolderInterface, - markerTiling: MarkerTilingOptions = MarkerTilingOptions.Default, - serviceRegistry: MutableMapServiceRegistry? = null, -): MapplsViewController { - // 非 Compose ホスト(React Native / Cordova)はこちらが入口なので、ここでも入れる - MapplsHttpBridge.install() - val markerController = getMarkerController(holder, markerTiling) - val mapController = - MapplsViewController( - holder = holder, - markerController = markerController, - polylineController = getPolylineController(holder), - polygonController = getPolygonController(holder), - groundImageController = getGroundImageController(holder), - circleController = getCircleController(holder), - rasterLayerController = getRasterLayerController(holder), - ) - - serviceRegistry?.let { registry -> - MapplsCapabilities.declare(registry) - registry.put( - MarkerRenderingSupportKey, - object : MarkerRenderingSupport { - override fun createMarkerRenderer( - strategy: MarkerRenderingStrategyInterface, - ): MarkerOverlayRendererInterface = mapController.createMarkerRenderer(strategy) - - override fun createMarkerEventController( - controller: StrategyMarkerController, - renderer: MarkerOverlayRendererInterface, - ): MarkerEventControllerInterface = - mapController.createMarkerEventController(controller, renderer) - - override fun registerMarkerEventController( - controller: MarkerEventControllerInterface, - ) { - mapController.registerMarkerEventController(controller) - } - - override fun onMarkerRenderingReady() { - mapController.sendInitialCameraUpdate() - } - }, - ) - } - return mapController -} - -fun getMarkerController( - holder: MapplsMapViewHolderInterface, - markerTiling: MarkerTilingOptions, -): MapplsMarkerController { - val manager = MarkerManager.defaultManager() - val markerLayer = - MarkerLayer( - sourceId = "markers-source", - layerId = "markers-layer", - ) - val dragLayer = - MarkerDragLayer( - sourceId = "marker-drag-source", - layerId = "marker-drag-layer", - ) - val renderer = - MapplsMarkerOverlayRenderer( - holder = holder, - markerLayer = markerLayer, - dragLayer = dragLayer, - markerManager = manager, - ) - - val controller = - MapplsMarkerController( - renderer = renderer, - markerTiling = markerTiling, - ) - return controller -} - -fun getPolylineController(holder: MapplsMapViewHolderInterface): MapplsPolylineController { - val polylineLayer = - MapplsPolylineLayer( - sourceId = "polyline-source", - layerId = "polyline-layer", - ) - val polylineManager = PolylineManager() - - val renderer = - MapplsPolylineOverlayRenderer( - layer = polylineLayer, - polylineManager = polylineManager, - holder = holder, - ) - - val controller = - MapplsPolylineController( - renderer = renderer, - ) - return controller -} - -fun getPolygonController(holder: MapplsMapViewHolderInterface): MapplsPolygonController { - val polylineLayer = - MapplsPolylineLayer( - sourceId = "polygon-outline-source", - layerId = "polygon-outline-layer", - ) - val polylineManager = PolylineManager() - val polylineOverlayRenderer = - MapplsPolylineOverlayRenderer( - layer = polylineLayer, - polylineManager = polylineManager, - holder = holder, - ) - - val polygonManager = PolygonManager() - val polygonLayer = - MapplsPolygonLayer( - sourceId = "polygon-fill-source", - layerId = "polygon-fill-layer", - ) - val polygonOverlayRenderer = - MapplsPolygonOverlayRenderer( - layer = polygonLayer, - polygonManager = polygonManager, - holder = holder, - ) - - return MapplsPolygonController( - renderer = - MapplsPolygonCompositeRenderer( - fill = polygonOverlayRenderer, - outline = polylineOverlayRenderer, - ), - ) -} - -fun getCircleController(holder: MapplsMapViewHolderInterface): MapplsCircleController { - val circleLayer = - MapplsCircleLayer( - sourceId = "circle-source", - layerId = "circle-layer", - ) - val circleManager = CircleManager() - val renderer = - MapplsCircleOverlayRenderer( - layer = circleLayer, - circleManager = circleManager, - holder = holder, - ) - return MapplsCircleController( - renderer = renderer, - circleManager = circleManager, - ) -} - -fun getRasterLayerController(holder: MapplsMapViewHolderInterface): MapplsRasterLayerController { - val renderer = - MapplsRasterLayerOverlayRenderer( - holder = holder, - ) - return MapplsRasterLayerController( - renderer = renderer, - ) -} - -fun getGroundImageController(holder: MapplsMapViewHolderInterface): MapplsGroundImageController { - val renderer = - MapplsGroundImageOverlayRenderer( - holder = holder, - ) - return MapplsGroundImageController(renderer = renderer) -} - -internal fun Context.findActivity(): Activity? = - when (this) { - is Activity -> this - is ContextWrapper -> baseContext.findActivity() - else -> null - } +package com.mapconductor.mappls + +import androidx.compose.runtime.Composable +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext +import com.mapconductor.compose.map.MapViewBase +import com.mapconductor.core.OnCameraMoveHandler +import com.mapconductor.core.OnMapEventHandler +import com.mapconductor.core.OnMapLoadedHandler +import com.mapconductor.core.circle.CircleManager +import com.mapconductor.core.map.CameraRestriction +import com.mapconductor.core.map.MapCameraPositionInterface +import com.mapconductor.core.map.MapPaddings +import com.mapconductor.core.map.MapViewStyle +import com.mapconductor.core.map.MutableMapServiceRegistry +import com.mapconductor.core.marker.MarkerEventControllerInterface +import com.mapconductor.core.marker.MarkerManager +import com.mapconductor.core.marker.MarkerOverlayRendererInterface +import com.mapconductor.core.marker.MarkerRenderingStrategyInterface +import com.mapconductor.core.marker.MarkerRenderingSupport +import com.mapconductor.core.marker.MarkerRenderingSupportKey +import com.mapconductor.core.marker.MarkerTilingOptions +import com.mapconductor.core.marker.StrategyMarkerController +import com.mapconductor.core.polygon.PolygonManager +import com.mapconductor.core.polyline.PolylineManager +import com.mapconductor.mappls.circle.MapplsCircleController +import com.mapconductor.mappls.circle.MapplsCircleLayer +import com.mapconductor.mappls.circle.MapplsCircleOverlayRenderer +import com.mapconductor.mappls.groundimage.MapplsGroundImageController +import com.mapconductor.mappls.groundimage.MapplsGroundImageOverlayRenderer +import com.mapconductor.mappls.marker.MapplsMarkerController +import com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer +import com.mapconductor.mappls.marker.MarkerDragLayer +import com.mapconductor.mappls.marker.MarkerLayer +import com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer +import com.mapconductor.mappls.polygon.MapplsPolygonController +import com.mapconductor.mappls.polygon.MapplsPolygonLayer +import com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer +import com.mapconductor.mappls.polyline.MapplsPolylineController +import com.mapconductor.mappls.polyline.MapplsPolylineLayer +import com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer +import com.mapconductor.mappls.raster.MapplsRasterLayerController +import com.mapconductor.mappls.raster.MapplsRasterLayerOverlayRenderer +import com.mappls.sdk.maps.MapView +import com.mappls.sdk.maps.Mappls +import com.mappls.sdk.maps.MapplsMap +import com.mappls.sdk.maps.MapplsMapOptions +import com.mappls.sdk.maps.OnMapReadyCallback +import com.mappls.sdk.maps.Style +import android.app.Activity +import android.content.Context +import android.content.ContextWrapper +import android.util.Log +import kotlinx.coroutines.suspendCancellableCoroutine + +@Composable +fun MapplsMapView( + state: MapplsViewState, + modifier: Modifier = Modifier, + markerTiling: MarkerTilingOptions? = null, + cameraRestriction: CameraRestriction? = null, + sdkInitialize: (suspend (Context) -> Boolean)? = null, + onMapLoaded: OnMapLoadedHandler? = null, + onMapClick: OnMapEventHandler? = null, + onMapLongClick: OnMapEventHandler? = null, + onCameraMoveStart: OnCameraMoveHandler? = null, + onCameraMove: OnCameraMoveHandler? = null, + onCameraMoveEnd: OnCameraMoveHandler? = null, + /** + * How the map looks, when the app states it rather than naming a design. + * + * A vector style *is* the basemap. `com.mapconductor:vectorstyle` builds + * one; what happens underneath depends on this backend and the app does + * not have to know. + */ + style: MapViewStyle? = null, + onStyleDiagnostics: ((List) -> Unit)? = null, + content: (@Composable MapplsMapViewScope.() -> Unit)? = null, +) { + val context = LocalContext.current + val scope = remember { MapplsMapViewScope() } + val registry = remember { scope.buildRegistry() } + val cameraState = remember { mutableStateOf(state.cameraPosition) } + + MapViewBase( + state = state, + cameraState = cameraState, + modifier = modifier, + viewProvider = { + val cameraPosition = + // パディングはネイティブに渡さない。接続時の moveCamera が中心のずらしで適用する。 + state.cameraPosition.copy(paddings = MapPaddings.Zeros).toCameraPosition(context.resources.displayMetrics.density) + val mapInitOptions = + MapplsMapOptions + .createFromAttributes(context) + .camera(cameraPosition) + .textureMode(true) + // Don't set style here - it will be set in holderProvider + + MapView(context, mapInitOptions) + }, + scope = scope, + registry = registry, + onMapLoaded = onMapLoaded, + holderProvider = { mapView -> + suspendCancellableCoroutine { continuation -> + mapView.getMapAsync( + object : OnMapReadyCallback { + override fun onMapReady(map: MapplsMap) { + // 認証が通ると SDK がアカウントの既定スタイルを読み込む。 + // 名前指定があればそのスタイルへ差し替え、読み込み完了後に resume する。 + val designName = state.mapDesignType.styleName + if (designName.isEmpty()) { + map.getStyle { + continuation.resume( + MapplsMapViewHolder(mapView, map), + ) { _, _, _ -> } + } + } else { + map.setMapplsStyle( + designName, + Style.OnStyleLoaded { + continuation.resume( + MapplsMapViewHolder(mapView, map), + ) { _, _, _ -> } + }, + ) + } + } + + override fun onMapError( + code: Int, + message: String?, + ) { + // 認証エラー(コンフィグファイル不一致など)はここへ来る。 + // resume しないので地図は表示されないまま — ログで原因を残す。 + Log.e("Mappls", "Map init error $code: $message") + } + }, + ) + } + }, + controllerProvider = { holder -> + createMapplsViewController( + holder = holder, + markerTiling = markerTiling ?: MarkerTilingOptions.Default, + serviceRegistry = state.serviceRegistry, + ).also { mapController -> + // Store controller reference in holder + mapController.setCameraMoveStartListener { + cameraState.value = it + state.updateCameraPosition(it) + onCameraMoveStart?.invoke(it) + } + mapController.setCameraMoveListener { + cameraState.value = it + state.updateCameraPosition(it) + onCameraMove?.invoke(it) + } + mapController.setCameraMoveEndListener { + cameraState.value = it + state.updateCameraPosition(it) + onCameraMoveEnd?.invoke(it) + } + mapController.setMapClickListener(onMapClick) + mapController.setMapDesignTypeChangeListener(state::onMapDesignTypeChange) + mapController.setMapLongClickListener(onMapLongClick) + cameraRestriction?.let { mapController.setCameraRestriction(it) } + state.setController(mapController) + // Post an initial camera update after layout to compute visibleRegion correctly + holder.mapView.post { mapController.sendInitialCameraUpdate() } + } + }, + sdkInitialize = { + // 外部タイルのホワイトリスト回避(MapplsHttpBridge のコメント参照)は + // 地図生成前に必ず入れる。sdkInitialize を差し替えられても失われないよう + // ここで無条件に呼ぶ。 + MapplsHttpBridge.install() + if (sdkInitialize != null) { + sdkInitialize(context) + } else { + Mappls.getInstance(context) + true + } + }, + // Pass content if it needs to be rendered within the overlay providers in MapViewBase, + // or handle it here if it's specific to MapplsMapView structure before calling MapViewBase. + // For now, assuming content relates to overlay definitions. + style = style, + onStyleDiagnostics = onStyleDiagnostics, + // Never started (onStart is not called), so it is not stopped either -- + // MapView.onStop() would deactivate the shared FileSource the next map + // still uses. Destroying it ends the render thread, whose camera + // listeners otherwise keep the controller and every overlay alive. + onDestroyMapView = { mapView -> mapView.onDestroy() }, + content = content, // This might need adjustment based on how overlays are handled + ) +} + +/** + * Creates the imperative controller graph used by both the Compose MapView and non-Compose hosts + * such as React Native. Keeping this construction here prevents provider-specific layer setup from + * being duplicated by each UI integration. + * + * @param serviceRegistry 登録先のサービスレジストリ。Compose からは `state.serviceRegistry` を渡す + * (react-sdk / ios-sdk と同じく持ち主は state)。React Native / Cordova のような非 Compose + * ホストは state を持たないので、自前のレジストリを渡す。 + */ +fun createMapplsViewController( + holder: MapplsMapViewHolderInterface, + markerTiling: MarkerTilingOptions = MarkerTilingOptions.Default, + serviceRegistry: MutableMapServiceRegistry? = null, +): MapplsViewController { + // 非 Compose ホスト(React Native / Cordova)はこちらが入口なので、ここでも入れる + MapplsHttpBridge.install() + val markerController = getMarkerController(holder, markerTiling) + val mapController = + MapplsViewController( + holder = holder, + markerController = markerController, + polylineController = getPolylineController(holder), + polygonController = getPolygonController(holder), + groundImageController = getGroundImageController(holder), + circleController = getCircleController(holder), + rasterLayerController = getRasterLayerController(holder), + ) + + serviceRegistry?.let { registry -> + MapplsCapabilities.declare(registry) + registry.put( + MarkerRenderingSupportKey, + object : MarkerRenderingSupport { + override fun createMarkerRenderer( + strategy: MarkerRenderingStrategyInterface, + ): MarkerOverlayRendererInterface = mapController.createMarkerRenderer(strategy) + + override fun createMarkerEventController( + controller: StrategyMarkerController, + renderer: MarkerOverlayRendererInterface, + ): MarkerEventControllerInterface = + mapController.createMarkerEventController(controller, renderer) + + override fun registerMarkerEventController( + controller: MarkerEventControllerInterface, + ) { + mapController.registerMarkerEventController(controller) + } + + override fun onMarkerRenderingReady() { + mapController.sendInitialCameraUpdate() + } + }, + ) + } + return mapController +} + +fun getMarkerController( + holder: MapplsMapViewHolderInterface, + markerTiling: MarkerTilingOptions, +): MapplsMarkerController { + val manager = MarkerManager.defaultManager() + val markerLayer = + MarkerLayer( + sourceId = "markers-source", + layerId = "markers-layer", + ) + val dragLayer = + MarkerDragLayer( + sourceId = "marker-drag-source", + layerId = "marker-drag-layer", + ) + val renderer = + MapplsMarkerOverlayRenderer( + holder = holder, + markerLayer = markerLayer, + dragLayer = dragLayer, + markerManager = manager, + ) + + val controller = + MapplsMarkerController( + renderer = renderer, + markerTiling = markerTiling, + ) + return controller +} + +fun getPolylineController(holder: MapplsMapViewHolderInterface): MapplsPolylineController { + val polylineLayer = + MapplsPolylineLayer( + sourceId = "polyline-source", + layerId = "polyline-layer", + ) + val polylineManager = PolylineManager() + + val renderer = + MapplsPolylineOverlayRenderer( + layer = polylineLayer, + polylineManager = polylineManager, + holder = holder, + ) + + val controller = + MapplsPolylineController( + renderer = renderer, + ) + return controller +} + +fun getPolygonController(holder: MapplsMapViewHolderInterface): MapplsPolygonController { + val polylineLayer = + MapplsPolylineLayer( + sourceId = "polygon-outline-source", + layerId = "polygon-outline-layer", + ) + val polylineManager = PolylineManager() + val polylineOverlayRenderer = + MapplsPolylineOverlayRenderer( + layer = polylineLayer, + polylineManager = polylineManager, + holder = holder, + ) + + val polygonManager = PolygonManager() + val polygonLayer = + MapplsPolygonLayer( + sourceId = "polygon-fill-source", + layerId = "polygon-fill-layer", + ) + val polygonOverlayRenderer = + MapplsPolygonOverlayRenderer( + layer = polygonLayer, + polygonManager = polygonManager, + holder = holder, + ) + + return MapplsPolygonController( + renderer = + MapplsPolygonCompositeRenderer( + fill = polygonOverlayRenderer, + outline = polylineOverlayRenderer, + ), + ) +} + +fun getCircleController(holder: MapplsMapViewHolderInterface): MapplsCircleController { + val circleLayer = + MapplsCircleLayer( + sourceId = "circle-source", + layerId = "circle-layer", + ) + val circleManager = CircleManager() + val renderer = + MapplsCircleOverlayRenderer( + layer = circleLayer, + circleManager = circleManager, + holder = holder, + ) + return MapplsCircleController( + renderer = renderer, + circleManager = circleManager, + ) +} + +fun getRasterLayerController(holder: MapplsMapViewHolderInterface): MapplsRasterLayerController { + val renderer = + MapplsRasterLayerOverlayRenderer( + holder = holder, + ) + return MapplsRasterLayerController( + renderer = renderer, + ) +} + +fun getGroundImageController(holder: MapplsMapViewHolderInterface): MapplsGroundImageController { + val renderer = + MapplsGroundImageOverlayRenderer( + holder = holder, + ) + return MapplsGroundImageController(renderer = renderer) +} + +internal fun Context.findActivity(): Activity? = + when (this) { + is Activity -> this + is ContextWrapper -> baseContext.findActivity() + else -> null + } diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt index 4e71be3..38a6b87 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt @@ -1,433 +1,438 @@ -package com.mapconductor.mappls - -import com.mapconductor.core.circle.CIRCLE_TILE_LAYER_ID -import com.mapconductor.core.circle.CircleTiler -import com.mapconductor.core.circle.circleTileRasterLayerState -import com.mapconductor.core.circle.OnCircleEventHandler -import com.mapconductor.core.controller.BaseMapViewController -import com.mapconductor.core.features.GeoPointInterface -import com.mapconductor.core.features.GeoRectBounds -import com.mapconductor.core.groundimage.OnGroundImageEventHandler -import com.mapconductor.core.map.CameraRestriction -import com.mapconductor.core.map.MapCameraPosition -import com.mapconductor.core.map.MapUISettings -import com.mapconductor.core.marker.DefaultMarkerEventController -import com.mapconductor.core.marker.MarkerAnimationOverlayHost -import com.mapconductor.core.marker.MarkerEventControllerInterface -import com.mapconductor.core.marker.MarkerOverlayRendererInterface -import com.mapconductor.core.marker.MarkerRenderingStrategyInterface -import com.mapconductor.core.marker.OnMarkerEventHandler -import com.mapconductor.core.marker.StrategyMarkerController -import com.mapconductor.core.marker.dispatchGeoMarkerClick -import com.mapconductor.core.polygon.OnPolygonEventHandler -import com.mapconductor.core.polygon.POLYGON_TILE_LAYER_ID -import com.mapconductor.core.polygon.PolygonState -import com.mapconductor.core.polygon.PolygonTiler -import com.mapconductor.core.polygon.polygonTileRasterLayerState -import com.mapconductor.core.polyline.OnPolylineEventHandler -import com.mapconductor.core.polyline.POLYLINE_TILE_LAYER_ID -import com.mapconductor.core.polyline.PolylineTiler -import com.mapconductor.core.polyline.polylineTileRasterLayerState -import com.mapconductor.mappls.circle.MapplsCircleController -import com.mapconductor.mappls.groundimage.MapplsGroundImageController -import com.mapconductor.mappls.marker.MapplsMarkerController -import com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer -import com.mapconductor.mappls.marker.MarkerDragLayer -import com.mapconductor.mappls.marker.MarkerLayer -import com.mapconductor.mappls.polygon.MapplsPolygonController -import com.mapconductor.mappls.polyline.MapplsPolylineController -import com.mapconductor.mappls.raster.MapplsRasterLayerController -import com.mappls.sdk.gestures.MoveGestureDetector -import com.mappls.sdk.maps.MapplsMap -import com.mappls.sdk.maps.Style -import com.mappls.sdk.maps.geometry.LatLng -import com.mappls.sdk.maps.style.OnStyleLoadListener -import java.util.UUID -import android.annotation.SuppressLint -import android.util.Log -import android.view.View -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.launch - -typealias MapplsDesignTypeChangeHandler = (MapplsMapDesignTypeInterface) -> Unit - -class MapplsViewController( - override val holder: MapplsMapViewHolderInterface, - internal val markerController: MapplsMarkerController, - internal val polylineController: MapplsPolylineController, - internal val polygonController: MapplsPolygonController, - internal val groundImageController: MapplsGroundImageController, - internal val circleController: MapplsCircleController, - internal val rasterLayerController: MapplsRasterLayerController, - override val mainCoroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), - override val defaultCoroutine: CoroutineScope = CoroutineScope(Dispatchers.Default), -) : BaseMapViewController(), - MapplsViewControllerInterface, - MapplsMap.OnMapClickListener, - MapplsMap.OnMapLongClickListener, - MapplsMap.OnMoveListener, - MapplsMap.OnCameraMoveListener, - MapplsMap.OnCameraIdleListener { - // Keep reference to the style instance to avoid getting a new one - internal var styleInstance: Style? = null - internal var wasScrollEnabledBeforeDrag: Boolean? = null - internal var dragTouchInterceptor: View.OnTouchListener? = null - internal val polygonZLayers: MutableSet = mutableSetOf() - internal val markerEventControllers = mutableListOf>() - internal var activeDragController: DefaultMarkerEventController? = null - internal var markerClickListener: OnMarkerEventHandler? = null - internal var markerDragStartListener: OnMarkerEventHandler? = null - internal var markerDragListener: OnMarkerEventHandler? = null - internal var markerDragEndListener: OnMarkerEventHandler? = null - internal var markerAnimateStartListener: OnMarkerEventHandler? = null - internal var markerAnimateEndListener: OnMarkerEventHandler? = null - - internal var lastLogicalCameraPosition: MapCameraPosition? = null - - init { - // Style should already be loaded by holderProvider - val style = holder.map.style - if (style != null) { - setupStyle(style) - // Trigger initial camera update after style is ready - sendInitialCameraUpdate() - } - - setupListeners() - registerOverlayController(markerController) - registerOverlayController(polylineController) - registerOverlayController(polygonController) - registerOverlayController(groundImageController) - registerOverlayController(circleController) - registerOverlayController(rasterLayerController) - registerMarkerEventController(DefaultMarkerEventController(markerController)) - - markerController.setRasterLayerCallback { state -> - if (state != null) { - rasterLayerController.upsert(state) - } else { - val markerTileLayers = - rasterLayerController.rasterLayerManager - .allEntities() - .filter { it.state.id.startsWith("marker-tile-") } - markerTileLayers.forEach { entity -> rasterLayerController.removeById(entity.state.id) } - } - } - - // Many polygons are drawn as raster tiles, shown through the same RasterLayer - // controller as the marker tiles (upsert / removeById, never the app's layers). - polygonController.tiler = - PolygonTiler().apply { - onTemplate = { template, tileSize -> - if (template != null) { - rasterLayerController.upsert(polygonTileRasterLayerState(template, tileSize)) - } else { - rasterLayerController.removeById(POLYGON_TILE_LAYER_ID) - } - } - } - - // Many circles too: the same raster layer path, in the circle band. - circleController.tiler = - CircleTiler().apply { - onTemplate = { template, tileSize -> - if (template != null) { - rasterLayerController.upsert(circleTileRasterLayerState(template, tileSize)) - } else { - rasterLayerController.removeById(CIRCLE_TILE_LAYER_ID) - } - } - } - - // Many polylines too: the same raster layer path, in the polyline band. - polylineController.tiler = - PolylineTiler().apply { - onTemplate = { template, tileSize -> - if (template != null) { - rasterLayerController.upsert(polylineTileRasterLayerState(template, tileSize)) - } else { - rasterLayerController.removeById(POLYLINE_TILE_LAYER_ID) - } - } - } - } - - fun setupListeners() { - holder.map.addOnCameraMoveListener(this) - holder.map.addOnCameraIdleListener(this) - - holder.map.removeOnMapClickListener(this) - holder.map.addOnMapClickListener(this) - - holder.map.removeOnMapLongClickListener(this) - holder.map.addOnMapLongClickListener(this) - - holder.map.removeOnMoveListener(this) - holder.map.addOnMoveListener(this) - } - - override suspend fun clearOverlays() { - markerController.clear() - polylineController.clear() - polygonController.clear() - groundImageController.clear() - circleController.clear() - rasterLayerController.clear() - // 拡張モジュール(クラスタリングなど)が登録した Strategy のマーカーも消す。 - clearStrategyMarkerControllers() - } - - override fun moveCamera(position: MapCameraPosition) = handleMoveCamera(position) - - override fun animateCamera( - position: MapCameraPosition, - duration: Long, - ) = handleAnimateCamera(position, duration) - - override fun fitBounds( - bounds: GeoRectBounds, - padding: Int, - ) = handleFitBounds(bounds, padding) - - override fun setCameraRestriction(restriction: CameraRestriction?) = handleCameraRestriction(restriction) - - override fun applyUISettings(settings: MapUISettings) { - // Mappls の getUiSettings() は @Nullable(MapLibre との差分) - holder.map.uiSettings?.apply { - isScrollGesturesEnabled = settings.scrollGesture - isZoomGesturesEnabled = settings.zoomGesture - isRotateGesturesEnabled = settings.rotateGesture - isTiltGesturesEnabled = settings.tiltGesture - } - } - - // Provide access to the style instance - fun getStyleInstance(): Style? = styleInstance - - private var mapDesignTypeChangeListener: MapplsDesignTypeChangeHandler? = null - - override fun setMapDesignType(value: MapplsMapDesignTypeInterface) { - mainCoroutine.launch { - // 空文字は「アカウントの既定スタイル」。既に既定が載っているので何もしない - // (setMapplsStyle("") は無効なスタイル名として弾かれる)。 - if (value.styleName.isEmpty()) return@launch - holder.map.setMapplsStyle( - value.styleName, - object : OnStyleLoadListener { - override fun onStyleLoaded(newStyle: Style) { - Log.d("Mappls", "Style changed to ${value.styleName}") - setupStyle(newStyle) - } - - override fun onError(message: String?) { - // スタイル名はアカウント紐付き。存在しない名前はここへ来る - Log.w("Mappls", "setMapplsStyle(${value.styleName}) failed: $message") - } - }, - ) - } - } - - fun sendInitialCameraUpdate() { - mainCoroutine.launch { - notifyMapInitialized() - val mapWidth = holder.mapView.width.toFloat() - val mapHeight = holder.mapView.height.toFloat() - if (mapWidth <= 0 || mapHeight <= 0) return@launch - - val camera = readLogicalCameraPosition() - getMapCameraPosition(camera)?.let { mapCameraPosition -> - defaultCoroutine.launch { notifyMapCameraPosition(mapCameraPosition) } - } - } - } - - override fun setMapDesignTypeChangeListener(listener: MapplsDesignTypeChangeHandler) { - mapDesignTypeChangeListener = listener - // Don't call listener immediately - it may trigger style reload - // listener(mapDesignType) - } - - override fun setMarkerAnimationOverlayHost(host: MarkerAnimationOverlayHost?) { - (markerController.renderer as MapplsMarkerOverlayRenderer).animationOverlayHost = host - } - - override suspend fun compositionPolygons(data: List) { - polygonController.add(data) - getStyleInstance()?.let { ensurePolygonZLayers(it) } - } - - override suspend fun updatePolygon(state: PolygonState) { - polygonController.update(state) - getStyleInstance()?.let { ensurePolygonZLayers(it) } - } - - @Deprecated("Use MarkerState.onDragStart instead.") - override fun setOnMarkerDragStart(listener: OnMarkerEventHandler?) { - markerDragStartListener = listener - markerEventControllers.forEach { it.setDragStartListener(listener) } - } - - @Deprecated("Use MarkerState.onDrag instead.") - override fun setOnMarkerDrag(listener: OnMarkerEventHandler?) { - markerDragListener = listener - markerEventControllers.forEach { it.setDragListener(listener) } - } - - @Deprecated("Use MarkerState.onDragEnd instead.") - override fun setOnMarkerDragEnd(listener: OnMarkerEventHandler?) { - markerDragEndListener = listener - markerEventControllers.forEach { it.setDragEndListener(listener) } - } - - @Deprecated("Use PolylineState.onClick instead.") - override fun setOnPolylineClickListener(listener: OnPolylineEventHandler?) { - polylineController.clickListener = listener - } - - @Deprecated("Use PolygonState.onClick instead.") - override fun setOnPolygonClickListener(listener: OnPolygonEventHandler?) { - polygonController.clickListener = listener - } - - @Deprecated("Use CircleState.onClick instead.") - override fun setOnCircleClickListener(listener: OnCircleEventHandler?) { - this.circleController.clickListener = listener - } - - @Deprecated("Use MarkerState.onAnimateStart instead.") - override fun setOnMarkerAnimateStart(listener: OnMarkerEventHandler?) { - markerAnimateStartListener = listener - markerEventControllers.forEach { it.setAnimateStartListener(listener) } - } - - @Deprecated("Use MarkerState.onAnimateEnd instead.") - override fun setOnMarkerAnimateEnd(listener: OnMarkerEventHandler?) { - markerAnimateEndListener = listener - markerEventControllers.forEach { it.setAnimateEndListener(listener) } - } - - @Deprecated("Use MarkerState.onClick instead.") - override fun setOnMarkerClickListener(listener: OnMarkerEventHandler?) { - markerClickListener = listener - markerEventControllers.forEach { it.setClickListener(listener) } - } - - @Deprecated("Use GroundImageState.onClick instead.") - override fun setOnGroundImageClickListener(listener: OnGroundImageEventHandler?) { - this.groundImageController.clickListener = listener - } - - /** - * マーカーのヒットテスト。クリックカスケードの先頭。 - * - * Mappls は地図クリックの座標からそのまま引けるので、コアの - * [dispatchGeoMarkerClick] に委ねる(`clickable = false` の透過もそちら)。 - */ - override fun dispatchMarkerTap(position: GeoPointInterface): Boolean = - markerEventControllers.dispatchGeoMarkerClick(position) - - // 拡張ファイル(Gestures / Camera)からは基底クラスの protected へ触れないため、 - // ここで internal の入口を用意しておく。 - internal fun emitCameraMoveStart(position: MapCameraPosition) { - cameraMoveStartCallback?.invoke(position) - } - - internal fun emitCameraMoveEnd(position: MapCameraPosition) { - cameraMoveEndCallback?.invoke(position) - } - - override fun onMapClick(point: LatLng): Boolean = handleMapClick(point) - - override fun onMapLongClick(point: LatLng): Boolean = handleMapLongClick(point) - - override fun onMoveBegin(detector: MoveGestureDetector) = handleMoveBegin(detector) - - override fun onMove(detector: MoveGestureDetector) = handleMove(detector) - - override fun onMoveEnd(detector: MoveGestureDetector) = handleMoveEnd(detector) - - @SuppressLint("ClickableViewAccessibility") - override fun onCameraMove() { - mainCoroutine.launch { - getMapCameraPosition(readLogicalCameraPosition())?.let { mapCameraPosition -> - defaultCoroutine.launch { - notifyMapCameraPosition(mapCameraPosition) - } - cameraMoveCallback?.invoke(mapCameraPosition) - } - } - } - - override fun onCameraIdle() { - mainCoroutine.launch { - getMapCameraPosition(readLogicalCameraPosition())?.let { mapCameraPosition -> - defaultCoroutine.launch { - notifyMapCameraPosition(mapCameraPosition) - } - cameraMoveEndCallback?.invoke(mapCameraPosition) - } - } - } - - internal fun registerMarkerEventController(controller: DefaultMarkerEventController) { - if (markerEventControllers.contains(controller)) return - markerEventControllers.add(controller) - controller.setClickListener(markerClickListener) - controller.setDragStartListener(markerDragStartListener) - controller.setDragListener(markerDragListener) - controller.setDragEndListener(markerDragEndListener) - controller.setAnimateStartListener(markerAnimateStartListener) - controller.setAnimateEndListener(markerAnimateEndListener) - - val renderer = controller.renderer as MapplsMarkerOverlayRenderer - styleInstance?.let { style -> - renderer.ensureDefaultIcon(style) - ensureGeoJsonSource(style, renderer.markerLayer.sourceId) - MapplsOverlayStacking.add( - holder.map, - style, - renderer.markerLayer.layer, - MapplsOverlayStacking.key(com.mapconductor.core.controller.OverlayKind.Marker), - ) - ensureGeoJsonSource(style, renderer.dragLayer.sourceId) - MapplsOverlayStacking.add(holder.map, style, renderer.dragLayer.layer, MapplsOverlayStacking.MARKER_DRAG) - renderer.redraw() - renderer.drawDragLayer() - } - } - - fun createMarkerRenderer( - strategy: MarkerRenderingStrategyInterface, - ): MarkerOverlayRendererInterface { - val groupId = UUID.randomUUID().toString() - val markerLayer = - MarkerLayer( - sourceId = "markers-source-$groupId", - layerId = "markers-layer-$groupId", - ) - val dragLayer = - MarkerDragLayer( - sourceId = "marker-drag-source-$groupId", - layerId = "marker-drag-layer-$groupId", - ) - return MapplsMarkerOverlayRenderer( - holder = holder, - markerManager = strategy.markerManager, - markerLayer = markerLayer, - dragLayer = dragLayer, - ) - } - - fun createMarkerEventController( - controller: StrategyMarkerController, - renderer: MarkerOverlayRendererInterface, - ): MarkerEventControllerInterface = DefaultMarkerEventController(controller) - - fun registerMarkerEventController(controller: MarkerEventControllerInterface) { - @Suppress("UNCHECKED_CAST") - val typed = controller as? DefaultMarkerEventController ?: return - registerMarkerEventController(typed) - } -} +package com.mapconductor.mappls + +import com.mapconductor.core.circle.CIRCLE_TILE_LAYER_ID +import com.mapconductor.core.circle.CircleTiler +import com.mapconductor.core.circle.circleTileRasterLayerState +import com.mapconductor.core.circle.OnCircleEventHandler +import com.mapconductor.core.controller.BaseMapViewController +import com.mapconductor.core.features.GeoPointInterface +import com.mapconductor.core.features.GeoRectBounds +import com.mapconductor.core.groundimage.OnGroundImageEventHandler +import com.mapconductor.core.map.CameraRestriction +import com.mapconductor.core.map.MapCameraPosition +import com.mapconductor.core.map.MapPaddings +import com.mapconductor.core.map.MapPaddingsInterface +import com.mapconductor.core.map.MapUISettings +import com.mapconductor.core.marker.DefaultMarkerEventController +import com.mapconductor.core.marker.MarkerAnimationOverlayHost +import com.mapconductor.core.marker.MarkerEventControllerInterface +import com.mapconductor.core.marker.MarkerOverlayRendererInterface +import com.mapconductor.core.marker.MarkerRenderingStrategyInterface +import com.mapconductor.core.marker.OnMarkerEventHandler +import com.mapconductor.core.marker.StrategyMarkerController +import com.mapconductor.core.marker.dispatchGeoMarkerClick +import com.mapconductor.core.polygon.OnPolygonEventHandler +import com.mapconductor.core.polygon.POLYGON_TILE_LAYER_ID +import com.mapconductor.core.polygon.PolygonState +import com.mapconductor.core.polygon.PolygonTiler +import com.mapconductor.core.polygon.polygonTileRasterLayerState +import com.mapconductor.core.polyline.OnPolylineEventHandler +import com.mapconductor.core.polyline.POLYLINE_TILE_LAYER_ID +import com.mapconductor.core.polyline.PolylineTiler +import com.mapconductor.core.polyline.polylineTileRasterLayerState +import com.mapconductor.mappls.circle.MapplsCircleController +import com.mapconductor.mappls.groundimage.MapplsGroundImageController +import com.mapconductor.mappls.marker.MapplsMarkerController +import com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer +import com.mapconductor.mappls.marker.MarkerDragLayer +import com.mapconductor.mappls.marker.MarkerLayer +import com.mapconductor.mappls.polygon.MapplsPolygonController +import com.mapconductor.mappls.polyline.MapplsPolylineController +import com.mapconductor.mappls.raster.MapplsRasterLayerController +import com.mappls.sdk.gestures.MoveGestureDetector +import com.mappls.sdk.maps.MapplsMap +import com.mappls.sdk.maps.Style +import com.mappls.sdk.maps.geometry.LatLng +import com.mappls.sdk.maps.style.OnStyleLoadListener +import java.util.UUID +import android.annotation.SuppressLint +import android.util.Log +import android.view.View +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch + +typealias MapplsDesignTypeChangeHandler = (MapplsMapDesignTypeInterface) -> Unit + +class MapplsViewController( + override val holder: MapplsMapViewHolderInterface, + internal val markerController: MapplsMarkerController, + internal val polylineController: MapplsPolylineController, + internal val polygonController: MapplsPolygonController, + internal val groundImageController: MapplsGroundImageController, + internal val circleController: MapplsCircleController, + internal val rasterLayerController: MapplsRasterLayerController, + override val mainCoroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), + override val defaultCoroutine: CoroutineScope = CoroutineScope(Dispatchers.Default), +) : BaseMapViewController(), + MapplsViewControllerInterface, + MapplsMap.OnMapClickListener, + MapplsMap.OnMapLongClickListener, + MapplsMap.OnMoveListener, + MapplsMap.OnCameraMoveListener, + MapplsMap.OnCameraIdleListener { + // Keep reference to the style instance to avoid getting a new one + internal var styleInstance: Style? = null + internal var wasScrollEnabledBeforeDrag: Boolean? = null + internal var dragTouchInterceptor: View.OnTouchListener? = null + internal val polygonZLayers: MutableSet = mutableSetOf() + internal val markerEventControllers = mutableListOf>() + internal var activeDragController: DefaultMarkerEventController? = null + internal var markerClickListener: OnMarkerEventHandler? = null + internal var markerDragStartListener: OnMarkerEventHandler? = null + internal var markerDragListener: OnMarkerEventHandler? = null + internal var markerDragEndListener: OnMarkerEventHandler? = null + internal var markerAnimateStartListener: OnMarkerEventHandler? = null + internal var markerAnimateEndListener: OnMarkerEventHandler? = null + + internal var lastLogicalCameraPosition: MapCameraPosition? = null + + /** アプリが指定したパディング(dp)。ネイティブには渡さず、中心のずらしで再現する。 */ + internal var cameraPaddings: MapPaddingsInterface = MapPaddings.Zeros + + init { + // Style should already be loaded by holderProvider + val style = holder.map.style + if (style != null) { + setupStyle(style) + // Trigger initial camera update after style is ready + sendInitialCameraUpdate() + } + + setupListeners() + registerOverlayController(markerController) + registerOverlayController(polylineController) + registerOverlayController(polygonController) + registerOverlayController(groundImageController) + registerOverlayController(circleController) + registerOverlayController(rasterLayerController) + registerMarkerEventController(DefaultMarkerEventController(markerController)) + + markerController.setRasterLayerCallback { state -> + if (state != null) { + rasterLayerController.upsert(state) + } else { + val markerTileLayers = + rasterLayerController.rasterLayerManager + .allEntities() + .filter { it.state.id.startsWith("marker-tile-") } + markerTileLayers.forEach { entity -> rasterLayerController.removeById(entity.state.id) } + } + } + + // Many polygons are drawn as raster tiles, shown through the same RasterLayer + // controller as the marker tiles (upsert / removeById, never the app's layers). + polygonController.tiler = + PolygonTiler().apply { + onTemplate = { template, tileSize -> + if (template != null) { + rasterLayerController.upsert(polygonTileRasterLayerState(template, tileSize)) + } else { + rasterLayerController.removeById(POLYGON_TILE_LAYER_ID) + } + } + } + + // Many circles too: the same raster layer path, in the circle band. + circleController.tiler = + CircleTiler().apply { + onTemplate = { template, tileSize -> + if (template != null) { + rasterLayerController.upsert(circleTileRasterLayerState(template, tileSize)) + } else { + rasterLayerController.removeById(CIRCLE_TILE_LAYER_ID) + } + } + } + + // Many polylines too: the same raster layer path, in the polyline band. + polylineController.tiler = + PolylineTiler().apply { + onTemplate = { template, tileSize -> + if (template != null) { + rasterLayerController.upsert(polylineTileRasterLayerState(template, tileSize)) + } else { + rasterLayerController.removeById(POLYLINE_TILE_LAYER_ID) + } + } + } + } + + fun setupListeners() { + holder.map.addOnCameraMoveListener(this) + holder.map.addOnCameraIdleListener(this) + + holder.map.removeOnMapClickListener(this) + holder.map.addOnMapClickListener(this) + + holder.map.removeOnMapLongClickListener(this) + holder.map.addOnMapLongClickListener(this) + + holder.map.removeOnMoveListener(this) + holder.map.addOnMoveListener(this) + } + + override suspend fun clearOverlays() { + markerController.clear() + polylineController.clear() + polygonController.clear() + groundImageController.clear() + circleController.clear() + rasterLayerController.clear() + // 拡張モジュール(クラスタリングなど)が登録した Strategy のマーカーも消す。 + clearStrategyMarkerControllers() + } + + override fun moveCamera(position: MapCameraPosition) = handleMoveCamera(position) + + override fun animateCamera( + position: MapCameraPosition, + duration: Long, + ) = handleAnimateCamera(position, duration) + + override fun fitBounds( + bounds: GeoRectBounds, + padding: Int, + ) = handleFitBounds(bounds, padding) + + override fun setCameraRestriction(restriction: CameraRestriction?) = handleCameraRestriction(restriction) + + override fun applyUISettings(settings: MapUISettings) { + // Mappls の getUiSettings() は @Nullable(MapLibre との差分) + holder.map.uiSettings?.apply { + isScrollGesturesEnabled = settings.scrollGesture + isZoomGesturesEnabled = settings.zoomGesture + isRotateGesturesEnabled = settings.rotateGesture + isTiltGesturesEnabled = settings.tiltGesture + } + } + + // Provide access to the style instance + fun getStyleInstance(): Style? = styleInstance + + private var mapDesignTypeChangeListener: MapplsDesignTypeChangeHandler? = null + + override fun setMapDesignType(value: MapplsMapDesignTypeInterface) { + mainCoroutine.launch { + // 空文字は「アカウントの既定スタイル」。既に既定が載っているので何もしない + // (setMapplsStyle("") は無効なスタイル名として弾かれる)。 + if (value.styleName.isEmpty()) return@launch + holder.map.setMapplsStyle( + value.styleName, + object : OnStyleLoadListener { + override fun onStyleLoaded(newStyle: Style) { + Log.d("Mappls", "Style changed to ${value.styleName}") + setupStyle(newStyle) + } + + override fun onError(message: String?) { + // スタイル名はアカウント紐付き。存在しない名前はここへ来る + Log.w("Mappls", "setMapplsStyle(${value.styleName}) failed: $message") + } + }, + ) + } + } + + fun sendInitialCameraUpdate() { + mainCoroutine.launch { + notifyMapInitialized() + val mapWidth = holder.mapView.width.toFloat() + val mapHeight = holder.mapView.height.toFloat() + if (mapWidth <= 0 || mapHeight <= 0) return@launch + + val camera = readLogicalCameraPosition() + getMapCameraPosition(camera)?.let { mapCameraPosition -> + defaultCoroutine.launch { notifyMapCameraPosition(mapCameraPosition) } + } + } + } + + override fun setMapDesignTypeChangeListener(listener: MapplsDesignTypeChangeHandler) { + mapDesignTypeChangeListener = listener + // Don't call listener immediately - it may trigger style reload + // listener(mapDesignType) + } + + override fun setMarkerAnimationOverlayHost(host: MarkerAnimationOverlayHost?) { + (markerController.renderer as MapplsMarkerOverlayRenderer).animationOverlayHost = host + } + + override suspend fun compositionPolygons(data: List) { + polygonController.add(data) + getStyleInstance()?.let { ensurePolygonZLayers(it) } + } + + override suspend fun updatePolygon(state: PolygonState) { + polygonController.update(state) + getStyleInstance()?.let { ensurePolygonZLayers(it) } + } + + @Deprecated("Use MarkerState.onDragStart instead.") + override fun setOnMarkerDragStart(listener: OnMarkerEventHandler?) { + markerDragStartListener = listener + markerEventControllers.forEach { it.setDragStartListener(listener) } + } + + @Deprecated("Use MarkerState.onDrag instead.") + override fun setOnMarkerDrag(listener: OnMarkerEventHandler?) { + markerDragListener = listener + markerEventControllers.forEach { it.setDragListener(listener) } + } + + @Deprecated("Use MarkerState.onDragEnd instead.") + override fun setOnMarkerDragEnd(listener: OnMarkerEventHandler?) { + markerDragEndListener = listener + markerEventControllers.forEach { it.setDragEndListener(listener) } + } + + @Deprecated("Use PolylineState.onClick instead.") + override fun setOnPolylineClickListener(listener: OnPolylineEventHandler?) { + polylineController.clickListener = listener + } + + @Deprecated("Use PolygonState.onClick instead.") + override fun setOnPolygonClickListener(listener: OnPolygonEventHandler?) { + polygonController.clickListener = listener + } + + @Deprecated("Use CircleState.onClick instead.") + override fun setOnCircleClickListener(listener: OnCircleEventHandler?) { + this.circleController.clickListener = listener + } + + @Deprecated("Use MarkerState.onAnimateStart instead.") + override fun setOnMarkerAnimateStart(listener: OnMarkerEventHandler?) { + markerAnimateStartListener = listener + markerEventControllers.forEach { it.setAnimateStartListener(listener) } + } + + @Deprecated("Use MarkerState.onAnimateEnd instead.") + override fun setOnMarkerAnimateEnd(listener: OnMarkerEventHandler?) { + markerAnimateEndListener = listener + markerEventControllers.forEach { it.setAnimateEndListener(listener) } + } + + @Deprecated("Use MarkerState.onClick instead.") + override fun setOnMarkerClickListener(listener: OnMarkerEventHandler?) { + markerClickListener = listener + markerEventControllers.forEach { it.setClickListener(listener) } + } + + @Deprecated("Use GroundImageState.onClick instead.") + override fun setOnGroundImageClickListener(listener: OnGroundImageEventHandler?) { + this.groundImageController.clickListener = listener + } + + /** + * マーカーのヒットテスト。クリックカスケードの先頭。 + * + * Mappls は地図クリックの座標からそのまま引けるので、コアの + * [dispatchGeoMarkerClick] に委ねる(`clickable = false` の透過もそちら)。 + */ + override fun dispatchMarkerTap(position: GeoPointInterface): Boolean = + markerEventControllers.dispatchGeoMarkerClick(position) + + // 拡張ファイル(Gestures / Camera)からは基底クラスの protected へ触れないため、 + // ここで internal の入口を用意しておく。 + internal fun emitCameraMoveStart(position: MapCameraPosition) { + cameraMoveStartCallback?.invoke(position) + } + + internal fun emitCameraMoveEnd(position: MapCameraPosition) { + cameraMoveEndCallback?.invoke(position) + } + + override fun onMapClick(point: LatLng): Boolean = handleMapClick(point) + + override fun onMapLongClick(point: LatLng): Boolean = handleMapLongClick(point) + + override fun onMoveBegin(detector: MoveGestureDetector) = handleMoveBegin(detector) + + override fun onMove(detector: MoveGestureDetector) = handleMove(detector) + + override fun onMoveEnd(detector: MoveGestureDetector) = handleMoveEnd(detector) + + @SuppressLint("ClickableViewAccessibility") + override fun onCameraMove() { + mainCoroutine.launch { + getMapCameraPosition(readLogicalCameraPosition())?.let { mapCameraPosition -> + defaultCoroutine.launch { + notifyMapCameraPosition(mapCameraPosition) + } + cameraMoveCallback?.invoke(mapCameraPosition) + } + } + } + + override fun onCameraIdle() { + mainCoroutine.launch { + getMapCameraPosition(readLogicalCameraPosition())?.let { mapCameraPosition -> + defaultCoroutine.launch { + notifyMapCameraPosition(mapCameraPosition) + } + cameraMoveEndCallback?.invoke(mapCameraPosition) + } + } + } + + internal fun registerMarkerEventController(controller: DefaultMarkerEventController) { + if (markerEventControllers.contains(controller)) return + markerEventControllers.add(controller) + controller.setClickListener(markerClickListener) + controller.setDragStartListener(markerDragStartListener) + controller.setDragListener(markerDragListener) + controller.setDragEndListener(markerDragEndListener) + controller.setAnimateStartListener(markerAnimateStartListener) + controller.setAnimateEndListener(markerAnimateEndListener) + + val renderer = controller.renderer as MapplsMarkerOverlayRenderer + styleInstance?.let { style -> + renderer.ensureDefaultIcon(style) + ensureGeoJsonSource(style, renderer.markerLayer.sourceId) + MapplsOverlayStacking.add( + holder.map, + style, + renderer.markerLayer.layer, + MapplsOverlayStacking.key(com.mapconductor.core.controller.OverlayKind.Marker), + ) + ensureGeoJsonSource(style, renderer.dragLayer.sourceId) + MapplsOverlayStacking.add(holder.map, style, renderer.dragLayer.layer, MapplsOverlayStacking.MARKER_DRAG) + renderer.redraw() + renderer.drawDragLayer() + } + } + + fun createMarkerRenderer( + strategy: MarkerRenderingStrategyInterface, + ): MarkerOverlayRendererInterface { + val groupId = UUID.randomUUID().toString() + val markerLayer = + MarkerLayer( + sourceId = "markers-source-$groupId", + layerId = "markers-layer-$groupId", + ) + val dragLayer = + MarkerDragLayer( + sourceId = "marker-drag-source-$groupId", + layerId = "marker-drag-layer-$groupId", + ) + return MapplsMarkerOverlayRenderer( + holder = holder, + markerManager = strategy.markerManager, + markerLayer = markerLayer, + dragLayer = dragLayer, + ) + } + + fun createMarkerEventController( + controller: StrategyMarkerController, + renderer: MarkerOverlayRendererInterface, + ): MarkerEventControllerInterface = DefaultMarkerEventController(controller) + + fun registerMarkerEventController(controller: MarkerEventControllerInterface) { + @Suppress("UNCHECKED_CAST") + val typed = controller as? DefaultMarkerEventController ?: return + registerMarkerEventController(typed) + } +} diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewControllerCamera.kt b/src/main/java/com/mapconductor/mappls/MapplsViewControllerCamera.kt index aa93959..76850d5 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewControllerCamera.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewControllerCamera.kt @@ -1,9 +1,12 @@ package com.mapconductor.mappls +import android.view.View import com.mapconductor.core.features.GeoRectBounds +import com.mapconductor.core.map.CameraPaddingEmulation import com.mapconductor.core.map.CameraRestriction import com.mapconductor.core.map.MapCameraPosition import com.mapconductor.core.map.MapCameraPositionInterface +import com.mapconductor.core.map.MapPaddings import com.mapconductor.core.map.buildVisibleRegion import com.mapconductor.mappls.zoom.ZoomAltitudeConverter import com.mappls.sdk.maps.camera.CameraUpdateFactory @@ -17,11 +20,63 @@ import kotlinx.coroutines.launch * 1 段ずれる。読むときも書くときも [ZoomAltitudeConverter] を通す。 */ internal fun MapplsViewController.readLogicalCameraPosition(): MapCameraPosition = - MapplsCameraStateSnapshot( - cameraPosition = holder.map.cameraPosition, - logicalTiltHint = lastLogicalCameraPosition?.tilt, - density = density(), - ).toMapCameraPosition() + CameraPaddingEmulation.fromNativeCamera( + MapplsCameraStateSnapshot( + cameraPosition = holder.map.cameraPosition, + logicalTiltHint = lastLogicalCameraPosition?.tilt, + density = density(), + ).toMapCameraPosition(), + cameraPaddings, + MAPPLS_VERTICAL_FOV, + viewportHeightDp(), + ) + +/** 地図の高さ(dp)。パディングのエミュレーションで遠近を解くのに使う。 */ +internal fun MapplsViewController.viewportHeightDp(): Double = holder.mapView.height / density().toDouble() + +/** + * パディングを中心のずらしに置き換えたカメラ。Mappls のパディングは常に 0 にする。 + * + * ネイティブのパディングは視錐台を上へ広げる。tilt があると上のパディングが + * 大きいほど画面の上端が地平線の先まで届き、そこまでタイルを読みに行って固まる + * (パディング中は tilt も 56° 前後に下げられる)。中心をずらせば、パディング無しと + * 同じ視錐台のまま target をパディング中央に置ける。paddings が null なら今のパディングを使い続ける。 + */ +internal fun MapplsViewController.toNativeCamera(position: MapCameraPosition): MapCameraPosition { + position.paddings?.let { cameraPaddings = it } + return CameraPaddingEmulation + .toNativeCamera(position.copy(paddings = cameraPaddings), MAPPLS_VERTICAL_FOV, viewportHeightDp()) + .copy(paddings = MapPaddings.Zeros) +} + +/** 地図がまだ大きさを持たない(レイアウト前)ときは、パディングを解けないので最初のレイアウトまで待つ。 */ +private fun MapplsViewController.needsLayoutFor(position: MapCameraPosition): Boolean { + val paddings = position.paddings ?: cameraPaddings + val padded = paddings.top != 0.0 || paddings.left != 0.0 || paddings.bottom != 0.0 || paddings.right != 0.0 + return padded && holder.mapView.height <= 0 +} + +private fun MapplsViewController.afterFirstLayout(action: () -> Unit) { + holder.mapView.addOnLayoutChangeListener( + object : View.OnLayoutChangeListener { + override fun onLayoutChange( + v: View, + left: Int, + top: Int, + right: Int, + bottom: Int, + oldLeft: Int, + oldTop: Int, + oldRight: Int, + oldBottom: Int, + ) { + if (bottom - top <= 0) return + v.removeOnLayoutChangeListener(this) + action() + } + }, + ) +} internal fun MapplsViewController.density(): Float = holder.mapView.resources.displayMetrics.density @@ -34,7 +89,11 @@ internal fun MapplsViewController.getMapCameraPosition(camera: MapCameraPosition internal fun MapplsViewController.handleMoveCamera(position: MapCameraPosition) { lastLogicalCameraPosition = position mainCoroutine.launch { - val cameraPos = position.toCameraPosition(density()) + if (needsLayoutFor(position)) { + afterFirstLayout { handleMoveCamera(position) } + return@launch + } + val cameraPos = toNativeCamera(position).toCameraPosition(density()) val cameraUpdate = CameraUpdateFactory .newCameraPosition(cameraPos) @@ -49,7 +108,11 @@ internal fun MapplsViewController.handleAnimateCamera( ) { lastLogicalCameraPosition = position mainCoroutine.launch { - val cameraPos = position.toCameraPosition(density()) + if (needsLayoutFor(position)) { + afterFirstLayout { handleAnimateCamera(position, duration) } + return@launch + } + val cameraPos = toNativeCamera(position).toCameraPosition(density()) val cameraUpdate = CameraUpdateFactory .newCameraPosition(cameraPos) From 75d5eeed421afbc5a4fd2981186579ece60b21c6 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Fri, 13 Nov 2026 03:41:38 -0800 Subject: [PATCH 27/27] Release 1.4.0 --- api/android-for-mappls.api | 7 +++++++ gradle.properties | 2 +- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/api/android-for-mappls.api b/api/android-for-mappls.api index 27ae1c3..332d344 100644 --- a/api/android-for-mappls.api +++ b/api/android-for-mappls.api @@ -84,6 +84,9 @@ public final class com.mapconductor.mappls.MapplsMapViewHolder implements com.ma public androidx.compose.ui.geometry.Offset toScreenOffset-x-9fifI(com.mapconductor.core.features.GeoPointInterface); public com.mapconductor.core.features.GeoPoint fromScreenOffsetSync-k-4lQ0M(long); public java.lang.Object fromScreenOffset-3MmeM6k(long, kotlin.coroutines.Continuation); + public com.mapconductor.core.projection.ProjectedPoint toProjectedPoint(com.mapconductor.core.features.GeoPointInterface); + public com.mapconductor.core.features.GeoPoint fromProjectedPoint(com.mapconductor.core.projection.ProjectedPoint); + public com.mapconductor.core.projection.MapCoordinateSystem getCoordinateSystem(); public java.lang.Object getMapView(); public java.lang.Object getMap(); } @@ -92,6 +95,9 @@ public interface com.mapconductor.mappls.MapplsMapViewHolderInterface extends co public final class com.mapconductor.mappls.MapplsMapViewHolderInterface$DefaultImpls { public static java.lang.Object fromScreenOffset-3MmeM6k(com.mapconductor.mappls.MapplsMapViewHolderInterface, long, kotlin.coroutines.Continuation); public static com.mapconductor.core.features.GeoPoint fromScreenOffsetSync-k-4lQ0M(com.mapconductor.mappls.MapplsMapViewHolderInterface, long); + public static com.mapconductor.core.projection.ProjectedPoint toProjectedPoint(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.features.GeoPointInterface); + public static com.mapconductor.core.features.GeoPoint fromProjectedPoint(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.projection.ProjectedPoint); + public static com.mapconductor.core.projection.MapCoordinateSystem getCoordinateSystem(com.mapconductor.mappls.MapplsMapViewHolderInterface); } public final class com.mapconductor.mappls.MapplsMapViewKt { public static final void MapplsMapView(com.mapconductor.mappls.MapplsViewState, androidx.compose.ui.Modifier, com.mapconductor.core.marker.MarkerTilingOptions, com.mapconductor.core.map.CameraRestriction, kotlin.jvm.functions.Function2, ? extends java.lang.Object>, kotlin.jvm.functions.Function1, kotlin.Unit>, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, com.mapconductor.core.map.MapViewStyle, kotlin.jvm.functions.Function1, kotlin.Unit>, kotlin.jvm.functions.Function3, androidx.compose.runtime.Composer, int, int, int); @@ -122,6 +128,7 @@ public final class com.mapconductor.mappls.MapplsOverlayStacking { public final com.mapconductor.core.controller.OverlayStacking$Key key(com.mapconductor.core.controller.OverlayKind, int); public final com.mapconductor.core.controller.OverlayStacking$Key getMARKER_TILE(); public final com.mapconductor.core.controller.OverlayStacking$Key getPOLYGON_TILE(); + public final com.mapconductor.core.controller.OverlayStacking$Key getCIRCLE_TILE(); public final com.mapconductor.core.controller.OverlayStacking$Key getPOLYLINE_TILE(); public final com.mapconductor.core.controller.OverlayStacking$Key getMARKER_DRAG(); public final void add(com.mappls.sdk.maps.MapplsMap, com.mappls.sdk.maps.Style, com.mappls.sdk.maps.style.layers.Layer, com.mapconductor.core.controller.OverlayStacking$Key); diff --git a/gradle.properties b/gradle.properties index c018eb9..8b1a332 100644 --- a/gradle.properties +++ b/gradle.properties @@ -8,5 +8,5 @@ minSdk=26 javaVersion=17 jvmTarget=17 -libraryVersion=1.3.1 +libraryVersion=1.4.0 android.generateSyncIssueWhenLibraryConstraintsAreEnabled=false