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": "" + } +} 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/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/api/android-for-tomtom.api b/api/android-for-tomtom.api index 98775dc..e2dd4b8 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); @@ -40,6 +41,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; } @@ -66,6 +70,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); @@ -83,6 +91,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); @@ -97,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); @@ -143,11 +155,14 @@ 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(); } 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 { @@ -326,7 +341,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/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/gradle.properties b/gradle.properties index 26d9949..8b1a332 100644 --- a/gradle.properties +++ b/gradle.properties @@ -3,10 +3,10 @@ android.useAndroidX=true kotlin.code.style=official android.nonTransitiveRClass=true -compileSdk=35 +compileSdk=37 minSdk=26 javaVersion=17 jvmTarget=17 -libraryVersion=1.3.1 +libraryVersion=1.4.0 android.generateSyncIssueWhenLibraryConstraintsAreEnabled=false diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index b2fda5a..e66ec05 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -1,15 +1,18 @@ [versions] -composeLibs = "1.7.8" -coroutines = "1.9.0" -agp = "9.2.1" -kotlin = "2.0.21" - -composeBom = "2025.02.00" -lifecycleRuntimeKtx = "2.8.7" +composeLibs = "1.12.1" +# material3 は compose-ui とは別のバージョン系列。composeLibs(ui 系)を流用すると +# 存在しない material3:1.7.8 を要求してクラスパスごと解決に失敗する。 +material3 = "1.4.0" +coroutines = "1.11.0" +agp = "9.4.1" +kotlin = "2.4.20" + +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.7.2" +activityCompose = "1.13.0" ktLint = "14.2.0" junit = "4.13.2" @@ -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/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/MapCameraPosition.kt b/src/main/java/com/mapconductor/tomtom/MapCameraPosition.kt index 897229b..38a3941 100644 --- a/src/main/java/com/mapconductor/tomtom/MapCameraPosition.kt +++ b/src/main/java/com/mapconductor/tomtom/MapCameraPosition.kt @@ -1,136 +1,144 @@ -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(), + ) +} + +/** + * 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 + else -> + MapCameraPosition( + position = position.position, + zoom = position.zoom, + bearing = position.bearing, + tilt = position.tilt, + paddings = position.paddings, + visibleRegion = position.visibleRegion, + fov = position.fov, + ) + } + +/** + * 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, + ) +} diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt index 1ed5c98..372ae98 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapDesign.kt @@ -1,14 +1,29 @@ 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 com.tomtom.sdk.map.display.style.StyleDescriptor +import android.net.Uri 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 +35,16 @@ sealed class TomTomMapDesign( override val attributionRules: List = emptyList(), ) : TomTomMapDesignType { /** 既定(ブラウジング)スタイル。 */ - object Standard : TomTomMapDesign("standard", StandardStyles.TomTomOrbisMaps.BROWSING) + /** ベースマップ無し。背景色だけのスタイル(core の同梱アセット)。 */ + object None : TomTomMapDesign("none", StyleDescriptor(Uri.parse(BlankMapStyle.ASSET_URI))) + + 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( @@ -40,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/TomTomMapView.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapView.kt index 9b38301..8e9b259 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 @@ -18,6 +19,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 @@ -36,7 +38,9 @@ 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 import kotlinx.coroutines.suspendCancellableCoroutine @@ -54,6 +58,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() } @@ -68,15 +81,38 @@ 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, ) 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 が届く(これがタイル描画に必須)。 @@ -102,7 +138,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() } } @@ -147,7 +185,6 @@ fun TomTomMapView( } mapController.setMapClickListener(onMapClick) mapController.setMapLongClickListener(onMapLongClick) - mapController.setMapDesignTypeChangeListener(state::onMapDesignTypeChange) cameraRestriction?.let { mapController.setCameraRestriction(it) } // 大量マーカーをラスタタイル化するため、マーカータイル用ラスタレイヤーの // 実体化(スタイル合成 + loadStyle)を配線する。 @@ -155,6 +192,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) @@ -165,6 +213,7 @@ fun TomTomMapView( scope = scope, registry = registry, onMapLoaded = onMapLoaded, + onDestroyMapView = { releaseMapView() }, customDisposableEffect = { _, _ -> // MapView のライフサイクルは上の本体 DisposableEffect で駆動済み。 // ここではコンポジション破棄時にコントローラを破棄してリークを防ぐ。 @@ -182,6 +231,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 5bc675b..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,17 +209,104 @@ 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() polygonController.clear() circleController.clear() + groundImageController.clear() + // TomTom には RasterLayerController が無い(ラスタは合成スタイルへ畳み込む)ので、 + // 他プロバイダの rasterLayerController.clear() に当たるものをここで行う。消すのは + // 公開 RasterLayer 経由のものだけ。マーカータイル等の mount 分は持ち主が外す。 + val rasterIds = publicRasterLayerIds.toList() + publicRasterLayerIds.clear() + rasterIds.forEach { removeRasterLayer(it) } + // 拡張モジュール(クラスタリングなど)が登録した Strategy のマーカーも消す。 + clearStrategyMarkerControllers() } override fun setMarkerAnimationOverlayHost(host: MarkerAnimationOverlayHost?) { (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() { + // 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() + circleController.add(states.sortedBy { it.zIndex ?: 0 }) + } + + 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() + polylineController.add(states.sortedBy { it.zIndex }) + } + // ---- Polyline / Polygon / Circle capable ------------------------------ override fun hasPolyline(state: PolylineState): Boolean = polylineController.polylineManager.hasEntity(state.id) @@ -299,6 +389,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, @@ -328,6 +428,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 @@ -354,6 +457,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( @@ -372,6 +492,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/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 がビューポートを算出できずクラスタが一切描画されない diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt index af75e79..9a095a0 100644 --- a/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt +++ b/src/main/java/com/mapconductor/tomtom/TomTomMapViewControllerRaster.kt @@ -1,5 +1,11 @@ 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 +import com.mapconductor.core.polyline.PolylineTiler import com.mapconductor.core.raster.RasterLayerSource import com.mapconductor.core.raster.RasterLayerState import com.mapconductor.tomtom.marker.MarkerTileRasterLayerCallback @@ -46,6 +52,39 @@ 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) + } + } + } + // 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) + } + } + } + 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) { @@ -54,6 +93,8 @@ internal suspend fun TomTomMapViewController.applyPublicRasterLayer(state: Raste removeRasterLayer(state.id) return } + // 帯の中の順(zIndex、同じなら渡された順)。合成のときに並べる。 + composedRasterZIndex[state.id] = state.zIndex // ソースの tileSize / minZoom / maxZoom を合成スタイルへ伝える。maxZoom を渡すと // 高ズームでオーバーズーム表示され、実タイルの無い領域での歯抜けを防げる。 upsertRasterLayer( @@ -85,18 +126,35 @@ 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 } composedStyleToggle = composedStyleToggle xor 1 val outFile = File(cacheDir, "tomtom_composed_style_$composedStyleToggle.json") + // アプリのラスターはラスターの帯(ベースマップのラベルの下)、マーカーのタイルはマーカーの帯(最前面)。 + // ポリゴンのタイルはアプリのラスターのすぐ上(ラベルの下)。ネイティブのサークル・ポリゴン + // (SDK のオーバーレイ)はその上に来る。ポリラインのタイルはベースマップの全レイヤー(道路・ラベル)の + // 上: TomTom のスタイルは最初のラベルの後ろにも道路の line が続くので、ラベルの前では道路のタイルが + // 地図の道路に覆われて見えなかった。ネイティブのサークルより上・マーカー(とそのタイル)より下になる + // (実機で確認。ポリゴンのタイルまで上へ上げるとサークルを覆ってしまう)。 + val (markerTiles, others) = + composedRasterLayers.values.partition { it.id == TomTomMapViewController.MARKER_RASTER_ID } + val (polylineTiles, rest) = others.partition { it.id == POLYLINE_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.composeRasterStyle( + TomTomStyleComposer.composeStackedRasterStyle( apiKey = apiKey, cacheDir = cacheDir, - layers = composedRasterLayers.values.toList(), + belowOverlays = appRasters.sortedBy { composedRasterZIndex[it.id] ?: 0 } + polygonTiles + circleTiles, + aboveOverlays = markerTiles, outFile = outFile, + withoutBasemap = withoutBasemap, + polylineTiles = polylineTiles, ) ?: return if (destroyed) return withContext(Dispatchers.Main) { @@ -136,3 +194,4 @@ internal fun TomTomMapViewController.styleLoadingCallback(tag: String) = android.util.Log.e("TomTomRaster", "loadStyle failed ($tag): $failure") } } + diff --git a/src/main/java/com/mapconductor/tomtom/TomTomMapViewStateImpl.kt b/src/main/java/com/mapconductor/tomtom/TomTomMapViewStateImpl.kt index 8192ec2..81b6101 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 @@ -36,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) } @@ -61,7 +66,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 +83,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, diff --git a/src/main/java/com/mapconductor/tomtom/marker/TomTomMarkerController.kt b/src/main/java/com/mapconductor/tomtom/marker/TomTomMarkerController.kt index f0727e9..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) } @@ -288,6 +316,7 @@ internal class TomTomMarkerController private constructor( cacheSizeBytes = markerTiling.cacheSize, debugTileOverlay = markerTiling.debugTileOverlay, iconScaleCallback = markerTiling.iconScaleCallback, + declutterPx = markerTiling.declutterPx, ) markerTileRenderer = tileRenderer tileServer.register(groupId, tileRenderer) @@ -353,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, diff --git a/src/main/java/com/mapconductor/tomtom/polygon/TomTomPolygonOverlayRenderer.kt b/src/main/java/com/mapconductor/tomtom/polygon/TomTomPolygonOverlayRenderer.kt index 80de850..c0c3152 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.densifyPolygonRing 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 @@ -42,13 +42,7 @@ class TomTomPolygonOverlayRenderer( points: List, geodesic: Boolean, ): List { - // 非 geodesic は補間せず生の頂点を使う(HERE と同じ)。geodesic のみ補間する。 - val geoPoints = - if (geodesic) { - WGS84Geodesic.createInterpolatePoints(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()) { @@ -78,16 +72,28 @@ class TomTomPolygonOverlayRenderer( points: List, geodesic: Boolean, ): List { - val geoPoints = - if (geodesic) { - WGS84Geodesic.createInterpolatePoints(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)) diff --git a/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt b/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt index 2f3130b..b5b265f 100644 --- a/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt +++ b/src/main/java/com/mapconductor/tomtom/raster/TomTomStyleComposer.kt @@ -1,211 +1,334 @@ -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" + + /** + * 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枚分の指定。 */ + 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? = + composeStackedRasterStyle( + apiKey = apiKey, + cacheDir = cacheDir, + belowOverlays = emptyList(), + aboveOverlays = layers, + outFile = outFile, + withoutBasemap = withoutBasemap, + ) + + /** + * [composeRasterStyle] の、重なり順を指定できる版。 + * + * - [belowOverlays]: アプリのラスター(RasterLayerState)。重なり順の決まり + * (ラスター < GroundImage < ポリゴン < サークル < ポリライン < マーカー)でいちばん下の帯なので、 + * SDK のオーバーレイ用レイヤー(polygon-shape など)とベースマップのラベルより**下**へ、 + * 渡された順(下→上)に入れる。 + * - [polylineTiles]: SDK 自身のポリラインのタイル(下→上)。スタイルの全レイヤー(ベースマップの + * 道路・ラベルも含む)の上、マーカーのタイルの下へ。TomTom のスタイルは最初の symbol の後ろにも + * 道路の line レイヤーが続くので、ラベルの前に入れると道路のタイルが地図の道路に覆われて見えなかった。 + * - [aboveOverlays]: マーカーのタイル。マーカーの帯なのでスタイルの末尾(最前面)へ。 + * + * 以前はどちらも末尾に積んでいたため、アプリのラスターがポリゴン・ポリライン・ + * GroundImage(いずれも SDK のオーバーレイ)を覆っていた。 + */ + internal suspend fun composeStackedRasterStyle( + apiKey: String, + cacheDir: File, + belowOverlays: List, + 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 + // (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)) + ?.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 { + 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) + } + + // アプリのラスター: 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++ + } + // ポリラインのタイル: ベースマップの全レイヤーの上へ順に。 + 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 + 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)) + } + + 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, " + + "${belowOverlays.size + polylineTiles.size + aboveOverlays.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)) + } + + /** + * アプリのラスターを入れる位置: ベースマップのラベル(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, + 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 + } +} 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