From 8fabcbb37529de4f2b26ada3b91b08c132f3ba8d Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 12 Sep 2026 14:52:42 +0900 Subject: [PATCH 01/25] Make bearing a clockwise map rotation (#6) 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 に合わせる。 --------- Co-authored-by: masashi --- .github/workflows/build.yml | 25 +- gradle/libs.versions.toml | 5 +- .../mapconductor/tomtom/MapCameraPosition.kt | 273 +++++++++--------- 3 files changed, 164 insertions(+), 139 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 b2fda5a..27e4342 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" coroutines = "1.9.0" agp = "9.2.1" kotlin = "2.0.21" @@ -33,7 +36,7 @@ tomtom-map-display = { group = "com.tomtom.sdk.maps", name = "map-display-standa # 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/tomtom/MapCameraPosition.kt b/src/main/java/com/mapconductor/tomtom/MapCameraPosition.kt index 897229b..1f29be4 100644 --- a/src/main/java/com/mapconductor/tomtom/MapCameraPosition.kt +++ b/src/main/java/com/mapconductor/tomtom/MapCameraPosition.kt @@ -1,136 +1,137 @@ -package com.mapconductor.tomtom - -import com.mapconductor.core.features.GeoPoint -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.core.zoom.AbstractZoomAltitudeConverter -import com.mapconductor.tomtom.zoom.ZoomAltitudeConverter -import com.tomtom.sdk.map.display.camera.CameraOptions -import com.tomtom.sdk.map.display.camera.CameraPosition as TomTomCameraPosition -import kotlin.math.abs -import kotlin.math.cos -import kotlin.math.tan - -private val converter = ZoomAltitudeConverter(AbstractZoomAltitudeConverter.DEFAULT_ZOOM0_ALTITUDE) - -// tilt < 0(上向きピッチ)の擬似表現に用いる定数。MapLibre 実装(android-for-maplibre の -// MapCameraPosition.kt)と同一値を用いることで、プロバイダ間で挙動を揃える。 -private const val NEGATIVE_TILT_TARGET_DISTANCE_SCALE = 1.83 -private const val NEGATIVE_TILT_ZOOM_OFFSET_AT_MAX_TILT = -0.9 - -/** - * 統一 bearing を TomTom の [CameraOptions.rotation] が要求する [0.0, 360.0] へ正規化する。 - * - * 他プロバイダ(MapTiler/MapLibre GL JS 等)は方位角を (-180, 180] で報告するため、地図を回転させた - * 状態で TomTom へ切り替えると負の rotation が渡り、`IllegalArgumentException: rotation must be in - * range [0.0,360.0]` でクラッシュしていた。ここで [0, 360) に丸めて防止する(NaN は 0 とみなす)。 - */ -private fun Double.toTomTomRotation(): Double = if (isNaN()) 0.0 else ((this % 360.0) + 360.0) % 360.0 - -/** - * MapConductor の MapCameraPosition → TomTom の [CameraOptions]。 - * - * rotation は方位角(bearing)に対応。tilt は 0.0〜60.0 にクランプする。 - * 統一ズームは Google Maps 換算のため、緯度を使って TomTom ネイティブズームへ変換する。 - */ -fun MapCameraPosition.toCameraOptions(): CameraOptions { - if (tilt >= 0) { - return CameraOptions( - position = GeoPoint.from(position).toTomTomGeoPoint(), - zoom = ZoomAltitudeConverter.googleZoomToTomTomZoom(zoom, position.latitude), - tilt = tilt.coerceIn(0.0, 60.0), - rotation = bearing.toTomTomRotation(), - ) - } - - // tilt < 0: TomTom(Mapbox GL 由来のベクターエンジン)は上向きピッチを直接表現できない。 - // MapLibre 実装と同じ方式で、地上ターゲットを進行方向(bearing)へ前進させ、abs(tilt) の - // 下向きピッチで描画することで、擬似的に上向き(負tilt)視点を再現する。 - val tiltAbsDeg = abs(tilt).coerceIn(0.0, 60.0) - val tiltAbsRad = Math.toRadians(tiltAbsDeg) - val tomtomZoomForAltitude = ZoomAltitudeConverter.googleZoomToTomTomZoom(zoom, position.latitude) - val altitude = converter.zoomLevelToAltitude(tomtomZoomForAltitude, position.latitude, 0.0) - val distanceForward = - altitude * - cos(tiltAbsRad) * - tan(tiltAbsRad) * - NEGATIVE_TILT_TARGET_DISTANCE_SCALE - val target = Spherical.computeOffset(position, distanceForward, bearing) - val adjustedZoom = zoom + NEGATIVE_TILT_ZOOM_OFFSET_AT_MAX_TILT * (tiltAbsDeg / 60.0) - - return CameraOptions( - position = target.toTomTomGeoPoint(), - zoom = ZoomAltitudeConverter.googleZoomToTomTomZoom(adjustedZoom, target.latitude), - tilt = tiltAbsDeg, - rotation = bearing.toTomTomRotation(), - ) -} - -fun MapCameraPosition.Companion.from(position: MapCameraPositionInterface): MapCameraPosition = - when (position) { - is MapCameraPosition -> position - else -> - MapCameraPosition( - position = position.position, - zoom = position.zoom, - bearing = position.bearing, - tilt = position.tilt, - paddings = position.paddings, - visibleRegion = position.visibleRegion, - ) - } - -/** - * TomTom の [CameraPosition] → MapConductor の MapCameraPosition。 - * - * @param logicalTiltHint 直近に要求した論理 tilt([MapCameraPosition.tilt])。これが負値のとき、 - * シフト済みカメラ状態(前進ターゲット + 正ピッチ)から元の位置・ズーム・負tilt を復元する。 - * null または 0 以上のときは通常変換。MapLibre 実装と同一ロジック。 - */ -fun TomTomCameraPosition.toMapCameraPosition( - paddings: MapPaddingsInterface = MapPaddings.Zeros, - logicalTiltHint: Double? = null, -): MapCameraPosition { - val pitchAbsDeg = abs(tilt).coerceIn(0.0, 60.0) - - if (logicalTiltHint == null || logicalTiltHint >= 0.0 || pitchAbsDeg == 0.0) { - // `zoom` は TomTom ネイティブズーム。統一ズーム(Google 換算)へ緯度依存で補正する。 - val altitude = - converter.zoomLevelToAltitude( - zoomLevel = zoom, - latitude = position.latitude, - tilt = tilt, - ) - val corePosition = position.toGeoPoint().copy(altitude = altitude) - return MapCameraPosition( - position = corePosition, - zoom = ZoomAltitudeConverter.tomtomZoomToGoogleZoom(zoom, position.latitude), - bearing = rotation, - tilt = tilt, - paddings = paddings, - visibleRegion = null, - ) - } - - // tilt < 0 の復元:前進させたターゲットとズームオフセットを逆算し、元の位置・ズーム・負tilt を返す。 - val pitchAbsRad = Math.toRadians(pitchAbsDeg) - val shiftedCenter = position.toGeoPoint() - val googleZoom = ZoomAltitudeConverter.tomtomZoomToGoogleZoom(zoom, position.latitude) - val originalGoogleZoom = googleZoom - NEGATIVE_TILT_ZOOM_OFFSET_AT_MAX_TILT * (pitchAbsDeg / 60.0) - val originalTomTomZoom = ZoomAltitudeConverter.googleZoomToTomTomZoom(originalGoogleZoom, shiftedCenter.latitude) - val altitude = converter.zoomLevelToAltitude(originalTomTomZoom, shiftedCenter.latitude, 0.0) - val distanceBackward = altitude * cos(pitchAbsRad) * tan(pitchAbsRad) * NEGATIVE_TILT_TARGET_DISTANCE_SCALE - val originalPosition = Spherical.computeOffset(shiftedCenter, distanceBackward, rotation + 180.0) - - return MapCameraPosition( - position = originalPosition.copy(altitude = altitude), - zoom = originalGoogleZoom, - bearing = rotation, - tilt = -pitchAbsDeg, - paddings = paddings, - visibleRegion = null, - ) -} +package com.mapconductor.tomtom + +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.core.zoom.AbstractZoomAltitudeConverter +import com.mapconductor.tomtom.zoom.ZoomAltitudeConverter +import com.tomtom.sdk.map.display.camera.CameraOptions +import com.tomtom.sdk.map.display.camera.CameraPosition as TomTomCameraPosition +import kotlin.math.abs +import kotlin.math.cos +import kotlin.math.tan + +private val converter = ZoomAltitudeConverter(AbstractZoomAltitudeConverter.DEFAULT_ZOOM0_ALTITUDE) + +// tilt < 0(上向きピッチ)の擬似表現に用いる定数。MapLibre 実装(android-for-maplibre の +// MapCameraPosition.kt)と同一値を用いることで、プロバイダ間で挙動を揃える。 +private const val NEGATIVE_TILT_TARGET_DISTANCE_SCALE = 1.83 +private const val NEGATIVE_TILT_ZOOM_OFFSET_AT_MAX_TILT = -0.9 + +/** + * 統一 bearing を TomTom の [CameraOptions.rotation] が要求する [0.0, 360.0] へ正規化する。 + * + * 他プロバイダ(MapTiler/MapLibre GL JS 等)は方位角を (-180, 180] で報告するため、地図を回転させた + * 状態で TomTom へ切り替えると負の rotation が渡り、`IllegalArgumentException: rotation must be in + * range [0.0,360.0]` でクラッシュしていた。ここで [0, 360) に丸めて防止する(NaN は 0 とみなす)。 + */ +private fun Double.toTomTomRotation(): Double = if (isNaN()) 0.0 else ((this % 360.0) + 360.0) % 360.0 + +/** + * MapConductor の MapCameraPosition → TomTom の [CameraOptions]。 + * + * rotation は方位角(bearing)に対応。tilt は 0.0〜60.0 にクランプする。 + * 統一ズームは Google Maps 換算のため、緯度を使って TomTom ネイティブズームへ変換する。 + */ +fun MapCameraPosition.toCameraOptions(): CameraOptions { + if (tilt >= 0) { + return CameraOptions( + position = GeoPoint.from(position).toTomTomGeoPoint(), + zoom = ZoomAltitudeConverter.googleZoomToTomTomZoom(zoom, position.latitude), + tilt = tilt.coerceIn(0.0, 60.0), + rotation = CameraBearing.toNativeHeading(bearing).toTomTomRotation(), + ) + } + + // tilt < 0: TomTom(Mapbox GL 由来のベクターエンジン)は上向きピッチを直接表現できない。 + // MapLibre 実装と同じ方式で、地上ターゲットを進行方向(bearing)へ前進させ、abs(tilt) の + // 下向きピッチで描画することで、擬似的に上向き(負tilt)視点を再現する。 + val tiltAbsDeg = abs(tilt).coerceIn(0.0, 60.0) + val tiltAbsRad = Math.toRadians(tiltAbsDeg) + val tomtomZoomForAltitude = ZoomAltitudeConverter.googleZoomToTomTomZoom(zoom, position.latitude) + val altitude = converter.zoomLevelToAltitude(tomtomZoomForAltitude, position.latitude, 0.0) + val distanceForward = + altitude * + cos(tiltAbsRad) * + tan(tiltAbsRad) * + NEGATIVE_TILT_TARGET_DISTANCE_SCALE + val target = Spherical.computeOffset(position, distanceForward, CameraBearing.toNativeHeading(bearing)) + val adjustedZoom = zoom + NEGATIVE_TILT_ZOOM_OFFSET_AT_MAX_TILT * (tiltAbsDeg / 60.0) + + return CameraOptions( + position = target.toTomTomGeoPoint(), + zoom = ZoomAltitudeConverter.googleZoomToTomTomZoom(adjustedZoom, target.latitude), + tilt = tiltAbsDeg, + rotation = CameraBearing.toNativeHeading(bearing).toTomTomRotation(), + ) +} + +fun MapCameraPosition.Companion.from(position: MapCameraPositionInterface): MapCameraPosition = + when (position) { + is MapCameraPosition -> position + else -> + MapCameraPosition( + position = position.position, + zoom = position.zoom, + bearing = position.bearing, + tilt = position.tilt, + paddings = position.paddings, + visibleRegion = position.visibleRegion, + ) + } + +/** + * TomTom の [CameraPosition] → MapConductor の MapCameraPosition。 + * + * @param logicalTiltHint 直近に要求した論理 tilt([MapCameraPosition.tilt])。これが負値のとき、 + * シフト済みカメラ状態(前進ターゲット + 正ピッチ)から元の位置・ズーム・負tilt を復元する。 + * null または 0 以上のときは通常変換。MapLibre 実装と同一ロジック。 + */ +fun TomTomCameraPosition.toMapCameraPosition( + paddings: MapPaddingsInterface = MapPaddings.Zeros, + logicalTiltHint: Double? = null, +): MapCameraPosition { + val pitchAbsDeg = abs(tilt).coerceIn(0.0, 60.0) + + if (logicalTiltHint == null || logicalTiltHint >= 0.0 || pitchAbsDeg == 0.0) { + // `zoom` は TomTom ネイティブズーム。統一ズーム(Google 換算)へ緯度依存で補正する。 + val altitude = + converter.zoomLevelToAltitude( + zoomLevel = zoom, + latitude = position.latitude, + tilt = tilt, + ) + val corePosition = position.toGeoPoint().copy(altitude = altitude) + return MapCameraPosition( + position = corePosition, + zoom = ZoomAltitudeConverter.tomtomZoomToGoogleZoom(zoom, position.latitude), + bearing = CameraBearing.bearingFromNativeHeading(rotation), + tilt = tilt, + paddings = paddings, + visibleRegion = null, + ) + } + + // tilt < 0 の復元:前進させたターゲットとズームオフセットを逆算し、元の位置・ズーム・負tilt を返す。 + val pitchAbsRad = Math.toRadians(pitchAbsDeg) + val shiftedCenter = position.toGeoPoint() + val googleZoom = ZoomAltitudeConverter.tomtomZoomToGoogleZoom(zoom, position.latitude) + val originalGoogleZoom = googleZoom - NEGATIVE_TILT_ZOOM_OFFSET_AT_MAX_TILT * (pitchAbsDeg / 60.0) + val originalTomTomZoom = ZoomAltitudeConverter.googleZoomToTomTomZoom(originalGoogleZoom, shiftedCenter.latitude) + val altitude = converter.zoomLevelToAltitude(originalTomTomZoom, shiftedCenter.latitude, 0.0) + val distanceBackward = altitude * cos(pitchAbsRad) * tan(pitchAbsRad) * NEGATIVE_TILT_TARGET_DISTANCE_SCALE + val originalPosition = Spherical.computeOffset(shiftedCenter, distanceBackward, rotation + 180.0) + + return MapCameraPosition( + position = originalPosition.copy(altitude = altitude), + zoom = originalGoogleZoom, + bearing = CameraBearing.bearingFromNativeHeading(rotation), + tilt = -pitchAbsDeg, + paddings = paddings, + visibleRegion = null, + ) +} From dc877dbe49ca578d81e8dfa7493b9145e279bd6d Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Mon, 21 Sep 2026 23:44:26 +0900 Subject: [PATCH 02/25] 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. --- README.md | 41 ++++++++ .../tomtom-okhttp5-raster-to-vector-report.md | 97 +++++++++++++++++++ .../mapconductor/tomtom/TomTomMapDesign.kt | 21 +++- .../tomtom/marker/TomTomMarkerController.kt | 1 + 4 files changed, 156 insertions(+), 4 deletions(-) create mode 100644 docs/tomtom-okhttp5-raster-to-vector-report.md diff --git a/README.md b/README.md index d3e76a1..5d8a60e 100644 --- a/README.md +++ b/README.md @@ -312,6 +312,47 @@ fun GroundImageExample() { moving is treated as a click (`onClick`). The finger's screen coordinate is converted with `TomTomMap.coordinateForPoint`, and the marker is repositioned by updating `Marker.coordinate`. +- **Map designs use the classic `StandardStyles.TomTomMaps.*`, not `TomTomOrbisMaps.*`**: + loading an Orbis descriptor (`tomtom://styles/standard/orbismap/browsing`) makes `loadStyle` + report `onSuccess()` while nothing is drawn — the map is left as a flat background colour. + Orbis vector maps require a separate entitlement on the API key; without it the failure is + silent rather than an error (`api.tomtom.com/maps/orbis/map-display/...` answers 400 while the + classic `api.tomtom.com/map/1/tile/basic/main/...` answers 200). Verified on a Pixel 5a with + map-display 2.4.x. Switch these back to `TomTomOrbisMaps.*` once an Orbis-entitled key is + available. +- **★ The app must pin OkHttp to 4.x.** TomTom Orbis Maps SDK 2.4.x is built against OkHttp + 4.x. With **OkHttp 5.x on the classpath, switching from the satellite (raster) style back to a + vector style leaves the map as a flat background colour** — `loadStyle` still reports + `onSuccess()`, `map.layers.size` still reports the full 137 layers, the camera is unchanged, + and no exception or HTTP error is logged. Panning does not recover it. Vector→vector + (Standard ⇄ Driving) is unaffected; only raster→vector breaks. + + The trigger is transitive: ArcGIS Maps SDK for Kotlin 300.1.0 brings `okhttp 5.3.2`, and + Gradle's highest-version-wins resolution lifts TomTom's `4.12.0` to `5.3.2`. That is why the + symptom only ever appeared in apps hosting several map SDKs, and never in a TomTom-only app. + + Verified both ways on a Pixel 5a with map-display 2.4.2, in a TomTom-only sample app: + + | ArcGIS on the classpath | resolved OkHttp | satellite → standard | + |---|---|---| + | no | 4.12.0 (default) | renders | + | no | 5.3.2 (forced) | **blank** | + | yes | 5.3.2 (default) | **blank** | + | yes | 4.12.0 (pinned) | renders | + + A library cannot pin this for its consumers, so the app must do it: + + ```kotlin + configurations.configureEach { + resolutionStrategy { + force("com.squareup.okhttp3:okhttp:4.12.0") + } + } + ``` + + `example-app/build.gradle.kts` and the React Native example carry exactly this. A report ready + to send to TomTom is in `docs/tomtom-okhttp5-raster-to-vector-report.md`. + ## License Apache License 2.0 diff --git a/docs/tomtom-okhttp5-raster-to-vector-report.md b/docs/tomtom-okhttp5-raster-to-vector-report.md new file mode 100644 index 0000000..2c173d4 --- /dev/null +++ b/docs/tomtom-okhttp5-raster-to-vector-report.md @@ -0,0 +1,97 @@ +# TomTom Orbis Maps SDK 2.4.2 — raster→vector style switch renders nothing when OkHttp 5.x is on the classpath + +## Summary + +With `com.squareup.okhttp3:okhttp:5.x` resolved on the application classpath, loading a vector +style after the satellite (raster) style leaves the map as a flat background colour. Nothing is +drawn — no basemap, no labels, no markers, no overlays. + +The failure is silent: + +- `TomTomMap.loadStyle(...)` invokes `StyleLoadingCallback.onSuccess()`. +- `TomTomMap.layers.size` reports the full layer count of the loaded style (137 for BROWSING). +- The camera is unchanged and correct. +- No exception, no HTTP error, and nothing from `mapdisplay.clientlib.*` in logcat. + +Panning or zooming does not recover it. Loading the same vector style a second time does not +recover it. Recreating the `MapView` does. + +Pinning OkHttp back to `4.12.0` — changing nothing else — fixes it completely. + +## Affected + +- `com.tomtom.sdk.maps:map-display-standard:2.4.2` (flavour `complete`) +- `com.squareup.okhttp3:okhttp:5.3.2` (also reproduced via 5.x pulled transitively) +- Device: Pixel 5a, Android 16, arm64-v8a. GPU: Adreno. +- Also seen on a React Native (Hermes) app on the same device. + +## Steps to reproduce + +1. A single-Activity app with one `MapView`, no other map SDK. +2. Add to the application module: + + ```kotlin + configurations.configureEach { + resolutionStrategy { + force("com.squareup.okhttp3:okhttp:5.3.2") + } + } + ``` + +3. Load `StandardStyles.TomTomMaps.BROWSING`. → renders correctly. +4. `loadStyle(StandardStyles.TomTomMaps.SATELLITE)`. → renders correctly. +5. `loadStyle(StandardStyles.TomTomMaps.BROWSING)`. → **blank; `onSuccess()` is still called.** + +Removing step 2 (leaving OkHttp at the 4.12.0 the SDK resolves by itself) makes step 5 render +correctly. + +## What is and is not affected + +| transition | OkHttp 4.12.0 | OkHttp 5.3.2 | +|---|---|---| +| initial vector load | renders | renders | +| vector → vector (BROWSING ⇄ DRIVING) | renders | renders | +| vector → raster (→ SATELLITE) | renders | renders | +| **raster → vector (SATELLITE → BROWSING)** | renders | **blank** | + +Only the raster→vector direction breaks. `StandardStyles.TomTomMaps.SATELLITE` is the only one of +the three standard descriptors that carries a layer-mapping URI +(`tomtom://mapping/standard/tomtommap/satellite`); BROWSING and DRIVING have +`layerMappingUri == null`. That may be where the raster→vector path differs. + +## How this is hit in practice + +Applications rarely choose OkHttp 5 deliberately. It arrives transitively — in our case from +`com.esri:arcgis-maps-kotlin:300.1.0`, which requires `okhttp 5.3.2`. Gradle's +highest-version-wins resolution then lifts the SDK's own `4.12.0` to `5.3.2` and the map breaks, +with nothing in the logs to point at the cause. + +Verified on-device in both directions, in a TomTom-only sample app: + +| ArcGIS on the classpath | resolved OkHttp | satellite → standard | +|---|---|---| +| no | 4.12.0 (default) | renders | +| no | 5.3.2 (forced) | blank | +| yes | 5.3.2 (default) | blank | +| yes | 4.12.0 (pinned) | renders | + +## Ruled out + +Each of these was tested on-device and did **not** change the outcome: + +- Compose (`AndroidView`) vs. a plain View hierarchy +- `MapOptions.renderToTexture` true / false +- markers, polygons and polylines present or absent +- re-applying the camera after the style load +- `StyleController.setStyleMode(StyleMode.MAIN)` +- loading the vector style twice (`onSuccess()` twice, still blank) +- supplying a layer mapping for the vector style — there is none: + `loadStyle failed: Unrecognized uri tomtom://mapping/standard/tomtommap/browsing` +- packaging other map SDKs' native libraries (MapLibre, Mapbox, ArcGIS) without initialising them + — the ArcGIS native libraries can be excluded from the APK entirely and the bug still occurs, + which is what pointed at the dependency graph rather than at native symbol collisions + +## Ask + +Either support OkHttp 5.x, or declare the incompatibility so the failure is not silent — for +example by failing `loadStyle` with a real `LoadingStyleFailure` instead of reporting success. diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt index 1ed5c98..7a7dba3 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt @@ -8,7 +8,20 @@ import com.tomtom.sdk.map.display.style.StyleDescriptor typealias TomTomMapDesignType = MapDesignTypeInterface /** - * TomTom Orbis Maps のマップデザイン(スタイル)。 + * TomTom のマップデザイン(スタイル)。 + * + * ## ★ Orbis のスタイル記述子は使わない + * + * `StandardStyles.TomTomOrbisMaps.*`(`tomtom://styles/standard/orbismap/browsing` 等)を + * 渡すと `loadStyle` は **success を返すのに何も描画されない**(地色だけの地図になる)。 + * 実機(Pixel 5a / map-display 2.4.x)で確認したうえ、API 側も + * `api.tomtom.com/maps/orbis/map-display/...` が 400 を返し、classic の + * `api.tomtom.com/map/1/tile/basic/main/...` は 200 を返す。Orbis のベクタ地図は + * 別建ての権限が要り、キーがそれを持たないと**エラーではなく無音の白紙**になる。 + * + * `MapOptions.mapStyle` の既定は `null`(SDK 内部の既定スタイル)で、これは描画される。 + * その挙動に合わせて classic の `StandardStyles.TomTomMaps.*` を使う。Orbis が要る + * 場合は、Orbis 権限付きのキーを用意したうえでここを差し替えること。 * * `id` / `getValue()` は安定キー(保存・復元に使用)で、実際に TomTom へ読み込ませる * [StyleDescriptor] は [styleDescriptor] が保持する(ライト/ダークは各 [StandardStyles] @@ -20,13 +33,13 @@ sealed class TomTomMapDesign( override val attributionRules: List = emptyList(), ) : TomTomMapDesignType { /** 既定(ブラウジング)スタイル。 */ - object Standard : TomTomMapDesign("standard", StandardStyles.TomTomOrbisMaps.BROWSING) + object Standard : TomTomMapDesign("standard", StandardStyles.TomTomMaps.BROWSING) /** ナビゲーション向けスタイル。 */ - object Driving : TomTomMapDesign("driving", StandardStyles.TomTomOrbisMaps.DRIVING) + object Driving : TomTomMapDesign("driving", StandardStyles.TomTomMaps.DRIVING) /** 衛星写真スタイル。 */ - object Satellite : TomTomMapDesign("satellite", StandardStyles.TomTomOrbisMaps.SATELLITE) + object Satellite : TomTomMapDesign("satellite", StandardStyles.TomTomMaps.SATELLITE) /** 任意の [StyleDescriptor](独自スタイル URI 等)を使うカスタムデザイン。 */ class Custom( diff --git a/src/main/java/com/mapconductor/tomtom/marker/TomTomMarkerController.kt b/src/main/java/com/mapconductor/tomtom/marker/TomTomMarkerController.kt index f0727e9..a5ad8fb 100644 --- a/src/main/java/com/mapconductor/tomtom/marker/TomTomMarkerController.kt +++ b/src/main/java/com/mapconductor/tomtom/marker/TomTomMarkerController.kt @@ -288,6 +288,7 @@ internal class TomTomMarkerController private constructor( cacheSizeBytes = markerTiling.cacheSize, debugTileOverlay = markerTiling.debugTileOverlay, iconScaleCallback = markerTiling.iconScaleCallback, + declutterPx = markerTiling.declutterPx, ) markerTileRenderer = tileRenderer tileServer.register(groupId, tileRenderer) From f3219003eb283846de0506e378be9ae275322112 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Tue, 29 Sep 2026 10:13:27 -0700 Subject: [PATCH 03/25] Add TomTomMapDesign.None and let the design reach the composed style With raster layers present the map shows a composed style, which always sat on the browsing style; the design was ignored. None now composes with every browsing layer hidden and at zero opacity and without the base raster, and a design change while layers are composed recomposes instead of loading the bare style (which dropped the raster layers). Measured on the TB520FU: the SDK still draws its basemap under this style, so None is not yet effective on Android. --- api/android-for-tomtom.api | 5 +- .../mapconductor/tomtom/TomTomMapDesign.kt | 6 + .../tomtom/TomTomMapViewController.kt | 10 + .../tomtom/TomTomMapViewControllerRaster.kt | 6 +- .../tomtom/raster/TomTomStyleComposer.kt | 454 ++++++++++-------- 5 files changed, 268 insertions(+), 213 deletions(-) diff --git a/api/android-for-tomtom.api b/api/android-for-tomtom.api index 98775dc..1983248 100644 --- a/api/android-for-tomtom.api +++ b/api/android-for-tomtom.api @@ -40,6 +40,9 @@ public final class com.mapconductor.tomtom.TomTomMapDesign$Custom extends com.ma public final class com.mapconductor.tomtom.TomTomMapDesign$Driving extends com.mapconductor.tomtom.TomTomMapDesign { public static final com.mapconductor.tomtom.TomTomMapDesign$Driving INSTANCE; } +public final class com.mapconductor.tomtom.TomTomMapDesign$None extends com.mapconductor.tomtom.TomTomMapDesign { + public static final com.mapconductor.tomtom.TomTomMapDesign$None INSTANCE; +} public final class com.mapconductor.tomtom.TomTomMapDesign$Satellite extends com.mapconductor.tomtom.TomTomMapDesign { public static final com.mapconductor.tomtom.TomTomMapDesign$Satellite INSTANCE; } @@ -326,7 +329,7 @@ public final class com.mapconductor.tomtom.raster.TomTomRasterLayerSink$DefaultI } public final class com.mapconductor.tomtom.raster.TomTomStyleComposer { public static final com.mapconductor.tomtom.raster.TomTomStyleComposer INSTANCE; - public final java.lang.Object composeRasterStyle(java.lang.String, java.io.File, java.util.List, java.io.File, kotlin.coroutines.Continuation); + public final java.lang.Object composeRasterStyle(java.lang.String, java.io.File, java.util.List, java.io.File, boolean, kotlin.coroutines.Continuation); } public final class com.mapconductor.tomtom.raster.TomTomStyleComposer$RasterSpec { public final java.lang.String getId(); diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt index 7a7dba3..b0022ef 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt @@ -3,6 +3,8 @@ package com.mapconductor.tomtom import com.mapconductor.core.map.AttributionRule import com.mapconductor.core.map.MapDesignTypeInterface import com.tomtom.sdk.map.display.style.StandardStyles +import android.net.Uri +import com.mapconductor.core.map.BlankMapStyle import com.tomtom.sdk.map.display.style.StyleDescriptor typealias TomTomMapDesignType = MapDesignTypeInterface @@ -33,6 +35,9 @@ sealed class TomTomMapDesign( override val attributionRules: List = emptyList(), ) : TomTomMapDesignType { /** 既定(ブラウジング)スタイル。 */ + /** ベースマップ無し。背景色だけのスタイル(core の同梱アセット)。 */ + object None : TomTomMapDesign("none", StyleDescriptor(Uri.parse(BlankMapStyle.ASSET_URI))) + object Standard : TomTomMapDesign("standard", StandardStyles.TomTomMaps.BROWSING) /** ナビゲーション向けスタイル。 */ @@ -53,6 +58,7 @@ sealed class TomTomMapDesign( companion object { fun create(id: String): TomTomMapDesign = when (id) { + None.id -> None Standard.id -> Standard Driving.id -> Driving Satellite.id -> Satellite diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt index 5bc675b..d14057f 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt @@ -299,6 +299,16 @@ class TomTomMapViewController internal constructor( val descriptor = (value as? TomTomMapDesign)?.styleDescriptor ?: TomTomMapDesign.create(value.id).styleDescriptor + // ラスタレイヤーがあるあいだは合成スタイルが地図の実体で、デザインはその + // 土台(ベースマップの有無)に効く。素のスタイルを読むとラスタごと消える。 + // 「無し」自体も合成スタイル(合成器のコメント参照)。 + val wasNone = mapDesignType.id == TomTomMapDesign.None.id + if (composedRasterLayers.isNotEmpty() || value.id == TomTomMapDesign.None.id || wasNone) { + mapDesignType = value + scheduleComposedStyleReload() + mapDesignTypeChangeListener?.invoke(value) + return + } mainCoroutine.launch { holder.map.loadStyle( descriptor, diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt index af75e79..46b9773 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt @@ -85,7 +85,10 @@ internal suspend fun TomTomMapViewController.applyComposedStyle() { if (destroyed) return val apiKey = rasterApiKey val cacheDir = rasterCacheDir - if (composedRasterLayers.isEmpty() || apiKey == null || cacheDir == null) { + // 「ベースマップ無し」自体が合成スタイル(合成器のコメント参照)なので、 + // ラスタレイヤーが無くても None なら合成する。 + val withoutBasemap = mapDesignType.id == TomTomMapDesign.None.id + if ((composedRasterLayers.isEmpty() && !withoutBasemap) || apiKey == null || cacheDir == null) { loadDesignStyle() return } @@ -97,6 +100,7 @@ internal suspend fun TomTomMapViewController.applyComposedStyle() { cacheDir = cacheDir, layers = composedRasterLayers.values.toList(), outFile = outFile, + withoutBasemap = withoutBasemap, ) ?: return if (destroyed) return withContext(Dispatchers.Main) { diff --git a/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt b/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt index 2f3130b..8e30de1 100644 --- a/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt +++ b/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt @@ -1,211 +1,243 @@ -package com.mapconductor.tomtom.raster - -import org.json.JSONArray -import org.json.JSONObject -import java.io.File -import java.net.HttpURLConnection -import java.net.URL -import android.net.Uri -import android.util.Log -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.withContext - -/** - * TomTom の browsing ベーススタイルへ「TomTom ラスタ地図(可視ベース)」と「自前マーカーラスタ」を - * 注入した合成 style JSON を組み立て、`loadStyle` 可能なローカル `file://` URI を返すユーティリティ。 - * - * ## 実機スパイクで確定した制約と、この構成の理由 - * TomTom Map Display SDK 1.26.7 には **実行時に source/layer を追加する公開 API が無い**ため、 - * マーカーラスタ層を足すにはスタイル全体を合成して `loadStyle` するしかない。さらに: - * - * 1. `loadStyle` は SDK オーバーレイ用の必須レイヤー(polyline-shape / polygon-shape / circle-shape / - * marker / route 等)がスタイルに存在することを要求する(無いと "Invalid layer mapping" で失敗)。 - * → **フルの browsing スタイルをベースにする**必要がある。 - * 2. ただし browsing の **proprietary ベクタタイルは `file://` ロードでは描画されない**(SDK 内部の - * ベクタタイルプロバイダ依存)。→ 可視ベース地図として **TomTom のラスタ地図タイル** - * (`map/1/tile/basic/main/{z}/{x}/{y}.png`)を最下層に足す(ラスタは `file://` でも描画される)。 - * 3. その上に自前マーカーラスタ(ローカルタイルサーバ)を重ねる。 - * - * ベーススタイル URL: `https://api.tomtom.com/style/1/style/25.2.*?key=...&map=gosdk/basic_street-light&...` - * (実機 preloadedStyles と `DefaultStyleUriTransformer` より確認。`25.2.*` はワイルドカードで CDN が - * 最新解決するため SDK パッチ更新に追随不要)。返却 JSON はキー埋め込み済み・MapLibre 互換 v8。 - * - * NOTE(security): 生成 JSON には API キーが平文で含まれる。書き出しは必ずアプリ private cacheDir に - * 限定し、URL/内容をログやリポジトリへ出力しないこと([[no-hardcoded-secrets]])。 - */ -object TomTomStyleComposer { - private const val TAG = "TomTomStyleComposer" - - /** browsing / light フルスタイルの実 URL テンプレート(%s = API キー)。SDK 必須レイヤーを含む。 */ - private const val BROWSING_STYLE_URL = - "https://api.tomtom.com/style/1/style/25.2.*" + - "?key=%s&map=gosdk/basic_street-light" + - "&traffic_incidents=gosdk/incidents_light&traffic_flow=gosdk/flow_relative-light" + - "&hillshade=2-test/hillshade_dem-light" - - /** 可視ベースに使う TomTom ラスタ地図タイル(basic/main)テンプレート(%s = API キー)。 */ - private const val BASE_RASTER_TILES = "https://api.tomtom.com/map/1/tile/basic/main/{z}/{x}/{y}.png?key=%s" - - private const val TILE_SIZE = 256 - - /** 合成スタイルに載せる自前ラスタレイヤー1枚分の指定。 */ - data class RasterSpec( - val id: String, - val tilesUrl: String, - val opacity: Double, - val tileSize: Int = TILE_SIZE, - // ソースの minzoom/maxzoom。特に maxzoom を設定するとそれ以上のズームでは - // maxzoom タイルをオーバーズーム表示するため、実タイルが無い高ズームでの - // 404(=歯抜け)を防げる。null なら未指定(全ズームで実タイルを要求)。 - val minZoom: Int? = null, - val maxZoom: Int? = null, - ) - - /** - * 合成スタイル(フル browsing + ラスタベース + 任意のラスタレイヤー群)を生成し、その `file://` URI を返す。 - * マーカータイル・GroundImage など複数のラスタレイヤーを [layers] の順(=下→上)で重ねられる。 - * - * @param apiKey TomTom API キー - * @param cacheDir 書き出し先(アプリ private `context.cacheDir`) - * @param layers 追加するラスタレイヤー群(tiles URL テンプレートは `{z}/{x}/{y}` を含むローカルサーバ URL) - */ - suspend fun composeRasterStyle( - apiKey: String, - cacheDir: File, - layers: List, - outFile: File = File(cacheDir, "tomtom_composed_style.json"), - ): Uri? = - withContext(Dispatchers.IO) { - val baseJson = - fetch(String.format(BROWSING_STYLE_URL, apiKey)) ?: run { - Log.e(TAG, "Failed to fetch base style JSON") - return@withContext null - } - - val root = - try { - JSONObject(baseJson) - } catch (e: Exception) { - Log.e(TAG, "Failed to parse base style JSON", e) - return@withContext null - } - - val sources = root.optJSONObject("sources") ?: JSONObject().also { root.put("sources", it) } - sources.put("mc-base-raster", rasterSource(String.format(BASE_RASTER_TILES, apiKey), TILE_SIZE, null, null)) - - val styleLayers = root.optJSONArray("layers") ?: JSONArray().also { root.put("layers", it) } - // 可視ベース地図(ラスタ)は最下層付近("background" の直後)に挿入し、 - // ラベル/オーバーレイ/マーカーがその上に来るようにする。 - val baseLayer = rasterLayer("mc-base-raster-layer", "mc-base-raster", 1.0) - val insertAt = - if (styleLayers.length() > 0 && - styleLayers.optJSONObject(0)?.optString("type") == "background" - ) { - 1 - } else { - 0 - } - insertLayerAt(styleLayers, insertAt, baseLayer) - - // 自前ラスタレイヤー(マーカータイル / GroundImage など)を最前面(末尾)へ順に重ねる。 - layers.forEachIndexed { index, spec -> - val sourceId = "mc-raster-src-$index" - sources.put(sourceId, rasterSource(spec.tilesUrl, spec.tileSize, spec.minZoom, spec.maxZoom)) - styleLayers.put(rasterLayer("mc-raster-layer-$index", sourceId, spec.opacity)) - } - - try { - outFile.writeText(root.toString()) - } catch (e: Exception) { - Log.e(TAG, "Failed to write composed style", e) - return@withContext null - } - Log.i( - TAG, - "Composed style written (${outFile.length()} bytes, ${styleLayers.length()} layers, ${layers.size} raster)", - ) - Uri.fromFile(outFile) - } - - /** - * この SDK は宣言した `tileSize` の**倍の大きさ**でタイルを敷く。 - * - * MapConductor の `tileSize` は「タイル 1 枚が覆うレイアウト単位」で、MapLibre は - * そのとおりに敷く。同じスタイル JSON を渡しているのに、この SDK は 1 段粗いズームの - * タイルを取ってきて 2 倍に引き伸ばす。 - * - * 実測(GeoJSON Layer ページ、地図ズーム 13、`tileSize` 512、Lenovo 実機): - * MapLibre / MapTiler / Longdo が線 6px なのに対し TomTom だけ 12px。 - * iOS でも同じ倍率(MapLibre 18px に対し TomTom 35px)で、要求されるタイルが - * z=12 ではなく z=11 になっていることまで確認してある。半分を宣言すると揃う。 - * - * **ここを外すと GeoJSON レイヤ・ヒートマップ・タイル方式マーカーが揃って 2 倍に - * 描かれる**(線が異常に太く、しかもぼやける)。 - * ios-for-tomtom の `TomTomStyleComposer.tileSizeScale` と同じ扱い。 - */ - private const val TILE_SIZE_SCALE = 2 - - private fun rasterSource( - tilesUrl: String, - tileSize: Int, - minZoom: Int?, - maxZoom: Int?, - ): JSONObject = - JSONObject().apply { - put("type", "raster") - put("tiles", JSONArray().put(tilesUrl)) - put("tileSize", (tileSize / TILE_SIZE_SCALE).coerceAtLeast(1)) - minZoom?.let { put("minzoom", it) } - // maxzoom を設定すると、それ以上のズームでは maxzoom タイルをスケールして - // 表示する(オーバーズーム)ため、実タイルが無い高ズームでの歯抜けを防ぐ。 - maxZoom?.let { put("maxzoom", it) } - } - - private fun rasterLayer( - id: String, - source: String, - opacity: Double, - ): JSONObject = - JSONObject().apply { - put("id", id) - put("type", "raster") - put("source", source) - put("paint", JSONObject().put("raster-opacity", opacity)) - } - - /** JSONArray への位置指定挿入(org.json は insert が無いため末尾に足してからシフト)。 */ - private fun insertLayerAt( - layers: JSONArray, - index: Int, - layer: JSONObject, - ) { - layers.put(layer) - for (i in layers.length() - 1 downTo index + 1) { - layers.put(i, layers.get(i - 1)) - } - layers.put(index, layer) - } - - private fun fetch(url: String): String? = - try { - (URL(url).openConnection() as HttpURLConnection).run { - connectTimeout = 15_000 - readTimeout = 15_000 - requestMethod = "GET" - setRequestProperty("User-Agent", "MapConductor") - try { - if (responseCode in 200..299) { - inputStream.bufferedReader().use { it.readText() } - } else { - Log.e(TAG, "Base style fetch HTTP $responseCode") - null - } - } finally { - disconnect() - } - } - } catch (e: Exception) { - Log.e(TAG, "Base style fetch error", e) - null - } -} +package com.mapconductor.tomtom.raster + +import com.mapconductor.core.map.BlankMapStyle +import org.json.JSONArray +import org.json.JSONObject +import java.io.File +import java.net.HttpURLConnection +import java.net.URL +import android.net.Uri +import android.util.Log +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext + +/** + * TomTom の browsing ベーススタイルへ「TomTom ラスタ地図(可視ベース)」と「自前マーカーラスタ」を + * 注入した合成 style JSON を組み立て、`loadStyle` 可能なローカル `file://` URI を返すユーティリティ。 + * + * ## 実機スパイクで確定した制約と、この構成の理由 + * TomTom Map Display SDK 1.26.7 には **実行時に source/layer を追加する公開 API が無い**ため、 + * マーカーラスタ層を足すにはスタイル全体を合成して `loadStyle` するしかない。さらに: + * + * 1. `loadStyle` は SDK オーバーレイ用の必須レイヤー(polyline-shape / polygon-shape / circle-shape / + * marker / route 等)がスタイルに存在することを要求する(無いと "Invalid layer mapping" で失敗)。 + * → **フルの browsing スタイルをベースにする**必要がある。 + * 2. ただし browsing の **proprietary ベクタタイルは `file://` ロードでは描画されない**(SDK 内部の + * ベクタタイルプロバイダ依存)。→ 可視ベース地図として **TomTom のラスタ地図タイル** + * (`map/1/tile/basic/main/{z}/{x}/{y}.png`)を最下層に足す(ラスタは `file://` でも描画される)。 + * 3. その上に自前マーカーラスタ(ローカルタイルサーバ)を重ねる。 + * + * ベーススタイル URL: `https://api.tomtom.com/style/1/style/25.2.*?key=...&map=gosdk/basic_street-light&...` + * (実機 preloadedStyles と `DefaultStyleUriTransformer` より確認。`25.2.*` はワイルドカードで CDN が + * 最新解決するため SDK パッチ更新に追随不要)。返却 JSON はキー埋め込み済み・MapLibre 互換 v8。 + * + * NOTE(security): 生成 JSON には API キーが平文で含まれる。書き出しは必ずアプリ private cacheDir に + * 限定し、URL/内容をログやリポジトリへ出力しないこと([[no-hardcoded-secrets]])。 + */ +object TomTomStyleComposer { + private const val TAG = "TomTomStyleComposer" + + /** browsing / light フルスタイルの実 URL テンプレート(%s = API キー)。SDK 必須レイヤーを含む。 */ + private const val BROWSING_STYLE_URL = + "https://api.tomtom.com/style/1/style/25.2.*" + + "?key=%s&map=gosdk/basic_street-light" + + "&traffic_incidents=gosdk/incidents_light&traffic_flow=gosdk/flow_relative-light" + + "&hillshade=2-test/hillshade_dem-light" + + /** 可視ベースに使う TomTom ラスタ地図タイル(basic/main)テンプレート(%s = API キー)。 */ + private const val BASE_RASTER_TILES = "https://api.tomtom.com/map/1/tile/basic/main/{z}/{x}/{y}.png?key=%s" + + private const val TILE_SIZE = 256 + + /** 合成スタイルに載せる自前ラスタレイヤー1枚分の指定。 */ + data class RasterSpec( + val id: String, + val tilesUrl: String, + val opacity: Double, + val tileSize: Int = TILE_SIZE, + // ソースの minzoom/maxzoom。特に maxzoom を設定するとそれ以上のズームでは + // maxzoom タイルをオーバーズーム表示するため、実タイルが無い高ズームでの + // 404(=歯抜け)を防げる。null なら未指定(全ズームで実タイルを要求)。 + val minZoom: Int? = null, + val maxZoom: Int? = null, + ) + + /** + * 合成スタイル(フル browsing + ラスタベース + 任意のラスタレイヤー群)を生成し、その `file://` URI を返す。 + * マーカータイル・GroundImage など複数のラスタレイヤーを [layers] の順(=下→上)で重ねられる。 + * + * @param apiKey TomTom API キー + * @param cacheDir 書き出し先(アプリ private `context.cacheDir`) + * @param layers 追加するラスタレイヤー群(tiles URL テンプレートは `{z}/{x}/{y}` を含むローカルサーバ URL) + */ + suspend fun composeRasterStyle( + apiKey: String, + cacheDir: File, + layers: List, + outFile: File = File(cacheDir, "tomtom_composed_style.json"), + // [TomTomMapDesign.None]: ベースマップを描かない(本文のコメント参照)。 + withoutBasemap: Boolean = false, + ): Uri? = + withContext(Dispatchers.IO) { + val baseJson = + fetch(String.format(BROWSING_STYLE_URL, apiKey)) ?: run { + Log.e(TAG, "Failed to fetch base style JSON") + return@withContext null + } + + val root = + try { + JSONObject(baseJson) + } catch (e: Exception) { + Log.e(TAG, "Failed to parse base style JSON", e) + return@withContext null + } + + val sources = root.optJSONObject("sources") ?: JSONObject().also { root.put("sources", it) } + val styleLayers = root.optJSONArray("layers") ?: JSONArray().also { root.put("layers", it) } + if (withoutBasemap) { + // browsing スタイルを骨組みのまま残し(この SDK は自前のレイヤーを持たない + // スタイルを渡すと既定スタイルへ戻る)、background 以外の全レイヤーを + // 非表示にする。TomTom のタイルは取得されず、ラスタは背景色の上に載る。 + // この SDK は読み込み後に自分のレイヤーの visibility を戻す(実測: 非表示だけでは + // ベースマップが残った。iOS 版はそれで消える)ので、不透明度も 0 にする。 + for (i in 0 until styleLayers.length()) { + val layer = styleLayers.optJSONObject(i) ?: continue + val type = layer.optString("type") + if (type == "background") { + layer.put("paint", JSONObject().put("background-color", BlankMapStyle.BACKGROUND_COLOR)) + continue + } + val layout = layer.optJSONObject("layout") ?: JSONObject().also { layer.put("layout", it) } + layout.put("visibility", "none") + val paint = layer.optJSONObject("paint") ?: JSONObject().also { layer.put("paint", it) } + when (type) { + "fill" -> paint.put("fill-opacity", 0) + "line" -> paint.put("line-opacity", 0) + "symbol" -> { paint.put("text-opacity", 0); paint.put("icon-opacity", 0) } + "raster" -> paint.put("raster-opacity", 0) + "fill-extrusion" -> paint.put("fill-extrusion-opacity", 0) + "circle" -> { paint.put("circle-opacity", 0); paint.put("circle-stroke-opacity", 0) } + "heatmap" -> paint.put("heatmap-opacity", 0) + "hillshade" -> paint.put("hillshade-exaggeration", 0) + } + } + } else { + sources.put("mc-base-raster", rasterSource(String.format(BASE_RASTER_TILES, apiKey), TILE_SIZE, null, null)) + + // 可視ベース地図(ラスタ)は最下層付近("background" の直後)に挿入し、 + // ラベル/オーバーレイ/マーカーがその上に来るようにする。 + val baseLayer = rasterLayer("mc-base-raster-layer", "mc-base-raster", 1.0) + val insertAt = + if (styleLayers.length() > 0 && + styleLayers.optJSONObject(0)?.optString("type") == "background" + ) { + 1 + } else { + 0 + } + insertLayerAt(styleLayers, insertAt, baseLayer) + } + + // 自前ラスタレイヤー(マーカータイル / GroundImage など)を最前面(末尾)へ順に重ねる。 + layers.forEachIndexed { index, spec -> + val sourceId = "mc-raster-src-$index" + sources.put(sourceId, rasterSource(spec.tilesUrl, spec.tileSize, spec.minZoom, spec.maxZoom)) + styleLayers.put(rasterLayer("mc-raster-layer-$index", sourceId, spec.opacity)) + } + + try { + outFile.writeText(root.toString()) + } catch (e: Exception) { + Log.e(TAG, "Failed to write composed style", e) + return@withContext null + } + Log.i( + TAG, + "Composed style written (${outFile.length()} bytes, ${styleLayers.length()} layers, ${layers.size} raster)", + ) + Uri.fromFile(outFile) + } + + /** + * この SDK は宣言した `tileSize` の**倍の大きさ**でタイルを敷く。 + * + * MapConductor の `tileSize` は「タイル 1 枚が覆うレイアウト単位」で、MapLibre は + * そのとおりに敷く。同じスタイル JSON を渡しているのに、この SDK は 1 段粗いズームの + * タイルを取ってきて 2 倍に引き伸ばす。 + * + * 実測(GeoJSON Layer ページ、地図ズーム 13、`tileSize` 512、Lenovo 実機): + * MapLibre / MapTiler / Longdo が線 6px なのに対し TomTom だけ 12px。 + * iOS でも同じ倍率(MapLibre 18px に対し TomTom 35px)で、要求されるタイルが + * z=12 ではなく z=11 になっていることまで確認してある。半分を宣言すると揃う。 + * + * **ここを外すと GeoJSON レイヤ・ヒートマップ・タイル方式マーカーが揃って 2 倍に + * 描かれる**(線が異常に太く、しかもぼやける)。 + * ios-for-tomtom の `TomTomStyleComposer.tileSizeScale` と同じ扱い。 + */ + private const val TILE_SIZE_SCALE = 2 + + private fun rasterSource( + tilesUrl: String, + tileSize: Int, + minZoom: Int?, + maxZoom: Int?, + ): JSONObject = + JSONObject().apply { + put("type", "raster") + put("tiles", JSONArray().put(tilesUrl)) + put("tileSize", (tileSize / TILE_SIZE_SCALE).coerceAtLeast(1)) + minZoom?.let { put("minzoom", it) } + // maxzoom を設定すると、それ以上のズームでは maxzoom タイルをスケールして + // 表示する(オーバーズーム)ため、実タイルが無い高ズームでの歯抜けを防ぐ。 + maxZoom?.let { put("maxzoom", it) } + } + + private fun rasterLayer( + id: String, + source: String, + opacity: Double, + ): JSONObject = + JSONObject().apply { + put("id", id) + put("type", "raster") + put("source", source) + put("paint", JSONObject().put("raster-opacity", opacity)) + } + + /** JSONArray への位置指定挿入(org.json は insert が無いため末尾に足してからシフト)。 */ + private fun insertLayerAt( + layers: JSONArray, + index: Int, + layer: JSONObject, + ) { + layers.put(layer) + for (i in layers.length() - 1 downTo index + 1) { + layers.put(i, layers.get(i - 1)) + } + layers.put(index, layer) + } + + private fun fetch(url: String): String? = + try { + (URL(url).openConnection() as HttpURLConnection).run { + connectTimeout = 15_000 + readTimeout = 15_000 + requestMethod = "GET" + setRequestProperty("User-Agent", "MapConductor") + try { + if (responseCode in 200..299) { + inputStream.bufferedReader().use { it.readText() } + } else { + Log.e(TAG, "Base style fetch HTTP $responseCode") + null + } + } finally { + disconnect() + } + } + } catch (e: Exception) { + Log.e(TAG, "Base style fetch error", e) + null + } +} From 2a9d637a91ee557f74eb39c0e517a42177d51218 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Mon, 5 Oct 2026 14:53:28 -0700 Subject: [PATCH 04/25] update dependencies (#7) --- gradle.properties | 2 +- gradle/libs.versions.toml | 16 ++++++++-------- 2 files changed, 9 insertions(+), 9 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 27e4342..52dd199 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -1,18 +1,18 @@ [versions] -composeLibs = "1.7.8" +composeLibs = "1.12.1" # material3 は compose-ui とは別のバージョン系列。composeLibs(ui 系)を流用すると # 存在しない material3:1.7.8 を要求してクラスパスごと解決に失敗する。 material3 = "1.4.0" -coroutines = "1.9.0" -agp = "9.2.1" -kotlin = "2.0.21" +coroutines = "1.11.0" +agp = "9.4.1" +kotlin = "2.4.20" -composeBom = "2025.02.00" -lifecycleRuntimeKtx = "2.8.7" +composeBom = "2026.09.00" +lifecycleRuntimeKtx = "2.11.0" # TomTom Orbis Maps Display SDK # 参照: https://developer.tomtom.com/android/maps/documentation -tomtomMaps = "2.4.1" -activityCompose = "1.9.3" +tomtomMaps = "2.6.2" +activityCompose = "1.13.0" ktLint = "14.2.0" junit = "4.13.2" From 29d3e822351f84dfa58cde6bbdb796f1b0453909 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 24 Oct 2026 01:59:54 -0700 Subject: [PATCH 05/25] Update TomTom Maps to 2.6.3 (#8) --- gradle/libs.versions.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 52dd199..a8e71c5 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -11,7 +11,7 @@ composeBom = "2026.09.00" lifecycleRuntimeKtx = "2.11.0" # TomTom Orbis Maps Display SDK # 参照: https://developer.tomtom.com/android/maps/documentation -tomtomMaps = "2.6.2" +tomtomMaps = "2.6.3" activityCompose = "1.13.0" ktLint = "14.2.0" From 4ff8aadc6b9593eca4a3a104e647c6e3c144439b Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 24 Oct 2026 10:52:12 -0700 Subject: [PATCH 06/25] Vector style support and cache the base style for offline startup (#9) * Cache TomTom base style for offline startup * 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-tomtom.api | 4 +- .../mapconductor/tomtom/TomTomMapDesign.kt | 4 +- .../com/mapconductor/tomtom/TomTomMapView.kt | 12 ++++++ .../tomtom/TomTomMapViewController.kt | 17 ++++++++ .../tomtom/raster/TomTomStyleComposer.kt | 39 +++++++++++++++---- 5 files changed, 66 insertions(+), 10 deletions(-) diff --git a/api/android-for-tomtom.api b/api/android-for-tomtom.api index 1983248..940e2ea 100644 --- a/api/android-for-tomtom.api +++ b/api/android-for-tomtom.api @@ -86,6 +86,8 @@ public final class com.mapconductor.tomtom.TomTomMapViewController extends com.m public void setMapDesignTypeChangeListener(kotlin.jvm.functions.Function1, kotlin.Unit>); public java.lang.Object compositionRasterLayers(java.util.List, kotlin.coroutines.Continuation); public java.lang.Object updateRasterLayer(com.mapconductor.core.raster.RasterLayerState, kotlin.coroutines.Continuation); + public void mountRasterLayer(com.mapconductor.core.raster.RasterLayerState); + public void unmountRasterLayer(java.lang.String); public boolean hasRasterLayer(com.mapconductor.core.raster.RasterLayerState); public java.lang.Object upsertRasterLayer(java.lang.String, java.lang.String, double, int, java.lang.Integer, java.lang.Integer, kotlin.coroutines.Continuation); public java.lang.Object removeRasterLayer(java.lang.String, kotlin.coroutines.Continuation); @@ -150,7 +152,7 @@ public final class com.mapconductor.tomtom.TomTomMapViewHolder implements com.ma public java.lang.Object getMap(); } public final class com.mapconductor.tomtom.TomTomMapViewKt { - public static final void TomTomMapView(com.mapconductor.tomtom.TomTomMapViewState, 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 TomTomMapView(com.mapconductor.tomtom.TomTomMapViewState, 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.tomtom.TomTomMapViewController createTomTomMapViewController(com.mapconductor.tomtom.TomTomMapViewHolder, com.mapconductor.core.marker.MarkerTilingOptions, com.mapconductor.core.map.MutableMapServiceRegistry); } public final class com.mapconductor.tomtom.TomTomMapViewSaver extends com.mapconductor.compose.map.BaseMapViewSaver { diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt index b0022ef..372ae98 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt @@ -1,11 +1,11 @@ package com.mapconductor.tomtom import com.mapconductor.core.map.AttributionRule +import com.mapconductor.core.map.BlankMapStyle import com.mapconductor.core.map.MapDesignTypeInterface import com.tomtom.sdk.map.display.style.StandardStyles -import android.net.Uri -import com.mapconductor.core.map.BlankMapStyle import com.tomtom.sdk.map.display.style.StyleDescriptor +import android.net.Uri typealias TomTomMapDesignType = MapDesignTypeInterface diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt index 9b38301..cd55210 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt @@ -18,6 +18,7 @@ import com.mapconductor.core.map.MapCameraPosition import com.mapconductor.core.map.MapCameraPositionInterface import com.mapconductor.core.map.MapCapability import com.mapconductor.core.map.MapCapabilityStatus +import com.mapconductor.core.map.MapViewStyle import com.mapconductor.core.map.MutableMapServiceRegistry import com.mapconductor.core.marker.MarkerEventControllerInterface import com.mapconductor.core.marker.MarkerOverlayRendererInterface @@ -54,6 +55,15 @@ fun TomTomMapView( 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 TomTomMapViewScope.() -> Unit)? = null, ) { val scope = remember { TomTomMapViewScope() } @@ -182,6 +192,8 @@ fun TomTomMapView( // 地図が生成されない)。初期化が必要なのは検索/ルーティング等のナビ機能のみ。 sdkInitialize?.invoke(context) ?: true }, + style = style, + onStyleDiagnostics = onStyleDiagnostics, content = content, ) } diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt index d14057f..e8dd877 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt @@ -364,6 +364,23 @@ class TomTomMapViewController internal constructor( applyPublicRasterLayer(state) } + /** + * content の外から載せるラスタ(マーカータイル、ベクタースタイルのラスタ化)。 + * + * 他プロバイダは [com.mapconductor.core.raster.RasterLayerController] を + * オーバーレイコントローラとして登録してあるので基底の実装で足りるが、 + * TomTom はラスタを自前の合成スタイルへ畳み込むのでそれが無い。 + * **`publicRasterLayerIds` に入れないこと** — 入れると次の composition が + * 「アプリが宣言していないレイヤ」として掃除してしまう。 + */ + override fun mountRasterLayer(state: RasterLayerState) { + mainCoroutine.launch { applyPublicRasterLayer(state) } + } + + override fun unmountRasterLayer(id: String) { + mainCoroutine.launch { removeRasterLayer(id) } + } + override fun hasRasterLayer(state: RasterLayerState): Boolean = composedRasterLayers.containsKey(state.id) override suspend fun upsertRasterLayer( diff --git a/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt b/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt index 8e30de1..ae86578 100644 --- a/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt +++ b/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt @@ -47,6 +47,13 @@ object TomTomStyleComposer { /** 可視ベースに使う TomTom ラスタ地図タイル(basic/main)テンプレート(%s = API キー)。 */ private const val BASE_RASTER_TILES = "https://api.tomtom.com/map/1/tile/basic/main/{z}/{x}/{y}.png?key=%s" + /** + * The browsing style's skeleton, kept so a map with no network still has + * the SDK layers it insists on. Private cache only: the JSON carries the + * API key. + */ + private const val BASE_STYLE_CACHE_FILE = "tomtom_base_style.json" + private const val TILE_SIZE = 256 /** 合成スタイルに載せる自前ラスタレイヤー1枚分の指定。 */ @@ -79,11 +86,22 @@ object TomTomStyleComposer { withoutBasemap: Boolean = false, ): Uri? = withContext(Dispatchers.IO) { + // The SDK will not take a style that has none of its own layers + // (it reverts to its default), so every composed style is built + // on the browsing style's skeleton -- which lives on + // api.tomtom.com. Keeping the last copy on disk is what lets the + // map come up at all with no network: the skeleton is reused and + // only the raster layers on top, which are served from the + // device, are drawn. + val cachedBase = File(cacheDir, BASE_STYLE_CACHE_FILE) val baseJson = - fetch(String.format(BROWSING_STYLE_URL, apiKey)) ?: run { - Log.e(TAG, "Failed to fetch base style JSON") - return@withContext null - } + fetch(String.format(BROWSING_STYLE_URL, apiKey)) + ?.also { runCatching { cachedBase.writeText(it) } } + ?: cachedBase.takeIf { it.isFile }?.let { runCatching { it.readText() }.getOrNull() } + ?: run { + Log.e(TAG, "Failed to fetch base style JSON and no cached copy") + return@withContext null + } val root = try { @@ -114,16 +132,23 @@ object TomTomStyleComposer { when (type) { "fill" -> paint.put("fill-opacity", 0) "line" -> paint.put("line-opacity", 0) - "symbol" -> { paint.put("text-opacity", 0); paint.put("icon-opacity", 0) } + "symbol" -> { + paint.put("text-opacity", 0) + paint.put("icon-opacity", 0) + } "raster" -> paint.put("raster-opacity", 0) "fill-extrusion" -> paint.put("fill-extrusion-opacity", 0) - "circle" -> { paint.put("circle-opacity", 0); paint.put("circle-stroke-opacity", 0) } + "circle" -> { + paint.put("circle-opacity", 0) + paint.put("circle-stroke-opacity", 0) + } "heatmap" -> paint.put("heatmap-opacity", 0) "hillshade" -> paint.put("hillshade-exaggeration", 0) } } } else { - sources.put("mc-base-raster", rasterSource(String.format(BASE_RASTER_TILES, apiKey), TILE_SIZE, null, null)) + sources + .put("mc-base-raster", rasterSource(String.format(BASE_RASTER_TILES, apiKey), TILE_SIZE, null, null)) // 可視ベース地図(ラスタ)は最下層付近("background" の直後)に挿入し、 // ラベル/オーバーレイ/マーカーがその上に来るようにする。 From 8c6242ca67717fe90410c00bf3141ad69138388b Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Wed, 28 Oct 2026 13:47:13 -0700 Subject: [PATCH 07/25] 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 52504b73275a1a61dc8f3bef96ce44b5c2a8d51c Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Thu, 5 Nov 2026 14:58:14 -0800 Subject: [PATCH 08/25] 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. --- .../tomtom/marker/TomTomMarkerController.kt | 39 +++++++++++++++++-- 1 file changed, 35 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/mapconductor/tomtom/marker/TomTomMarkerController.kt b/src/main/java/com/mapconductor/tomtom/marker/TomTomMarkerController.kt index a5ad8fb..358615c 100644 --- a/src/main/java/com/mapconductor/tomtom/marker/TomTomMarkerController.kt +++ b/src/main/java/com/mapconductor/tomtom/marker/TomTomMarkerController.kt @@ -22,7 +22,11 @@ import com.mapconductor.core.tileserver.TileServerRegistry import com.mapconductor.tomtom.TomTomActualMarker import com.mapconductor.tomtom.TomTomMapViewHolder import java.util.UUID +import kotlin.time.Duration.Companion.milliseconds import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch import kotlinx.coroutines.sync.withPermit import kotlinx.coroutines.withContext @@ -143,11 +147,12 @@ internal class TomTomMarkerController private constructor( 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) { @@ -165,13 +170,15 @@ internal class TomTomMarkerController private constructor( tiling = true, ), ) - syncTiledOverlay() + scheduleTileRefresh() return } if (wasTiled) { tiledMarkerIds.remove(state.id) } + // ネイティブマーカーとして描くときだけ焼き込む。タイル担当なら要らない。 + val markerIcon = state.icon?.toBitmapIcon() ?: defaultMarkerIcon val renderEntity = MarkerEntity( @@ -207,7 +214,7 @@ internal class TomTomMarkerController private constructor( renderer.onPostProcess() if (tiledMarkerIds.isNotEmpty()) { - syncTiledOverlay() + scheduleTileRefresh() } else { removeTileOverlay() } @@ -215,6 +222,25 @@ internal class TomTomMarkerController private constructor( 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 = + (renderer as TomTomMarkerRenderer).coroutine.launch { + delay(TILE_REFRESH_COALESCE) + semaphore.withPermit { syncTiledOverlay() } + } + } + override suspend fun clear() { viewportSwitch.destroy() semaphore.withPermit { @@ -251,6 +277,8 @@ internal class TomTomMarkerController private constructor( override fun destroy() { viewportSwitch.destroy() + // 待っている描き直しが後から走ると、外したタイル経路をまた登録してしまう。 + tileRefreshJob?.cancel() // タイルサーバは他マップと共有のプロセス内シングルトンなので stop はしない。 // このマップ用のルート登録だけ解除する。 markerTileGroupId?.let { groupId -> tileServer.unregister(groupId) } @@ -354,6 +382,9 @@ internal class TomTomMarkerController private constructor( } companion object { + /** 続けて来る変更を 1 回の描き直しにまとめる窓。1 フレーム分。 */ + private val TILE_REFRESH_COALESCE = 16.milliseconds + fun create( holder: TomTomMapViewHolder, markerTiling: MarkerTilingOptions = MarkerTilingOptions.Default, From 09cca32096d92080906bcf49fb2fe416bf64a8b0 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Fri, 6 Nov 2026 19:25:13 -0800 Subject: [PATCH 09/25] Keep the map design across configuration changes - TomTomMapView never applied the state's design to the map (it used the MapOptions default) and the controller's default (Standard) was reported to the state on listener attach, so a passed-in or restored design became Standard. The design is applied first, then the listener attached. - The saver kept only the id; Custom designs (StyleDescriptor) and attribution rules were lost. It now saves the descriptor (Parcelable). - Device round-trip test. --- .../tomtom/TomTomMapViewSaverTest.kt | 87 +++++++++++++++++++ .../com/mapconductor/tomtom/TomTomMapView.kt | 12 ++- .../tomtom/TomTomMapViewStateImpl.kt | 33 +++++-- 3 files changed, 126 insertions(+), 6 deletions(-) create mode 100644 src/androidTest/java/com/mapconductor/tomtom/TomTomMapViewSaverTest.kt diff --git a/src/androidTest/java/com/mapconductor/tomtom/TomTomMapViewSaverTest.kt b/src/androidTest/java/com/mapconductor/tomtom/TomTomMapViewSaverTest.kt new file mode 100644 index 0000000..3b8e74f --- /dev/null +++ b/src/androidTest/java/com/mapconductor/tomtom/TomTomMapViewSaverTest.kt @@ -0,0 +1,87 @@ +package com.mapconductor.tomtom + +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 com.tomtom.sdk.map.display.style.StyleDescriptor +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.net.Uri +import android.os.Bundle +import android.os.Parcel + +/** + * 回転などの構成変更で state が [TomTomMapViewSaver] を通って作り直されても、デザイン(id・ + * attributionRules ほか)と uiSettings・カメラが落ちないこと。Bundle は実機の Parcel を一度通す。 + */ +@RunWith(AndroidJUnit4::class) +class TomTomMapViewSaverTest { + 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 keepsCustomDesignWithItsStyleDescriptor() { + val descriptor = StyleDescriptor(Uri.parse("https://example.com/style.json")) + val design = TomTomMapDesign.Custom("my-style", descriptor, rules) + val state = TomTomMapViewState(id = "tomtom-1", mapDesignType = design, cameraPosition = camera) + state.uiSettings = MapUISettings(rotateGesture = false, tiltGesture = false) + + val restored = roundTrip(TomTomMapViewSaver().createSaver(), state) + + // 以前は id だけを保存して create(id) で戻しており、Standard になっていた。 + val actual = restored.mapDesignType + assertTrue(actual is TomTomMapDesign.Custom) + actual as TomTomMapDesign.Custom + assertEquals("my-style", actual.id) + assertEquals(descriptor, actual.styleDescriptor) + assertEquals(rules, actual.attributionRules) + assertCommon(restored, "tomtom-1") + } + + @Test + fun keepsPresetDesignAsTheSameObject() { + val state = TomTomMapViewState(id = "tomtom-2", mapDesignType = TomTomMapDesign.Satellite) + assertSame(TomTomMapDesign.Satellite, roundTrip(TomTomMapViewSaver().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/tomtom/TomTomMapView.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt index cd55210..29f4a23 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt @@ -157,7 +157,6 @@ fun TomTomMapView( } mapController.setMapClickListener(onMapClick) mapController.setMapLongClickListener(onMapLongClick) - mapController.setMapDesignTypeChangeListener(state::onMapDesignTypeChange) cameraRestriction?.let { mapController.setCameraRestriction(it) } // 大量マーカーをラスタタイル化するため、マーカータイル用ラスタレイヤーの // 実体化(スタイル合成 + loadStyle)を配線する。 @@ -165,6 +164,17 @@ fun TomTomMapView( apiKey = tomtomApiKey(context), cacheDir = context.cacheDir, ) + // 地図は MapOptions の既定スタイル(= Standard)で作られる。state のデザインが + // それ以外なら載せる。そのあとでリスナーを繋ぐ: 先に繋ぐとコントローラの既定値 + // (Standard)が state へ返り、アプリが渡した(あるいは回転後に復元した) + // デザインが Standard に化ける。 + val initialDesign = state.mapDesignType + if (initialDesign === TomTomMapDesign.Standard) { + mapController.mapDesignType = initialDesign + } else { + mapController.setMapDesignType(initialDesign) + } + mapController.setMapDesignTypeChangeListener(state::onMapDesignTypeChange) holder.mapView.post { // Style loading can reset the camera, so reapply it once the view is attached. mapController.moveCamera(initialCameraPosition) diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewStateImpl.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewStateImpl.kt index 8192ec2..6609e88 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewStateImpl.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewStateImpl.kt @@ -9,7 +9,9 @@ import com.mapconductor.core.map.MapCameraPosition import com.mapconductor.core.map.MapCameraPositionInterface import com.mapconductor.core.map.MapPaddings import com.mapconductor.core.map.MapViewState +import com.mapconductor.core.map.MapViewStateBundle import com.mapconductor.core.map.MapViewStateInterface +import com.tomtom.sdk.map.display.style.StyleDescriptor import java.util.UUID import android.os.Bundle import kotlinx.coroutines.flow.MutableStateFlow @@ -61,7 +63,14 @@ class TomTomMapViewSaver : BaseMapViewSaver() { state: TomTomMapViewState, bundle: Bundle, ) { - bundle.putString("id", state.mapDesignType.id) + val design = state.mapDesignType + bundle.putString("id", design.id) + // 定義済み(Standard など)以外は、地図に読み込ませる StyleDescriptor(Parcelable)ごと + // 保存して Custom で戻す。id だけだと Custom は Standard に化け、attributionRules も落ちる。 + if (design is TomTomMapDesign && design !== TomTomMapDesign.create(design.id)) { + bundle.putParcelable(KEY_STYLE_DESCRIPTOR, design.styleDescriptor) + } + MapViewStateBundle.putAttributionRules(bundle, design.attributionRules) } override fun createState( @@ -71,16 +80,30 @@ class TomTomMapViewSaver : BaseMapViewSaver() { ): TomTomMapViewState = TomTomMapViewState( id = stateId, - mapDesignType = - TomTomMapDesign.create( - id = mapDesignBundle?.getString("id") ?: TomTomMapDesign.Standard.id, - ), + mapDesignType = restoreDesign(mapDesignBundle), cameraPosition = cameraPosition, ) + private fun restoreDesign(bundle: Bundle?): TomTomMapDesign { + val id = bundle?.getString("id") ?: return TomTomMapDesign.Standard + val rules = MapViewStateBundle.getAttributionRules(bundle) + + @Suppress("DEPRECATION") + val descriptor = bundle.getParcelable(KEY_STYLE_DESCRIPTOR) + val preset = TomTomMapDesign.create(id) + return when { + descriptor != null -> TomTomMapDesign.Custom(id, descriptor, rules) + rules.isNotEmpty() -> TomTomMapDesign.Custom(id, preset.styleDescriptor, rules) + else -> preset + } + } + override fun getStateId(state: TomTomMapViewState): String = state.id } +// 公開 API の門番(javap)にコンパニオンの定数が載らないよう、ファイル private にする。 +private const val KEY_STYLE_DESCRIPTOR = "styleDescriptor" + @Composable fun rememberTomTomMapViewState( mapDesign: TomTomMapDesign = TomTomMapDesign.Standard, From 398fa0ba0c4d8780ced99fed1a5da96570942c17 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 05:40:54 -0800 Subject: [PATCH 10/25] 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. TomTom composes rasters into its style; the polygon tiles go between the app's raster layers and the marker tiles. --- .../tomtom/TomTomMapViewControllerRaster.kt | 25 ++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt index 46b9773..024d811 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt @@ -1,5 +1,7 @@ package com.mapconductor.tomtom +import com.mapconductor.core.polygon.POLYGON_TILE_LAYER_ID +import com.mapconductor.core.polygon.PolygonTiler import com.mapconductor.core.raster.RasterLayerSource import com.mapconductor.core.raster.RasterLayerState import com.mapconductor.tomtom.marker.MarkerTileRasterLayerCallback @@ -46,6 +48,18 @@ fun TomTomMapViewController.setupMarkerTileRaster( upsertRasterLayer(TomTomMapViewController.MARKER_RASTER_ID, src.template, 1.0) }, ) + // Many polygons are drawn as raster tiles, composed into the style like the marker tiles. + // Not a public layer, so the app's RasterLayer composition never removes it. + polygonController.tiler = + PolygonTiler().apply { + onTemplate = { template, tileSize -> + if (template != null) { + upsertRasterLayer(POLYGON_TILE_LAYER_ID, template, 1.0, tileSize, null, null) + } else { + removeRasterLayer(POLYGON_TILE_LAYER_ID) + } + } + } } internal suspend fun TomTomMapViewController.applyPublicRasterLayer(state: RasterLayerState) { @@ -98,7 +112,8 @@ internal suspend fun TomTomMapViewController.applyComposedStyle() { TomTomStyleComposer.composeRasterStyle( apiKey = apiKey, cacheDir = cacheDir, - layers = composedRasterLayers.values.toList(), + // The app's layers, then the polygon tiles, then the marker tiles on top. + layers = composedRasterLayers.values.sortedBy { rasterOrder(it.id) }, outFile = outFile, withoutBasemap = withoutBasemap, ) ?: return @@ -140,3 +155,11 @@ internal fun TomTomMapViewController.styleLoadingCallback(tag: String) = android.util.Log.e("TomTomRaster", "loadStyle failed ($tag): $failure") } } + +/** Where a composed raster layer goes: imagery under polygons, polygons under markers. */ +private fun rasterOrder(id: String): Int = + when (id) { + TomTomMapViewController.MARKER_RASTER_ID -> 2 + POLYGON_TILE_LAYER_ID -> 1 + else -> 0 + } From 5fe46093d117138054203df56622246701150162 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 13:16:50 -0800 Subject: [PATCH 11/25] Pause and stop the MapView before destroying it, once The MapView went straight from resumed to onDestroy() when the map left. It is now wound down through onPause / onStop first (unless the Activity already did), and released once whether MapViewBase or the local effect gets there first. --- .../com/mapconductor/tomtom/TomTomMapView.kt | 22 ++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt index 29f4a23..1c12098 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt @@ -7,6 +7,7 @@ import androidx.compose.runtime.remember import androidx.compose.ui.Modifier import androidx.compose.ui.platform.LocalContext import androidx.lifecycle.DefaultLifecycleObserver +import androidx.lifecycle.Lifecycle import androidx.lifecycle.LifecycleOwner import androidx.lifecycle.compose.LocalLifecycleOwner import com.mapconductor.compose.map.MapViewBase @@ -38,6 +39,7 @@ import com.mapconductor.tomtom.polyline.TomTomPolylineController import com.mapconductor.tomtom.polyline.TomTomPolylineOverlayRenderer import com.tomtom.sdk.map.display.MapOptions import com.tomtom.sdk.map.display.ui.MapView +import java.util.concurrent.atomic.AtomicBoolean import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.suspendCancellableCoroutine @@ -87,6 +89,21 @@ fun TomTomMapView( MapView(context, options).apply { onCreate(null) } } + // 破棄は 1 回だけ。observer が進めた分(onResume / onStart)を巻き戻してから onDestroy。 + // 設定変更では Activity 側で onPause / onStop が済んでいるので onDestroy だけになる。 + val releaseMapView = + remember(mapView) { + val released = AtomicBoolean(false) + + fun() { + if (!released.compareAndSet(false, true)) return + val current = lifecycle.currentState + if (current.isAtLeast(Lifecycle.State.RESUMED)) mapView.onPause() + if (current.isAtLeast(Lifecycle.State.STARTED)) mapView.onStop() + mapView.onDestroy() + } + } + // MapView のライフサイクルをホスト Activity のライフサイクルに同期させる。 // observer 追加時に現在の状態(STARTED/RESUMED)まで catch-up されるため、 // この時点で MapView に onStart/onResume が届く(これがタイル描画に必須)。 @@ -112,7 +129,9 @@ fun TomTomMapView( lifecycle.addObserver(observer) onDispose { lifecycle.removeObserver(observer) - mapView.onDestroy() + // MapViewBase normally released it already (after the controller); + // this covers a map that left before MapViewBase took the view. + releaseMapView() } } @@ -185,6 +204,7 @@ fun TomTomMapView( scope = scope, registry = registry, onMapLoaded = onMapLoaded, + onDestroyMapView = { releaseMapView() }, customDisposableEffect = { _, _ -> // MapView のライフサイクルは上の本体 DisposableEffect で駆動済み。 // ここではコンポジション破棄時にコントローラを破棄してリークを防ぐ。 From ca6beddd178b44a33c06d0518601a35cee93056f Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 16:20:26 -0800 Subject: [PATCH 12/25] 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. --- .../java/com/mapconductor/tomtom/TomTomMapViewStateImpl.kt | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewStateImpl.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewStateImpl.kt index 6609e88..81b6101 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewStateImpl.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewStateImpl.kt @@ -38,10 +38,13 @@ class TomTomMapViewState( this.controller?.setMapDesignType(value) } get() = _mapDesignType - private var controller: TomTomMapViewControllerInterface? = 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: TomTomMapViewControllerInterface? + get() = attachedMapController as? TomTomMapViewControllerInterface internal fun setController(controller: TomTomMapViewControllerInterface) { - this.controller = controller attachController(controller) } From f0cf8dd030fc00dd0a507e58b963e9e5189624dd Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 21:23:01 -0800 Subject: [PATCH 13/25] Interpolate the closing edge of geodesic polygons The geodesic ring was densified with createInterpolatePoints, which only interpolates between neighbouring points, so the closing edge (last vertex -> first) of a geodesic polygon was a straight chord in both fill and outline. Use android-sdk-core's densifyGeodesicRing. geodesic=false is unchanged. Requires the android-sdk-core release that adds densifyGeodesicRing. --- .../tomtom/polygon/TomTomPolygonOverlayRenderer.kt | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/mapconductor/tomtom/polygon/TomTomPolygonOverlayRenderer.kt b/src/main/java/com/mapconductor/tomtom/polygon/TomTomPolygonOverlayRenderer.kt index 80de850..86f7d4b 100644 --- a/src/main/java/com/mapconductor/tomtom/polygon/TomTomPolygonOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/tomtom/polygon/TomTomPolygonOverlayRenderer.kt @@ -3,13 +3,13 @@ package com.mapconductor.tomtom.polygon import androidx.compose.ui.graphics.toArgb import com.mapconductor.core.features.GeoPoint import com.mapconductor.core.features.GeoPointInterface +import com.mapconductor.core.geometry.densifyGeodesicRing import com.mapconductor.core.polygon.AbstractPolygonOverlayRenderer import com.mapconductor.core.polygon.PolygonEntityInterface import com.mapconductor.core.polygon.PolygonState import com.mapconductor.core.polygon.bridgeHolesIntoSingleRing import com.mapconductor.core.polygon.unionHoles import com.mapconductor.core.projection.Earth -import com.mapconductor.core.spherical.WGS84Geodesic import com.mapconductor.tomtom.TomTomActualPolygon import com.mapconductor.tomtom.TomTomMapViewHolder import com.mapconductor.tomtom.toTomTomGeoPoint @@ -43,9 +43,10 @@ class TomTomPolygonOverlayRenderer( geodesic: Boolean, ): List { // 非 geodesic は補間せず生の頂点を使う(HERE と同じ)。geodesic のみ補間する。 + // geodesic は閉じる辺(末尾 → 先頭)も大圏で補間する(塗りと輪郭が同じネイティブポリゴン)。 val geoPoints = if (geodesic) { - WGS84Geodesic.createInterpolatePoints(points, maxSegmentLength = maxSegmentLengthMeters()) + densifyGeodesicRing(points, maxSegmentLength = maxSegmentLengthMeters()) } else { points } @@ -80,7 +81,7 @@ class TomTomPolygonOverlayRenderer( ): List { val geoPoints = if (geodesic) { - WGS84Geodesic.createInterpolatePoints(points, maxSegmentLength = maxSegmentLengthMeters()) + densifyGeodesicRing(points, maxSegmentLength = maxSegmentLengthMeters()) } else { points } From 039f4eb46f037f89c05c1e5235f451f839ae5e12 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 22:35:34 -0800 Subject: [PATCH 14/25] Clear ground images and raster layers in clearOverlays() too clearOverlays() cleared markers, polylines, polygons and circles but not the ground image controller, and nothing removed the raster layers, so both stayed on the map (seen on the tablet: the relief raster still covered the map after clearOverlays()). It is the same kind of gap as the Mapbox circles fixed in "Clear circles in clearOverlays() too". TomTom has no RasterLayerController (rasters are folded into the composed style), so the equivalent of rasterLayerController.clear() is done here: the layers added through the public RasterLayer overlay (publicRasterLayerIds) are removed. Rasters mounted from outside the content, such as marker tiles, are left to their owners. --- .../com/mapconductor/tomtom/TomTomMapViewController.kt | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt index e8dd877..00232d1 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt @@ -211,6 +211,13 @@ class TomTomMapViewController internal constructor( polylineController.clear() polygonController.clear() circleController.clear() + groundImageController.clear() + // TomTom には RasterLayerController が無い(ラスタは合成スタイルへ畳み込む)ので、 + // 他プロバイダの rasterLayerController.clear() に当たるものをここで行う。消すのは + // 公開 RasterLayer 経由のものだけ。マーカータイル等の mount 分は持ち主が外す。 + val rasterIds = publicRasterLayerIds.toList() + publicRasterLayerIds.clear() + rasterIds.forEach { removeRasterLayer(it) } } override fun setMarkerAnimationOverlayHost(host: MarkerAnimationOverlayHost?) { From aa471a30c078c8db9dc1cc922b715936dcab2b65 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 23:25:58 -0800 Subject: [PATCH 15/25] Densify non-geodesic polygon rings, closing edge included A geodesic=false polygon passed its raw vertices to TomTom, so every edge was a straight Web Mercator segment, unlike polylines with geodesic=false (linear lat/lng interpolation) and the other providers. Use android-sdk-core's densifyPolygonRing for both modes; it closes the ring before densifying, so the closing edge (last vertex -> first) matches the others (it replaces the unreleased densifyGeodesicRing). The linear case uses 200 km segments rather than the core's 10 km: raw vertices were used because a world-mask ring densified every 10 km made TomTom fail to draw it. A lat/lng line still bends smoothly at 200 km. Requires the android-sdk-core release that adds densifyPolygonRing. --- .../polygon/TomTomPolygonOverlayRenderer.kt | 37 +++++++++++-------- 1 file changed, 21 insertions(+), 16 deletions(-) diff --git a/src/main/java/com/mapconductor/tomtom/polygon/TomTomPolygonOverlayRenderer.kt b/src/main/java/com/mapconductor/tomtom/polygon/TomTomPolygonOverlayRenderer.kt index 86f7d4b..c0c3152 100644 --- a/src/main/java/com/mapconductor/tomtom/polygon/TomTomPolygonOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/tomtom/polygon/TomTomPolygonOverlayRenderer.kt @@ -3,7 +3,7 @@ package com.mapconductor.tomtom.polygon import androidx.compose.ui.graphics.toArgb import com.mapconductor.core.features.GeoPoint import com.mapconductor.core.features.GeoPointInterface -import com.mapconductor.core.geometry.densifyGeodesicRing +import com.mapconductor.core.geometry.densifyPolygonRing import com.mapconductor.core.polygon.AbstractPolygonOverlayRenderer import com.mapconductor.core.polygon.PolygonEntityInterface import com.mapconductor.core.polygon.PolygonState @@ -42,14 +42,7 @@ class TomTomPolygonOverlayRenderer( points: List, geodesic: Boolean, ): List { - // 非 geodesic は補間せず生の頂点を使う(HERE と同じ)。geodesic のみ補間する。 - // geodesic は閉じる辺(末尾 → 先頭)も大圏で補間する(塗りと輪郭が同じネイティブポリゴン)。 - val geoPoints = - if (geodesic) { - densifyGeodesicRing(points, maxSegmentLength = maxSegmentLengthMeters()) - } else { - points - } + val geoPoints = densify(points, geodesic) var ring = geoPoints.map { GeoPoint.from(it).toTomTomGeoPoint() } // 末尾の重複始点を除く(開いたリング)。 if (ring.size >= 2 && ring.first() == ring.last()) { @@ -79,16 +72,28 @@ class TomTomPolygonOverlayRenderer( points: List, geodesic: Boolean, ): List { - val geoPoints = - if (geodesic) { - densifyGeodesicRing(points, maxSegmentLength = maxSegmentLengthMeters()) - } else { - points - } - val ring = geoPoints.map { GeoPoint.from(it) } + val ring = densify(points, geodesic).map { GeoPoint.from(it) } return if (ring.size >= 2 && ring.first() == ring.last()) ring.dropLast(1) else ring } + /** + * 閉じる辺(末尾 → 先頭)も含めてリングを密度化する(塗りと輪郭が同じネイティブポリゴン)。 + * geodesic は大圏、geodesic=false は緯度経度の線形補間(ポリラインの false と同じ線)。 + * + * 線形補間は [MAX_GEODESIC_SEGMENT_METERS] 刻みと粗くする。世界マスク級のリングを 10 km 刻みで + * 補間すると過密になり TomTom の描画が失敗する(以前はこのため false を補間していなかった)。 + * 緯度経度の直線は 200 km 刻みでもメルカトル上の曲がりを十分に表せる。 + */ + private fun densify( + points: List, + geodesic: Boolean, + ): List = + densifyPolygonRing( + points, + geodesic, + maxSegmentLength = if (geodesic) maxSegmentLengthMeters() else MAX_GEODESIC_SEGMENT_METERS, + ) + private fun maxSegmentLengthMeters(): Double { val zoom = holder.map.cameraPosition.zoom val metersPerPixel = Earth.CIRCUMFERENCE_METERS / (256.0 * 2.0.pow(zoom)) From 48b60465400c10266ab67cf3d161811557a3a456 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 23:10:01 -0800 Subject: [PATCH 16/25] 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). --- .../java/com/mapconductor/tomtom/TomTomMapViewController.kt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt index 00232d1..1d06034 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt @@ -218,6 +218,8 @@ class TomTomMapViewController internal constructor( val rasterIds = publicRasterLayerIds.toList() publicRasterLayerIds.clear() rasterIds.forEach { removeRasterLayer(it) } + // 拡張モジュール(クラスタリングなど)が登録した Strategy のマーカーも消す。 + clearStrategyMarkerControllers() } override fun setMarkerAnimationOverlayHost(host: MarkerAnimationOverlayHost?) { From 12dbebae8257c6fe975cb4b3399f738617e879eb Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Sat, 7 Nov 2026 23:55:27 -0800 Subject: [PATCH 17/25] Put app rasters under the SDK overlays; restack native shapes by band Composed rasters were appended at the end of the style, above the SDK's polygon/polyline/marker layers, so a RasterLayerState covered polygons, polylines and ground images. App rasters are now inserted before the first label or SDK overlay layer of the composed style, in zIndex order; marker tiles stay on top. TomTom's native Polygon/Polyline have no draw order and stack in add order; ground images, polygons and circle fills are all native Polygons and circle outlines are Polylines. When something is added to a lower band, the bands above it are cleared and added again so the order follows the bands. 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-tomtom.api | 4 ++ .../tomtom/TomTomMapViewController.kt | 68 +++++++++++++++++++ .../tomtom/TomTomMapViewControllerRaster.kt | 10 ++- .../tomtom/raster/TomTomStyleComposer.kt | 61 ++++++++++++++++- 4 files changed, 138 insertions(+), 5 deletions(-) diff --git a/api/android-for-tomtom.api b/api/android-for-tomtom.api index 940e2ea..eaa0c3a 100644 --- a/api/android-for-tomtom.api +++ b/api/android-for-tomtom.api @@ -69,6 +69,10 @@ public final class com.mapconductor.tomtom.TomTomMapViewController extends com.m public void destroy(); public java.lang.Object clearOverlays(kotlin.coroutines.Continuation); public void setMarkerAnimationOverlayHost(com.mapconductor.core.marker.MarkerAnimationOverlayHost); + public java.lang.Object compositionGroundImages(java.util.List, kotlin.coroutines.Continuation); + public java.lang.Object compositionPolygons(java.util.List, kotlin.coroutines.Continuation); + public java.lang.Object compositionCircles(java.util.List, kotlin.coroutines.Continuation); + public java.lang.Object compositionPolylines(java.util.List, kotlin.coroutines.Continuation); public boolean hasPolyline(com.mapconductor.core.polyline.PolylineState); public void setOnPolylineClickListener(kotlin.jvm.functions.Function1); public boolean hasPolygon(com.mapconductor.core.polygon.PolygonState); diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt index 00232d1..a60e25b 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt @@ -224,6 +224,70 @@ class TomTomMapViewController internal constructor( (markerController.renderer as TomTomMarkerRenderer).animationOverlayHost = host } + // ---- 重なり順 ---------------------------------------------------------- + // + // TomTom のネイティブの Polygon / Polyline には重なり順の指定が無く、後から足したものが + // 上に積まれる。GroundImage・ポリゴン・サークルの塗りはどれもネイティブの Polygon、 + // サークルの輪郭とポリラインはネイティブの Polyline なので、そのままだと + // 「追加した順」で重なる(clearOverlays の後に送り直すと順が変わる)。 + // 帯の順(GroundImage < ポリゴン < サークル < ポリライン)を守るため、下の帯へ + // 新しく足されたら、それより上の帯を足し直す。帯の中は zIndex の順(同じなら渡された順)。 + + override suspend fun compositionGroundImages(data: List) { + val added = data.any { !groundImageController.groundImageManager.hasEntity(it.id) } + groundImageController.add(data) + if (added) { + restackPolygons() + restackCircles() + } + } + + override suspend fun compositionPolygons(data: List) { + val added = data.any { !polygonController.polygonManager.hasEntity(it.id) } + polygonController.add(data.sortedBy { it.zIndex }) + if (added) { + restackPolygons() + restackCircles() + } + } + + override suspend fun compositionCircles(data: List) { + val added = data.any { !circleController.circleManager.hasEntity(it.id) } + circleController.add(data.sortedBy { it.zIndex ?: 0 }) + if (added) { + restackCircles() + restackPolylines() + } + } + + override suspend fun compositionPolylines(data: List) { + val added = data.any { !polylineController.polylineManager.hasEntity(it.id) } + polylineController.add(data.sortedBy { it.zIndex }) + if (added) restackPolylines() + } + + /** いったん消して zIndex の順に足し直す(ネイティブの積み順を作り直す)。 */ + private suspend fun restackPolygons() { + val states = polygonController.polygonManager.allEntities().map { it.state } + if (states.isEmpty()) return + polygonController.clear() + polygonController.add(states.sortedBy { it.zIndex }) + } + + private suspend fun restackCircles() { + val states = circleController.circleManager.allEntities().map { it.state } + if (states.isEmpty()) return + circleController.clear() + circleController.add(states.sortedBy { it.zIndex ?: 0 }) + } + + private suspend fun restackPolylines() { + val states = polylineController.polylineManager.allEntities().map { it.state } + if (states.isEmpty()) return + polylineController.clear() + polylineController.add(states.sortedBy { it.zIndex }) + } + // ---- Polyline / Polygon / Circle capable ------------------------------ override fun hasPolyline(state: PolylineState): Boolean = polylineController.polylineManager.hasEntity(state.id) @@ -345,6 +409,9 @@ class TomTomMapViewController internal constructor( // 注意: 合成は現状 browsing/light ベース固定。Standard 以外のデザインでラスタを載せた場合は // ベースが browsing になる(対象ページは Standard のため実用上問題なし)。 internal val composedRasterLayers = LinkedHashMap() + + /** アプリのラスターの zIndex(帯の中の順)。[composedRasterLayers] と同じキー。 */ + internal val composedRasterZIndex = java.util.concurrent.ConcurrentHashMap() internal val composedStyleMutex = Mutex() internal var rasterApiKey: String? = null internal var rasterCacheDir: File? = null @@ -406,6 +473,7 @@ class TomTomMapViewController internal constructor( } override suspend fun removeRasterLayer(id: String) { + composedRasterZIndex.remove(id) val removed = composedStyleMutex.withLock { composedRasterLayers.remove(id) != null } if (!removed) return scheduleComposedStyleReload() diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt index 46b9773..d077dc2 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt @@ -54,6 +54,8 @@ internal suspend fun TomTomMapViewController.applyPublicRasterLayer(state: Raste removeRasterLayer(state.id) return } + // 帯の中の順(zIndex、同じなら渡された順)。合成のときに並べる。 + composedRasterZIndex[state.id] = state.zIndex // ソースの tileSize / minZoom / maxZoom を合成スタイルへ伝える。maxZoom を渡すと // 高ズームでオーバーズーム表示され、実タイルの無い領域での歯抜けを防げる。 upsertRasterLayer( @@ -94,11 +96,15 @@ internal suspend fun TomTomMapViewController.applyComposedStyle() { } composedStyleToggle = composedStyleToggle xor 1 val outFile = File(cacheDir, "tomtom_composed_style_$composedStyleToggle.json") + // アプリのラスターはラスターの帯(SDK のオーバーレイの下)、マーカーのタイルはマーカーの帯(最前面)。 + val (markerTiles, appRasters) = + composedRasterLayers.values.partition { it.id == TomTomMapViewController.MARKER_RASTER_ID } val uri = - TomTomStyleComposer.composeRasterStyle( + TomTomStyleComposer.composeStackedRasterStyle( apiKey = apiKey, cacheDir = cacheDir, - layers = composedRasterLayers.values.toList(), + belowOverlays = appRasters.sortedBy { composedRasterZIndex[it.id] ?: 0 }, + aboveOverlays = markerTiles, outFile = outFile, withoutBasemap = withoutBasemap, ) ?: return diff --git a/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt b/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt index ae86578..a4fd5e4 100644 --- a/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt +++ b/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt @@ -84,6 +84,35 @@ object TomTomStyleComposer { outFile: File = File(cacheDir, "tomtom_composed_style.json"), // [TomTomMapDesign.None]: ベースマップを描かない(本文のコメント参照)。 withoutBasemap: Boolean = false, + ): Uri? = + composeStackedRasterStyle( + apiKey = apiKey, + cacheDir = cacheDir, + belowOverlays = emptyList(), + aboveOverlays = layers, + outFile = outFile, + withoutBasemap = withoutBasemap, + ) + + /** + * [composeRasterStyle] の、重なり順を指定できる版。 + * + * - [belowOverlays]: アプリのラスター(RasterLayerState)。重なり順の決まり + * (ラスター < GroundImage < ポリゴン < サークル < ポリライン < マーカー)でいちばん下の帯なので、 + * SDK のオーバーレイ用レイヤー(polygon-shape など)とベースマップのラベルより**下**へ、 + * 渡された順(下→上)に入れる。 + * - [aboveOverlays]: マーカーのタイル。マーカーの帯なのでスタイルの末尾(最前面)へ。 + * + * 以前はどちらも末尾に積んでいたため、アプリのラスターがポリゴン・ポリライン・ + * GroundImage(いずれも SDK のオーバーレイ)を覆っていた。 + */ + internal suspend fun composeStackedRasterStyle( + apiKey: String, + cacheDir: File, + belowOverlays: List, + aboveOverlays: List, + outFile: File, + withoutBasemap: Boolean, ): Uri? = withContext(Dispatchers.IO) { // The SDK will not take a style that has none of its own layers @@ -164,8 +193,17 @@ object TomTomStyleComposer { insertLayerAt(styleLayers, insertAt, baseLayer) } - // 自前ラスタレイヤー(マーカータイル / GroundImage など)を最前面(末尾)へ順に重ねる。 - layers.forEachIndexed { index, spec -> + // アプリのラスター: SDK のオーバーレイ用レイヤーとラベルの下へ、渡された順に。 + var insertBelow = overlayOrLabelIndex(styleLayers) + belowOverlays.forEachIndexed { index, spec -> + val sourceId = "mc-raster-src-$index" + sources.put(sourceId, rasterSource(spec.tilesUrl, spec.tileSize, spec.minZoom, spec.maxZoom)) + insertLayerAt(styleLayers, insertBelow, rasterLayer("mc-raster-layer-$index", sourceId, spec.opacity)) + insertBelow++ + } + // マーカーのタイル: 最前面(末尾)へ順に重ねる。 + aboveOverlays.forEachIndexed { i, spec -> + val index = belowOverlays.size + i val sourceId = "mc-raster-src-$index" sources.put(sourceId, rasterSource(spec.tilesUrl, spec.tileSize, spec.minZoom, spec.maxZoom)) styleLayers.put(rasterLayer("mc-raster-layer-$index", sourceId, spec.opacity)) @@ -179,7 +217,8 @@ object TomTomStyleComposer { } Log.i( TAG, - "Composed style written (${outFile.length()} bytes, ${styleLayers.length()} layers, ${layers.size} raster)", + "Composed style written (${outFile.length()} bytes, ${styleLayers.length()} layers, " + + "${belowOverlays.size + aboveOverlays.size} raster)", ) Uri.fromFile(outFile) } @@ -230,6 +269,22 @@ object TomTomStyleComposer { put("paint", JSONObject().put("raster-opacity", opacity)) } + /** + * アプリのラスターを入れる位置: ベースマップのラベル(symbol)か SDK のオーバーレイ用レイヤー + * (polygon-shape / polyline-shape / circle-shape / marker / route など)のうち最初のもの。 + * どちらも無ければ末尾。 + */ + private fun overlayOrLabelIndex(layers: JSONArray): Int { + for (i in 0 until layers.length()) { + val layer = layers.optJSONObject(i) ?: continue + val id = layer.optString("id") + if (layer.optString("type") == "symbol" || SDK_OVERLAY_LAYER_HINTS.any { id.contains(it) }) return i + } + return layers.length() + } + + private val SDK_OVERLAY_LAYER_HINTS = listOf("shape", "marker", "route") + /** JSONArray への位置指定挿入(org.json は insert が無いため末尾に足してからシフト)。 */ private fun insertLayerAt( layers: JSONArray, From 9910ef4330b36f0c0506130ce68dc5c81e72a87d Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Mon, 9 Nov 2026 09:38:06 -0800 Subject: [PATCH 18/25] 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. Composed into the style above the polygon tiles; restacking native polylines is skipped while tiles are in use (it would tile them all again). Whatever redraws from the polyline manager skips tiled entities (no native line). --- .../tomtom/TomTomMapViewController.kt | 2 ++ .../tomtom/TomTomMapViewControllerRaster.kt | 21 +++++++++++++++++-- 2 files changed, 21 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt index 50be728..2158ce9 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt @@ -284,6 +284,8 @@ class TomTomMapViewController internal constructor( } private suspend fun restackPolylines() { + // Drawn as tiles: the tile layer has its own order, and clearing would tile them all again. + if (polylineController.tiler?.tiledStates()?.isNotEmpty() == true) return val states = polylineController.polylineManager.allEntities().map { it.state } if (states.isEmpty()) return polylineController.clear() diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt index 027e3ef..77fca4c 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt @@ -2,6 +2,8 @@ package com.mapconductor.tomtom import com.mapconductor.core.polygon.POLYGON_TILE_LAYER_ID import com.mapconductor.core.polygon.PolygonTiler +import com.mapconductor.core.polyline.POLYLINE_TILE_LAYER_ID +import com.mapconductor.core.polyline.PolylineTiler import com.mapconductor.core.raster.RasterLayerSource import com.mapconductor.core.raster.RasterLayerState import com.mapconductor.tomtom.marker.MarkerTileRasterLayerCallback @@ -60,6 +62,17 @@ fun TomTomMapViewController.setupMarkerTileRaster( } } } + // Many polylines too, the same way (over the polygon tiles, under the SDK's overlays). + polylineController.tiler = + PolylineTiler().apply { + onTemplate = { template, tileSize -> + if (template != null) { + upsertRasterLayer(POLYLINE_TILE_LAYER_ID, template, 1.0, tileSize, null, null) + } else { + removeRasterLayer(POLYLINE_TILE_LAYER_ID) + } + } + } } internal suspend fun TomTomMapViewController.applyPublicRasterLayer(state: RasterLayerState) { @@ -114,14 +127,18 @@ internal suspend fun TomTomMapViewController.applyComposedStyle() { // ポリゴンのタイルはアプリのラスターのすぐ上(SDK のオーバーレイの下)。ポリゴンの帯は // GroundImage の上だが、TomTom の GroundImage はネイティブの Polygon(SDK のオーバーレイ)で、 // スタイルの層をその間へは入れられない。サークル・ポリライン・マーカーの下は守れる。 + // ポリラインのタイルはポリゴンのタイルの上(同じ理由で SDK のオーバーレイの下: ネイティブの + // ポリゴン・サークルもこのタイルの上に来る)。マーカーのタイルとマーカーの下は守れる。 val (markerTiles, others) = composedRasterLayers.values.partition { it.id == TomTomMapViewController.MARKER_RASTER_ID } - val (polygonTiles, appRasters) = others.partition { it.id == POLYGON_TILE_LAYER_ID } + val (shapeTiles, appRasters) = others.partition { it.id == POLYGON_TILE_LAYER_ID || it.id == POLYLINE_TILE_LAYER_ID } + // Polygon tiles first (lower), then polyline tiles. + val shapeTilesBottomUp = shapeTiles.sortedBy { if (it.id == POLYGON_TILE_LAYER_ID) 0 else 1 } val uri = TomTomStyleComposer.composeStackedRasterStyle( apiKey = apiKey, cacheDir = cacheDir, - belowOverlays = appRasters.sortedBy { composedRasterZIndex[it.id] ?: 0 } + polygonTiles, + belowOverlays = appRasters.sortedBy { composedRasterZIndex[it.id] ?: 0 } + shapeTilesBottomUp, aboveOverlays = markerTiles, outFile = outFile, withoutBasemap = withoutBasemap, From 69318061413eaa6d30e6b6a67dfd9b421976185c Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Mon, 9 Nov 2026 13:57:04 -0800 Subject: [PATCH 19/25] Put the polyline tiles above the TomTom basemap's roads The polyline tiles went in front of the style's first label, like the app's rasters. TomTom's style keeps drawing road lines after its first symbol layer (67 line layers on the browsing style), so the basemap's roads covered the tile roads: on the Boston roads page only paths and the edges of the other classes showed. They are now appended after every style layer (under the marker tiles), as ios-for-tomtom does. The polygon tiles stay where they were: lifting them too put them over the native circle. Checked on the tablet (overlap check, z16, colour test): polygon tiles < circle < road tiles < marker; road taps still resolve. --- .../tomtom/TomTomMapViewControllerRaster.kt | 20 +++++++++---------- .../tomtom/raster/TomTomStyleComposer.kt | 15 ++++++++++++-- 2 files changed, 23 insertions(+), 12 deletions(-) diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt index 77fca4c..e586846 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt @@ -123,25 +123,25 @@ internal suspend fun TomTomMapViewController.applyComposedStyle() { } composedStyleToggle = composedStyleToggle xor 1 val outFile = File(cacheDir, "tomtom_composed_style_$composedStyleToggle.json") - // アプリのラスターはラスターの帯(SDK のオーバーレイの下)、マーカーのタイルはマーカーの帯(最前面)。 - // ポリゴンのタイルはアプリのラスターのすぐ上(SDK のオーバーレイの下)。ポリゴンの帯は - // GroundImage の上だが、TomTom の GroundImage はネイティブの Polygon(SDK のオーバーレイ)で、 - // スタイルの層をその間へは入れられない。サークル・ポリライン・マーカーの下は守れる。 - // ポリラインのタイルはポリゴンのタイルの上(同じ理由で SDK のオーバーレイの下: ネイティブの - // ポリゴン・サークルもこのタイルの上に来る)。マーカーのタイルとマーカーの下は守れる。 + // アプリのラスターはラスターの帯(ベースマップのラベルの下)、マーカーのタイルはマーカーの帯(最前面)。 + // ポリゴンのタイルはアプリのラスターのすぐ上(ラベルの下)。ネイティブのサークル・ポリゴン + // (SDK のオーバーレイ)はその上に来る。ポリラインのタイルはベースマップの全レイヤー(道路・ラベル)の + // 上: TomTom のスタイルは最初のラベルの後ろにも道路の line が続くので、ラベルの前では道路のタイルが + // 地図の道路に覆われて見えなかった。ネイティブのサークルより上・マーカー(とそのタイル)より下になる + // (実機で確認。ポリゴンのタイルまで上へ上げるとサークルを覆ってしまう)。 val (markerTiles, others) = composedRasterLayers.values.partition { it.id == TomTomMapViewController.MARKER_RASTER_ID } - val (shapeTiles, appRasters) = others.partition { it.id == POLYGON_TILE_LAYER_ID || it.id == POLYLINE_TILE_LAYER_ID } - // Polygon tiles first (lower), then polyline tiles. - val shapeTilesBottomUp = shapeTiles.sortedBy { if (it.id == POLYGON_TILE_LAYER_ID) 0 else 1 } + val (polylineTiles, rest) = others.partition { it.id == POLYLINE_TILE_LAYER_ID } + val (polygonTiles, appRasters) = rest.partition { it.id == POLYGON_TILE_LAYER_ID } val uri = TomTomStyleComposer.composeStackedRasterStyle( apiKey = apiKey, cacheDir = cacheDir, - belowOverlays = appRasters.sortedBy { composedRasterZIndex[it.id] ?: 0 } + shapeTilesBottomUp, + belowOverlays = appRasters.sortedBy { composedRasterZIndex[it.id] ?: 0 } + polygonTiles, aboveOverlays = markerTiles, outFile = outFile, withoutBasemap = withoutBasemap, + polylineTiles = polylineTiles, ) ?: return if (destroyed) return withContext(Dispatchers.Main) { diff --git a/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt b/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt index a4fd5e4..b5b265f 100644 --- a/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt +++ b/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt @@ -101,6 +101,9 @@ object TomTomStyleComposer { * (ラスター < GroundImage < ポリゴン < サークル < ポリライン < マーカー)でいちばん下の帯なので、 * SDK のオーバーレイ用レイヤー(polygon-shape など)とベースマップのラベルより**下**へ、 * 渡された順(下→上)に入れる。 + * - [polylineTiles]: SDK 自身のポリラインのタイル(下→上)。スタイルの全レイヤー(ベースマップの + * 道路・ラベルも含む)の上、マーカーのタイルの下へ。TomTom のスタイルは最初の symbol の後ろにも + * 道路の line レイヤーが続くので、ラベルの前に入れると道路のタイルが地図の道路に覆われて見えなかった。 * - [aboveOverlays]: マーカーのタイル。マーカーの帯なのでスタイルの末尾(最前面)へ。 * * 以前はどちらも末尾に積んでいたため、アプリのラスターがポリゴン・ポリライン・ @@ -113,6 +116,7 @@ object TomTomStyleComposer { aboveOverlays: List, outFile: File, withoutBasemap: Boolean, + polylineTiles: List = emptyList(), ): Uri? = withContext(Dispatchers.IO) { // The SDK will not take a style that has none of its own layers @@ -201,9 +205,16 @@ object TomTomStyleComposer { insertLayerAt(styleLayers, insertBelow, rasterLayer("mc-raster-layer-$index", sourceId, spec.opacity)) insertBelow++ } + // ポリラインのタイル: ベースマップの全レイヤーの上へ順に。 + polylineTiles.forEachIndexed { i, spec -> + val index = belowOverlays.size + i + val sourceId = "mc-raster-src-$index" + sources.put(sourceId, rasterSource(spec.tilesUrl, spec.tileSize, spec.minZoom, spec.maxZoom)) + styleLayers.put(rasterLayer("mc-raster-layer-$index", sourceId, spec.opacity)) + } // マーカーのタイル: 最前面(末尾)へ順に重ねる。 aboveOverlays.forEachIndexed { i, spec -> - val index = belowOverlays.size + i + val index = belowOverlays.size + polylineTiles.size + i val sourceId = "mc-raster-src-$index" sources.put(sourceId, rasterSource(spec.tilesUrl, spec.tileSize, spec.minZoom, spec.maxZoom)) styleLayers.put(rasterLayer("mc-raster-layer-$index", sourceId, spec.opacity)) @@ -218,7 +229,7 @@ object TomTomStyleComposer { Log.i( TAG, "Composed style written (${outFile.length()} bytes, ${styleLayers.length()} layers, " + - "${belowOverlays.size + aboveOverlays.size} raster)", + "${belowOverlays.size + polylineTiles.size + aboveOverlays.size} raster)", ) Uri.fromFile(outFile) } From 6d84235ceb4cc89bf7b047cf1772d7c9c8e7ffb0 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Tue, 10 Nov 2026 16:16:50 -0800 Subject: [PATCH 20/25] Support bulk Circles with raster tiles --- .../tomtom/TomTomMapViewControllerRaster.kt | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt index e586846..9a095a0 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt @@ -1,5 +1,7 @@ package com.mapconductor.tomtom +import com.mapconductor.core.circle.CIRCLE_TILE_LAYER_ID +import com.mapconductor.core.circle.CircleTiler import com.mapconductor.core.polygon.POLYGON_TILE_LAYER_ID import com.mapconductor.core.polygon.PolygonTiler import com.mapconductor.core.polyline.POLYLINE_TILE_LAYER_ID @@ -73,6 +75,16 @@ fun TomTomMapViewController.setupMarkerTileRaster( } } } + circleController.tiler = + CircleTiler().apply { + onTemplate = { template, tileSize -> + if (template != null) { + upsertRasterLayer(CIRCLE_TILE_LAYER_ID, template, 1.0, tileSize, null, null) + } else { + removeRasterLayer(CIRCLE_TILE_LAYER_ID) + } + } + } } internal suspend fun TomTomMapViewController.applyPublicRasterLayer(state: RasterLayerState) { @@ -132,12 +144,13 @@ internal suspend fun TomTomMapViewController.applyComposedStyle() { val (markerTiles, others) = composedRasterLayers.values.partition { it.id == TomTomMapViewController.MARKER_RASTER_ID } val (polylineTiles, rest) = others.partition { it.id == POLYLINE_TILE_LAYER_ID } - val (polygonTiles, appRasters) = rest.partition { it.id == POLYGON_TILE_LAYER_ID } + val (circleTiles, remaining) = rest.partition { it.id == CIRCLE_TILE_LAYER_ID } + val (polygonTiles, appRasters) = remaining.partition { it.id == POLYGON_TILE_LAYER_ID } val uri = TomTomStyleComposer.composeStackedRasterStyle( apiKey = apiKey, cacheDir = cacheDir, - belowOverlays = appRasters.sortedBy { composedRasterZIndex[it.id] ?: 0 } + polygonTiles, + belowOverlays = appRasters.sortedBy { composedRasterZIndex[it.id] ?: 0 } + polygonTiles + circleTiles, aboveOverlays = markerTiles, outFile = outFile, withoutBasemap = withoutBasemap, From a058fdcac7f5e596868e1b6a21f5cb5ad86537d1 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Tue, 10 Nov 2026 23:15:01 -0800 Subject: [PATCH 21/25] Do not restack tiled circles restackCircles() clears every circle and adds them again, on every new ground image, polygon or circle. With the circles in tiles that tiled all of them again: at the nationwide example's 723,800 circles on a tablet, the first tiles came 24 s after the data instead of 17 s, and restoring a carrier took 13 s instead of 6 s, the tile layer gone meanwhile. The tile layer has its own order; skip the restack while circles are tiled, as restackPolylines() already does. --- .../java/com/mapconductor/tomtom/TomTomMapViewController.kt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt index 2158ce9..bd8bb17 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt @@ -277,6 +277,9 @@ class TomTomMapViewController internal constructor( } private suspend fun restackCircles() { + // Drawn as tiles: the tile layer has its own order, and clearing would tile them all again + // (6 s for 700k circles on a tablet, with the tiles gone meanwhile), as for polylines. + if (circleController.tiler?.tiledStates()?.isNotEmpty() == true) return val states = circleController.circleManager.allEntities().map { it.state } if (states.isEmpty()) return circleController.clear() From 87db2b6c3aa92ba6650be5a99f82740e80c014e9 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Wed, 11 Nov 2026 22:29:04 -0800 Subject: [PATCH 22/25] Apply camera paddings and report fov on TomTom setPadding is not used because it jumps when set. Paddings are emulated by moving the camera center and undone on read. TomTom limits the tilt by zoom (about 42 at zoom 15), so when the camera settles at a lower tilt than requested the padded center is solved again for the actual tilt. fov is 45 (no API; measured 45 on TB520FU in both orientations). --- api/android-for-tomtom.api | 3 ++ .../mapconductor/tomtom/MapCameraPosition.kt | 7 +++ .../tomtom/TomTomMapViewController.kt | 12 +++++ .../tomtom/TomTomMapViewControllerCamera.kt | 51 +++++++++++++++++-- 4 files changed, 69 insertions(+), 4 deletions(-) diff --git a/api/android-for-tomtom.api b/api/android-for-tomtom.api index eaa0c3a..2513d62 100644 --- a/api/android-for-tomtom.api +++ b/api/android-for-tomtom.api @@ -8,6 +8,7 @@ public final class com.mapconductor.tomtom.GeoRectBoundsKt { public static final com.mapconductor.core.features.GeoRectBounds toGeoRectBounds(com.tomtom.sdk.location.GeoBoundingBox); } public final class com.mapconductor.tomtom.MapCameraPositionKt { + public static final double TOMTOM_VERTICAL_FOV; public static final com.tomtom.sdk.map.display.camera.CameraOptions toCameraOptions(com.mapconductor.core.map.MapCameraPosition); 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.tomtom.sdk.map.display.camera.CameraPosition, com.mapconductor.core.map.MapPaddingsInterface, java.lang.Double); @@ -106,6 +107,8 @@ public final class com.mapconductor.tomtom.TomTomMapViewController extends com.m public final class com.mapconductor.tomtom.TomTomMapViewController$Companion { } public final class com.mapconductor.tomtom.TomTomMapViewControllerCameraKt { + public static final double viewportHeightDp(com.mapconductor.tomtom.TomTomMapViewController); + public static final com.mapconductor.core.map.MapCameraPosition toNativeCamera(com.mapconductor.tomtom.TomTomMapViewController, com.mapconductor.core.map.MapCameraPosition); public static final void handleMoveCamera(com.mapconductor.tomtom.TomTomMapViewController, com.mapconductor.core.map.MapCameraPosition); public static final void handleAnimateCamera(com.mapconductor.tomtom.TomTomMapViewController, com.mapconductor.core.map.MapCameraPosition, long); public static final void handleFitBounds(com.mapconductor.tomtom.TomTomMapViewController, com.mapconductor.core.features.GeoRectBounds, int); diff --git a/src/main/java/com/mapconductor/tomtom/MapCameraPosition.kt b/src/main/java/com/mapconductor/tomtom/MapCameraPosition.kt index 1f29be4..38a3941 100644 --- a/src/main/java/com/mapconductor/tomtom/MapCameraPosition.kt +++ b/src/main/java/com/mapconductor/tomtom/MapCameraPosition.kt @@ -70,6 +70,12 @@ fun MapCameraPosition.toCameraOptions(): CameraOptions { ) } +/** + * TomTom のカメラの縦方向の視野角(度)。SDK に取得 API は無い。地図の大きさによらず一定で、 + * TB520FU の縦・横で 45° を実測した(焦点距離 ≈ 地図の高さ × 1.21)。 + */ +internal const val TOMTOM_VERTICAL_FOV = 45.0 + fun MapCameraPosition.Companion.from(position: MapCameraPositionInterface): MapCameraPosition = when (position) { is MapCameraPosition -> position @@ -81,6 +87,7 @@ fun MapCameraPosition.Companion.from(position: MapCameraPositionInterface): MapC tilt = position.tilt, paddings = position.paddings, visibleRegion = position.visibleRegion, + fov = position.fov, ) } diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt index bd8bb17..b58223f 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewController.kt @@ -8,7 +8,10 @@ import com.mapconductor.core.features.GeoPointInterface import com.mapconductor.core.features.GeoRectBounds import com.mapconductor.core.groundimage.GroundImageState import com.mapconductor.core.groundimage.OnGroundImageEventHandler +import com.mapconductor.core.map.CameraPaddingEmulation 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 @@ -206,6 +209,15 @@ class TomTomMapViewController internal constructor( // カメラ状態の読み戻し時に元の負tilt を復元するヒントとして保持する(MapLibre と同方針)。 internal var lastLogicalCameraPosition: MapCameraPosition? = null + /** + * 今カメラに付いているパディング(dp)。 + * + * `MapController.setPadding` は使わない。付けた瞬間に画面がずれてアニメーションの + * 始まりが跳ぶため。代わりにカメラ中心をずらして再現し([CameraPaddingEmulation])、 + * 読むときに元へ戻すためにここで覚えておく。 + */ + internal var cameraPaddings: MapPaddingsInterface = MapPaddings.Zeros + override suspend fun clearOverlays() { markerController.clear() polylineController.clear() diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerCamera.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerCamera.kt index 6ede79e..521df29 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerCamera.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerCamera.kt @@ -1,11 +1,29 @@ package com.mapconductor.tomtom import com.mapconductor.core.features.GeoRectBounds +import com.mapconductor.core.map.CameraPaddingEmulation import com.mapconductor.core.map.MapCameraPosition import com.mapconductor.core.map.buildVisibleRegion +import kotlin.math.abs import kotlin.time.Duration.Companion.milliseconds import kotlinx.coroutines.launch +/** 地図の高さ(dp)。パディングのエミュレーションで遠近を解くのに使う。 */ +internal fun TomTomMapViewController.viewportHeightDp(): Double { + val density = holder.mapView.resources.displayMetrics.density + return holder.mapView.height / density.toDouble() +} + +/** パディングを中心のずらしに置き換えたカメラ。paddings が null なら今のパディングを使い続ける。 */ +internal fun TomTomMapViewController.toNativeCamera(position: MapCameraPosition): MapCameraPosition { + position.paddings?.let { cameraPaddings = it } + return CameraPaddingEmulation.toNativeCamera( + position.copy(paddings = cameraPaddings), + TOMTOM_VERTICAL_FOV, + viewportHeightDp(), + ) +} + /** * カメラの読み書きと、移動中・停止時の通知。 */ @@ -14,7 +32,7 @@ internal fun TomTomMapViewController.handleMoveCamera(position: MapCameraPositio lastLogicalCameraPosition = position mainCoroutine.launch { if (destroyed) return@launch - holder.map.moveCamera(position.toCameraOptions()) + holder.map.moveCamera(toNativeCamera(position).toCameraOptions()) } } @@ -27,7 +45,7 @@ internal fun TomTomMapViewController.handleAnimateCamera( mainCoroutine.launch { if (destroyed) return@launch holder.map.animateCamera( - position.toCameraOptions(), + toNativeCamera(position).toCameraOptions(), duration.milliseconds, ) } @@ -76,6 +94,7 @@ internal fun TomTomMapViewController.onCameraChangeInternal() { /** カメラ停止時(steady リスナーから配線)。 */ internal fun TomTomMapViewController.onCameraSteadyInternal() { cameraMovingStarted = false + if (correctPaddedTiltIfClamped()) return val mapCameraPosition = getMapCameraPosition() // 範囲・ズーム制限に違反していれば矩形内へ引き戻す(TomTom はネイティブの範囲制限 API が無いため)。 // 再適用すると再度 steady が発火し、そこでは補正不要になり通常フローへ進む。 @@ -87,10 +106,34 @@ internal fun TomTomMapViewController.onCameraSteadyInternal() { emitCameraMoveEnd(mapCameraPosition) } +/** + * TomTom はズームに応じて tilt を抑える(ズーム 15 で約 42°)。パディングを中心のずらしで + * 再現しているので、要求した tilt で解いた中心のままだと、パディング中央からずれる + * (tilt 60° の要求で 130px)。止まったところで実際の tilt を見て、違っていれば + * その tilt で解き直して置き直す。置き直したら true。 + */ +private fun TomTomMapViewController.correctPaddedTiltIfClamped(): Boolean { + val requested = lastLogicalCameraPosition ?: return false + if (requested.tilt <= 0.0) return false + val paddings = cameraPaddings + if (paddings.top == 0.0 && paddings.left == 0.0 && paddings.bottom == 0.0 && paddings.right == 0.0) return false + val actualTilt = holder.map.cameraPosition.tilt + if (abs(actualTilt - requested.tilt) < TILT_CLAMP_TOLERANCE_DEG) return false + handleMoveCamera(requested.copy(tilt = actualTilt)) + return true +} + +private const val TILT_CLAMP_TOLERANCE_DEG = 0.5 + internal fun TomTomMapViewController.getMapCameraPosition(): MapCameraPosition { val camera = - holder.map.cameraPosition.toMapCameraPosition( - logicalTiltHint = lastLogicalCameraPosition?.tilt, + CameraPaddingEmulation.fromNativeCamera( + holder.map.cameraPosition.toMapCameraPosition( + logicalTiltHint = lastLogicalCameraPosition?.tilt, + ), + cameraPaddings, + TOMTOM_VERTICAL_FOV, + viewportHeightDp(), ) // 画面四隅を投影して visibleRegion(ビューポート)を構築する。 // これが無いと marker-clustering がビューポートを算出できずクラスタが一切描画されない From e4c46a929ce8e44778d92cc1fdb00b3e9412e86e Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Thu, 12 Nov 2026 13:32:29 -0800 Subject: [PATCH 23/25] Update TomTom Maps SDK to 2.7.2 2.7 makes MapOptions.initialCameraOptions required. Pass a minimum-zoom camera at the target position and keep moving to the real camera after the view attaches: handing over the real camera up front leaves that moveCamera with nothing to change, and with renderToTexture the first frame is then never drawn (black map on a Pixel 5a). --- gradle/libs.versions.toml | 2 +- src/main/java/com/mapconductor/tomtom/TomTomMapView.kt | 9 +++++++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index a8e71c5..e66ec05 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -11,7 +11,7 @@ composeBom = "2026.09.00" lifecycleRuntimeKtx = "2.11.0" # TomTom Orbis Maps Display SDK # 参照: https://developer.tomtom.com/android/maps/documentation -tomtomMaps = "2.6.3" +tomtomMaps = "2.7.2" activityCompose = "1.13.0" ktLint = "14.2.0" diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt index 1c12098..8e9b259 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt @@ -38,6 +38,7 @@ import com.mapconductor.tomtom.polygon.TomTomPolygonOverlayRenderer import com.mapconductor.tomtom.polyline.TomTomPolylineController import com.mapconductor.tomtom.polyline.TomTomPolylineOverlayRenderer import com.tomtom.sdk.map.display.MapOptions +import com.tomtom.sdk.map.display.camera.InitialCameraOptions import com.tomtom.sdk.map.display.ui.MapView import java.util.concurrent.atomic.AtomicBoolean import kotlinx.coroutines.ExperimentalCoroutinesApi @@ -80,9 +81,17 @@ fun TomTomMapView( // 描画されない(View だけ出てタイルが出ない)。tmp の動作実装と同じ構成にする。 val mapView = remember { + // 2.7 から初期カメラが必須。ここでは同じ地点の広域表示にしておき、目的のカメラは + // 下の post で moveCamera する。最初から目的のカメラを渡すと moveCamera がカメラを + // 変えず、TextureView 描画では最初の 1 枚が描かれないまま黒くなる(2.7.2 実測)。 val options = MapOptions( mapKey = tomtomApiKey(context), + initialCameraOptions = + InitialCameraOptions.LocationBased( + position = initialCameraPosition.position.toTomTomGeoPoint(), + zoom = InitialCameraOptions.MIN_ZOOM, + ), // Compose の SubcomposeLayout 内に埋め込むため TextureView 描画にする。 renderToTexture = true, ) From bbaa7e779936c079e98105879da0311325bb1281 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Thu, 12 Nov 2026 18:30:01 -0800 Subject: [PATCH 24/25] Calibrate the TomTom zoom offset to 1.735 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit With 1.76, TomTom showed 0.025 zoom levels more area than Google Maps at the same unified zoom: the centre scale (coordinateForPoint ±200 px) differed by +0.025 at latitudes 0, 35.68 and 64.95 and zooms 9-19 on the TB520FU, about 1.7% on the CameraSync reference rectangles. With 1.735 the difference is within ±0.0005 from zoom 7 up, and +0.003 at zoom 5. Below that the globe and Mercator projections cannot be matched by a constant. The latitude term log2(cos φ) was already right, so only the base offset changes. iOS shows the same 0.025 offset and gets the same value. --- .../mapconductor/tomtom/zoom/ZoomAltitudeConverter.kt | 9 +++++++-- src/test/java/com/mapconductor/tomtom/ExampleUnitTest.kt | 4 ++-- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/mapconductor/tomtom/zoom/ZoomAltitudeConverter.kt b/src/main/java/com/mapconductor/tomtom/zoom/ZoomAltitudeConverter.kt index e7e05c5..2002bb6 100644 --- a/src/main/java/com/mapconductor/tomtom/zoom/ZoomAltitudeConverter.kt +++ b/src/main/java/com/mapconductor/tomtom/zoom/ZoomAltitudeConverter.kt @@ -11,7 +11,12 @@ import kotlin.math.max * * TomTom のズームはグラウンドスケール基準(画面上の meter/pixel が緯度によらず一定) * なので、Web Mercator 基準との差が緯度に依存する。オフセットは - * `1.76 + log2(cos φ)`。1.76 は実測較正値。 + * `1.735 + log2(cos φ)`。1.735 は実測較正値。 + * + * 較正は TB520FU(TomTom Maps SDK 2.7.2)で、同じ統一ズーム・同じ地図サイズの Google Maps と + * 表示範囲(`coordinateForPoint` で取った四隅)を突き合わせて行った。以前の 1.76 では TomTom が + * 緯度 0〜70°、zoom 12〜18 のどこでも 0.025 段だけ広く写っていた(Camera Sync の参照矩形で約 1.7%)。 + * zoom 10 以下で差が膨らんで見えるのは地球儀表示で四隅が回り込むためで、中心付近の縮尺は合っている。 * * 換算式はコアの [GroundScaleZoomAltitudeConverter] にある。 */ @@ -19,7 +24,7 @@ class ZoomAltitudeConverter( zoom0Altitude: Double = DEFAULT_ZOOM0_ALTITUDE, ) : GroundScaleZoomAltitudeConverter(zoom0Altitude, baseZoomOffset = TOMTOM_TO_GOOGLE_ZOOM_BASE_OFFSET) { companion object { - const val TOMTOM_TO_GOOGLE_ZOOM_BASE_OFFSET = 1.76 + const val TOMTOM_TO_GOOGLE_ZOOM_BASE_OFFSET = 1.735 fun zoomOffsetAt(latitude: Double): Double { val clampedLat = latitude.coerceIn(-85.0, 85.0) diff --git a/src/test/java/com/mapconductor/tomtom/ExampleUnitTest.kt b/src/test/java/com/mapconductor/tomtom/ExampleUnitTest.kt index e4c7ea2..819abe9 100644 --- a/src/test/java/com/mapconductor/tomtom/ExampleUnitTest.kt +++ b/src/test/java/com/mapconductor/tomtom/ExampleUnitTest.kt @@ -7,12 +7,12 @@ import org.junit.Test class ExampleUnitTest { @Test fun tokyoOffsetMatchesCameraSyncCalibration() { - assertEquals(1.46, ZoomAltitudeConverter.zoomOffsetAt(35.6812), 0.01) + assertEquals(1.435, ZoomAltitudeConverter.zoomOffsetAt(35.6812), 0.01) } @Test fun oahuOffsetMatchesCameraSyncCalibration() { - assertEquals(1.66, ZoomAltitudeConverter.zoomOffsetAt(21.4389), 0.01) + assertEquals(1.632, ZoomAltitudeConverter.zoomOffsetAt(21.4389), 0.01) } @Test From 848c52bbc91bf2d94f90e42639122478c07117c5 Mon Sep 17 00:00:00 2001 From: Masashi Katsumata Date: Fri, 13 Nov 2026 03:40:56 -0800 Subject: [PATCH 25/25] Release 1.4.0 --- api/android-for-tomtom.api | 3 +++ gradle.properties | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/api/android-for-tomtom.api b/api/android-for-tomtom.api index 2513d62..e2dd4b8 100644 --- a/api/android-for-tomtom.api +++ b/api/android-for-tomtom.api @@ -155,6 +155,9 @@ public final class com.mapconductor.tomtom.TomTomMapViewHolder 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(); } 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