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/api/android-for-mappls.api b/api/android-for-mappls.api index df63c9f..332d344 100644 --- a/api/android-for-mappls.api +++ b/api/android-for-mappls.api @@ -10,19 +10,27 @@ public final class com.mapconductor.mappls.GeoRectBoundsKt { public static final com.mapconductor.core.features.GeoRectBounds toGeoRectBounds(com.mappls.sdk.maps.geometry.LatLngBounds); } public final class com.mapconductor.mappls.MapCameraPositionKt { + public static final double MAPPLS_VERTICAL_FOV; + public static final double[] toMapplsPadding(com.mapconductor.core.map.MapPaddingsInterface, float); + public static final com.mapconductor.core.map.MapPaddings toMapPaddings(double[], float); public static final com.mappls.sdk.maps.camera.CameraPosition toCameraPosition(com.mapconductor.core.map.MapCameraPosition); + public static final com.mappls.sdk.maps.camera.CameraPosition toCameraPosition(com.mapconductor.core.map.MapCameraPosition, java.lang.Float); public static final com.mapconductor.core.map.MapCameraPosition from(com.mapconductor.core.map.MapCameraPosition$Companion, com.mapconductor.core.map.MapCameraPositionInterface); public static final com.mapconductor.core.map.MapCameraPosition toMapCameraPosition(com.mappls.sdk.maps.camera.CameraPosition); public static final com.mapconductor.core.map.MapCameraPosition toMapCameraPosition(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double); + public static final com.mapconductor.core.map.MapCameraPosition toMapCameraPosition(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double, java.lang.Float); } public final class com.mapconductor.mappls.MapplsCameraStateSnapshot { - public com.mapconductor.mappls.MapplsCameraStateSnapshot(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double); + public com.mapconductor.mappls.MapplsCameraStateSnapshot(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double, java.lang.Float); + public com.mapconductor.mappls.MapplsCameraStateSnapshot(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double, java.lang.Float, int, kotlin.jvm.internal.DefaultConstructorMarker); public final com.mappls.sdk.maps.camera.CameraPosition getCameraPosition(); public final java.lang.Double getLogicalTiltHint(); + public final java.lang.Float getDensity(); public final com.mapconductor.core.map.MapCameraPosition toMapCameraPosition(); public final com.mappls.sdk.maps.camera.CameraPosition component1(); public final java.lang.Double component2(); - public final com.mapconductor.mappls.MapplsCameraStateSnapshot copy(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double); + public final java.lang.Float component3(); + public final com.mapconductor.mappls.MapplsCameraStateSnapshot copy(com.mappls.sdk.maps.camera.CameraPosition, java.lang.Double, java.lang.Float); public java.lang.String toString(); public int hashCode(); public boolean equals(java.lang.Object); @@ -76,6 +84,9 @@ public final class com.mapconductor.mappls.MapplsMapViewHolder implements com.ma public androidx.compose.ui.geometry.Offset toScreenOffset-x-9fifI(com.mapconductor.core.features.GeoPointInterface); public com.mapconductor.core.features.GeoPoint fromScreenOffsetSync-k-4lQ0M(long); public java.lang.Object fromScreenOffset-3MmeM6k(long, kotlin.coroutines.Continuation); + public com.mapconductor.core.projection.ProjectedPoint toProjectedPoint(com.mapconductor.core.features.GeoPointInterface); + public com.mapconductor.core.features.GeoPoint fromProjectedPoint(com.mapconductor.core.projection.ProjectedPoint); + public com.mapconductor.core.projection.MapCoordinateSystem getCoordinateSystem(); public java.lang.Object getMapView(); public java.lang.Object getMap(); } @@ -84,13 +95,16 @@ public interface com.mapconductor.mappls.MapplsMapViewHolderInterface extends co public final class com.mapconductor.mappls.MapplsMapViewHolderInterface$DefaultImpls { public static java.lang.Object fromScreenOffset-3MmeM6k(com.mapconductor.mappls.MapplsMapViewHolderInterface, long, kotlin.coroutines.Continuation); public static com.mapconductor.core.features.GeoPoint fromScreenOffsetSync-k-4lQ0M(com.mapconductor.mappls.MapplsMapViewHolderInterface, long); + public static com.mapconductor.core.projection.ProjectedPoint toProjectedPoint(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.features.GeoPointInterface); + public static com.mapconductor.core.features.GeoPoint fromProjectedPoint(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.projection.ProjectedPoint); + public static com.mapconductor.core.projection.MapCoordinateSystem getCoordinateSystem(com.mapconductor.mappls.MapplsMapViewHolderInterface); } public final class com.mapconductor.mappls.MapplsMapViewKt { - public static final void MapplsMapView(com.mapconductor.mappls.MapplsViewState, androidx.compose.ui.Modifier, com.mapconductor.core.marker.MarkerTilingOptions, com.mapconductor.core.map.CameraRestriction, kotlin.jvm.functions.Function2, ? extends java.lang.Object>, kotlin.jvm.functions.Function1, kotlin.Unit>, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function3, androidx.compose.runtime.Composer, int, int, int); + public static final void MapplsMapView(com.mapconductor.mappls.MapplsViewState, androidx.compose.ui.Modifier, com.mapconductor.core.marker.MarkerTilingOptions, com.mapconductor.core.map.CameraRestriction, kotlin.jvm.functions.Function2, ? extends java.lang.Object>, kotlin.jvm.functions.Function1, kotlin.Unit>, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, com.mapconductor.core.map.MapViewStyle, kotlin.jvm.functions.Function1, kotlin.Unit>, kotlin.jvm.functions.Function3, androidx.compose.runtime.Composer, int, int, int); public static final com.mapconductor.mappls.MapplsViewController createMapplsViewController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.marker.MarkerTilingOptions, com.mapconductor.core.map.MutableMapServiceRegistry); public static final com.mapconductor.mappls.marker.MapplsMarkerController getMarkerController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.marker.MarkerTilingOptions); public static final com.mapconductor.mappls.polyline.MapplsPolylineController getPolylineController(com.mapconductor.mappls.MapplsMapViewHolderInterface); - public static final com.mapconductor.mappls.polygon.MapplsPolygonConductor getPolygonController(com.mapconductor.mappls.MapplsMapViewHolderInterface); + public static final com.mapconductor.mappls.polygon.MapplsPolygonController getPolygonController(com.mapconductor.mappls.MapplsMapViewHolderInterface); public static final com.mapconductor.mappls.circle.MapplsCircleController getCircleController(com.mapconductor.mappls.MapplsMapViewHolderInterface); public static final com.mapconductor.mappls.raster.MapplsRasterLayerController getRasterLayerController(com.mapconductor.mappls.MapplsMapViewHolderInterface); public static final com.mapconductor.mappls.groundimage.MapplsGroundImageController getGroundImageController(com.mapconductor.mappls.MapplsMapViewHolderInterface); @@ -108,6 +122,18 @@ public final class com.mapconductor.mappls.MapplsMapViewSaver extends com.mapcon public final class com.mapconductor.mappls.MapplsMapViewScope extends com.mapconductor.compose.MapViewScope { public com.mapconductor.mappls.MapplsMapViewScope(); } +public final class com.mapconductor.mappls.MapplsOverlayStacking { + public static final com.mapconductor.mappls.MapplsOverlayStacking INSTANCE; + public final com.mapconductor.core.controller.OverlayLayerStack stackOf(com.mappls.sdk.maps.MapplsMap); + public final com.mapconductor.core.controller.OverlayStacking$Key key(com.mapconductor.core.controller.OverlayKind, int); + public final com.mapconductor.core.controller.OverlayStacking$Key getMARKER_TILE(); + public final com.mapconductor.core.controller.OverlayStacking$Key getPOLYGON_TILE(); + public final com.mapconductor.core.controller.OverlayStacking$Key getCIRCLE_TILE(); + public final com.mapconductor.core.controller.OverlayStacking$Key getPOLYLINE_TILE(); + public final com.mapconductor.core.controller.OverlayStacking$Key getMARKER_DRAG(); + public final void add(com.mappls.sdk.maps.MapplsMap, com.mappls.sdk.maps.Style, com.mappls.sdk.maps.style.layers.Layer, com.mapconductor.core.controller.OverlayStacking$Key); + public final void remove(com.mappls.sdk.maps.MapplsMap, com.mappls.sdk.maps.Style, java.lang.String); +} public final class com.mapconductor.mappls.MapplsPolyUtilsKt { public static final java.util.List createMapplsLines-rXlOB7A(java.lang.String, java.util.List, boolean, long, float, int); public static final java.lang.String toMapplsColorString-8_81llA(long); @@ -116,8 +142,8 @@ public final class com.mapconductor.mappls.MapplsPolyUtilsKt { public final class com.mapconductor.mappls.MapplsTypeAliasKt { } public final class com.mapconductor.mappls.MapplsViewController extends com.mapconductor.core.controller.BaseMapViewController implements com.mapconductor.mappls.MapplsViewControllerInterface,com.mappls.sdk.maps.MapplsMap$OnMapClickListener,com.mappls.sdk.maps.MapplsMap$OnMapLongClickListener,com.mappls.sdk.maps.MapplsMap$OnMoveListener,com.mappls.sdk.maps.MapplsMap$OnCameraMoveListener,com.mappls.sdk.maps.MapplsMap$OnCameraIdleListener { - public com.mapconductor.mappls.MapplsViewController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.mappls.marker.MapplsMarkerController, com.mapconductor.mappls.polyline.MapplsPolylineController, com.mapconductor.mappls.polygon.MapplsPolygonConductor, com.mapconductor.mappls.groundimage.MapplsGroundImageController, com.mapconductor.mappls.circle.MapplsCircleController, com.mapconductor.mappls.raster.MapplsRasterLayerController, kotlinx.coroutines.CoroutineScope, kotlinx.coroutines.CoroutineScope); - public com.mapconductor.mappls.MapplsViewController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.mappls.marker.MapplsMarkerController, com.mapconductor.mappls.polyline.MapplsPolylineController, com.mapconductor.mappls.polygon.MapplsPolygonConductor, com.mapconductor.mappls.groundimage.MapplsGroundImageController, com.mapconductor.mappls.circle.MapplsCircleController, com.mapconductor.mappls.raster.MapplsRasterLayerController, kotlinx.coroutines.CoroutineScope, kotlinx.coroutines.CoroutineScope, int, kotlin.jvm.internal.DefaultConstructorMarker); + public com.mapconductor.mappls.MapplsViewController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.mappls.marker.MapplsMarkerController, com.mapconductor.mappls.polyline.MapplsPolylineController, com.mapconductor.mappls.polygon.MapplsPolygonController, com.mapconductor.mappls.groundimage.MapplsGroundImageController, com.mapconductor.mappls.circle.MapplsCircleController, com.mapconductor.mappls.raster.MapplsRasterLayerController, kotlinx.coroutines.CoroutineScope, kotlinx.coroutines.CoroutineScope); + public com.mapconductor.mappls.MapplsViewController(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.mappls.marker.MapplsMarkerController, com.mapconductor.mappls.polyline.MapplsPolylineController, com.mapconductor.mappls.polygon.MapplsPolygonController, com.mapconductor.mappls.groundimage.MapplsGroundImageController, com.mapconductor.mappls.circle.MapplsCircleController, com.mapconductor.mappls.raster.MapplsRasterLayerController, kotlinx.coroutines.CoroutineScope, kotlinx.coroutines.CoroutineScope, int, kotlin.jvm.internal.DefaultConstructorMarker); public com.mapconductor.mappls.MapplsMapViewHolderInterface getHolder(); public kotlinx.coroutines.CoroutineScope getMainCoroutine(); public kotlinx.coroutines.CoroutineScope getDefaultCoroutine(); @@ -160,6 +186,9 @@ public final class com.mapconductor.mappls.MapplsViewController extends com.mapc } public final class com.mapconductor.mappls.MapplsViewControllerCameraKt { public static final com.mapconductor.core.map.MapCameraPosition readLogicalCameraPosition(com.mapconductor.mappls.MapplsViewController); + public static final double viewportHeightDp(com.mapconductor.mappls.MapplsViewController); + public static final com.mapconductor.core.map.MapCameraPosition toNativeCamera(com.mapconductor.mappls.MapplsViewController, com.mapconductor.core.map.MapCameraPosition); + public static final float density(com.mapconductor.mappls.MapplsViewController); public static final com.mapconductor.core.map.MapCameraPosition getMapCameraPosition(com.mapconductor.mappls.MapplsViewController, com.mapconductor.core.map.MapCameraPositionInterface); public static final void handleMoveCamera(com.mapconductor.mappls.MapplsViewController, com.mapconductor.core.map.MapCameraPosition); public static final void handleAnimateCamera(com.mapconductor.mappls.MapplsViewController, com.mapconductor.core.map.MapCameraPosition, long); @@ -303,6 +332,9 @@ public final class com.mapconductor.mappls.marker.MapplsMarkerController extends public void destroy(); public java.lang.Object update(java.lang.Object, kotlin.coroutines.Continuation); } +final class com.mapconductor.mappls.marker.MapplsMarkerController$Companion { + public final long getTILE_REFRESH_COALESCE-UwyO8pc(); +} public final class com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer extends com.mapconductor.core.marker.AbstractMarkerOverlayRenderer { public com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.marker.MarkerManager, com.mapconductor.mappls.marker.MarkerLayer, com.mapconductor.mappls.marker.MarkerDragLayer, kotlinx.coroutines.CoroutineScope); public com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer(com.mapconductor.mappls.MapplsMapViewHolderInterface, com.mapconductor.core.marker.MarkerManager, com.mapconductor.mappls.marker.MarkerLayer, com.mapconductor.mappls.marker.MarkerDragLayer, kotlinx.coroutines.CoroutineScope, int, kotlin.jvm.internal.DefaultConstructorMarker); @@ -318,6 +350,7 @@ public final class com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer ex public java.lang.Object onRemove(java.util.List>, kotlin.coroutines.Continuation); public final void drawDragLayer(); public final void redraw(); + protected java.lang.Object applyDrawOrder(java.util.List>, kotlin.coroutines.Continuation); public java.lang.Object onPostProcess(kotlin.coroutines.Continuation); public java.lang.Object onChange(java.util.List>, kotlin.coroutines.Continuation>); public void onDragSelectionChanged(com.mapconductor.core.marker.MarkerEntityInterface, com.mapconductor.core.marker.MarkerEntityInterface); @@ -365,27 +398,23 @@ public class com.mapconductor.mappls.marker.MarkerLayer { public final boolean wouldSkipDraw(java.util.List>); public final void draw(java.util.List>, com.mappls.sdk.maps.Style); } -public final class com.mapconductor.mappls.polygon.MapplsPolygonConductor implements com.mapconductor.core.controller.SlottedOverlayController> { - public com.mapconductor.mappls.polygon.MapplsPolygonConductor(com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer, com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer); - public final com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer getPolygonOverlay(); - public final com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer getPolylineOverlay(); +public final class com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer implements com.mapconductor.core.polygon.PolygonOverlayRendererInterface> { + public com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer(com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer, com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer); + public final com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer getFill(); + public final com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer getOutline(); + public java.lang.Object onAdd(java.util.List, kotlin.coroutines.Continuation>>); + public java.lang.Object onChange(java.util.List>>, kotlin.coroutines.Continuation>>); + public java.lang.Object onRemove(java.util.List>>, kotlin.coroutines.Continuation); + public java.lang.Object onPostProcess(kotlin.coroutines.Continuation); +} +public final class com.mapconductor.mappls.polygon.MapplsPolygonCompositeRendererKt { +} +public final class com.mapconductor.mappls.polygon.MapplsPolygonController extends com.mapconductor.core.polygon.PolygonController> { + public com.mapconductor.mappls.polygon.MapplsPolygonController(com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer); + public com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer getRenderer(); public int getZIndex(); - public final kotlin.jvm.functions.Function1 getClickListener(); - public final void setClickListener(kotlin.jvm.functions.Function1); - public java.lang.Object add(java.util.List, kotlin.coroutines.Continuation); - public java.lang.Object update(com.mapconductor.core.polygon.PolygonState, kotlin.coroutines.Continuation); - public final void dispatchClick(com.mapconductor.core.polygon.PolygonEvent); - public com.mapconductor.core.polygon.PolygonEntityInterface find(com.mapconductor.core.features.GeoPointInterface); - public java.lang.Object clear(kotlin.coroutines.Continuation); - public com.mapconductor.core.controller.OverlayKind getKind(); - public boolean has(java.lang.String); - public void setClickListenerAny(java.lang.Object); - public com.mapconductor.core.controller.OverlayHit resolveTap(com.mapconductor.core.features.GeoPointInterface); public void destroy(); - public java.lang.Object update(java.lang.Object, kotlin.coroutines.Continuation); - public java.lang.Object find(com.mapconductor.core.features.GeoPointInterface); -} -public final class com.mapconductor.mappls.polygon.MapplsPolygonConductorKt { + public com.mapconductor.core.polygon.PolygonOverlayRendererInterface getRenderer(); } public final class com.mapconductor.mappls.polygon.MapplsPolygonLayer { public com.mapconductor.mappls.polygon.MapplsPolygonLayer(java.lang.String, java.lang.String); @@ -462,7 +491,6 @@ public final class com.mapconductor.mappls.raster.MapplsRasterLayerController ex public java.lang.Object update(com.mapconductor.core.raster.RasterLayerState, kotlin.coroutines.Continuation); public java.lang.Object clear(kotlin.coroutines.Continuation); public void destroy(); - public final java.lang.Object reapplyStyle(kotlin.coroutines.Continuation); public java.lang.Object update(java.lang.Object, kotlin.coroutines.Continuation); } public final class com.mapconductor.mappls.raster.MapplsRasterLayerHandle { diff --git a/build.gradle.kts b/build.gradle.kts index 4fd12f6..8b66e67 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -29,6 +29,7 @@ android { defaultConfig { minSdk = project.property("minSdk").toString().toInt() + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" consumerProguardFiles("consumer-rules.pro") } @@ -82,8 +83,11 @@ dependencies { } testImplementation(libs.junit) -} + // Saver の保存 → 復元を実機の Bundle / Parcel で確かめる(SaverRoundTripTest)。 + androidTestImplementation(libs.androidx.junit) + androidTestImplementation(libs.androidx.espresso.core) +} // Set project version for NMCP plugin version = libraryVersion @@ -92,9 +96,10 @@ val libraryDescription = "Mappls (MapmyIndia) implementation for MapConductor un // Gradle 9.6 で `by tasks.registering` は非推奨(スクリプトコンパイルエラーになる)。 // googlemaps 等の既存モジュールは古い形のままなので、再コンパイル時に同じ問題が出る。 -val javadocJar = tasks.register("javadocJar") { - archiveClassifier.set("javadoc") -} +val javadocJar = + tasks.register("javadocJar") { + archiveClassifier.set("javadoc") + } afterEvaluate { publishing { diff --git a/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 dfa0ddf..0a9be4b 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -1,16 +1,19 @@ [versions] -composeLibs = "1.7.8" -mapplsSdk = "9.0.3" -coroutines = "1.9.0" -agp = "9.2.1" -kotlin = "2.0.21" - -composeBom = "2025.02.00" -coreKtx = "1.16.0" -lifecycleRuntimeKtx = "2.8.7" -okhttp = "5.3.2" -playServicesMaps = "20.0.0" -activityCompose = "1.9.3" +composeLibs = "1.12.1" +# material3 は compose-ui とは別のバージョン系列。composeLibs(ui 系)を流用すると +# 存在しない material3:1.7.8 を要求してクラスパスごと解決に失敗する。 +material3 = "1.4.0" +mapplsSdk = "9.0.4" +coroutines = "1.11.0" +agp = "9.4.1" +kotlin = "2.4.20" + +composeBom = "2026.09.00" +coreKtx = "1.19.1" +lifecycleRuntimeKtx = "2.11.0" +okhttp = "5.5.1" +playServicesMaps = "20.1.0" +activityCompose = "1.13.0" ktLint = "14.2.0" junit = "4.13.2" @@ -37,7 +40,7 @@ play-services-maps = { module = "com.google.android.gms:play-services-maps", ver # Sample app androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" } -androidx-material3 = { group = "androidx.compose.material3", name = "material3", version.ref = "composeLibs" } +androidx-material3 = { group = "androidx.compose.material3", name = "material3", version.ref = "material3" } androidx-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling", version.ref = "composeLibs" } # Test diff --git a/settings.gradle.kts b/settings.gradle.kts index 981619a..68da554 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -46,4 +46,3 @@ dependencyResolutionManagement { } rootProject.name = "android-for-mappls" - diff --git a/src/androidTest/java/com/mapconductor/mappls/MapplsMapViewSaverTest.kt b/src/androidTest/java/com/mapconductor/mappls/MapplsMapViewSaverTest.kt new file mode 100644 index 0000000..05b1bf4 --- /dev/null +++ b/src/androidTest/java/com/mapconductor/mappls/MapplsMapViewSaverTest.kt @@ -0,0 +1,79 @@ +package com.mapconductor.mappls + +import androidx.compose.runtime.saveable.Saver +import androidx.compose.runtime.saveable.SaverScope +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.mapconductor.core.features.GeoPoint +import com.mapconductor.core.map.AttributionRule +import com.mapconductor.core.map.MapCameraPosition +import com.mapconductor.core.map.MapUISettings +import org.junit.Assert.assertEquals +import org.junit.Assert.assertSame +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import android.os.Bundle +import android.os.Parcel + +/** + * 回転などの構成変更で state が [MapplsMapViewSaver] を通って作り直されても、デザイン(id・ + * attributionRules ほか)と uiSettings・カメラが落ちないこと。Bundle は実機の Parcel を一度通す。 + */ +@RunWith(AndroidJUnit4::class) +class MapplsMapViewSaverTest { + private val rules = + listOf(AttributionRule("© test"), AttributionRule("© ranged", minZoom = 3, maxZoom = 15)) + + private val camera = + MapCameraPosition( + position = GeoPoint(21.38, -157.93), + zoom = 12.0, + bearing = 20.0, + tilt = 10.0, + ) + + @Test + fun keepsDesignWithAttributionRules() { + val design = MapplsDesign(id = "contract-style", styleName = "contract_style_name", attributionRules = rules) + val state = MapplsViewState(mapDesignType = design, id = "mappls-1", cameraPosition = camera) + state.uiSettings = MapUISettings(rotateGesture = false, tiltGesture = false) + + val restored = roundTrip(MapplsMapViewSaver().createSaver(), state) + + // 以前は styleName しか保存しておらず、id は default に戻っていた。 + assertEquals(design, restored.mapDesignType) + assertCommon(restored, "mappls-1") + } + + @Test + fun keepsPresetDesign() { + val state = MapplsViewState(mapDesignType = MapplsDesign.StandardDay, id = "mappls-2") + assertEquals(MapplsDesign.StandardDay, roundTrip(MapplsMapViewSaver().createSaver(), state).mapDesignType) + } + + private fun assertCommon(restored: com.mapconductor.core.map.MapViewStateInterface<*>, id: String) { + assertEquals(id, restored.id) + assertEquals(false, restored.uiSettings.rotateGesture) + assertEquals(false, restored.uiSettings.tiltGesture) + assertEquals(true, restored.uiSettings.scrollGesture) + assertEquals(12.0, restored.cameraPosition.zoom, 1e-9) + assertEquals(20.0, restored.cameraPosition.bearing, 1e-9) + assertEquals(21.38, restored.cameraPosition.position.latitude, 1e-9) + } + + private fun roundTrip( + saver: Saver, + value: T, + ): T { + val saved = with(saver) { SaverScope { true }.save(value) }!! + // 一度 Parcel に書いて読み戻す(プロセスが落ちたあとの復元と同じ経路)。 + val parcel = Parcel.obtain() + try { + parcel.writeBundle(saved) + parcel.setDataPosition(0) + return saver.restore(parcel.readBundle(javaClass.classLoader)!!)!! + } finally { + parcel.recycle() + } + } +} diff --git a/src/main/java/com/mapconductor/mappls/MapCameraPosition.kt b/src/main/java/com/mapconductor/mappls/MapCameraPosition.kt index fb61f11..f4c9a81 100644 --- a/src/main/java/com/mapconductor/mappls/MapCameraPosition.kt +++ b/src/main/java/com/mapconductor/mappls/MapCameraPosition.kt @@ -1,8 +1,11 @@ package com.mapconductor.mappls import com.mapconductor.core.features.GeoPoint +import com.mapconductor.core.map.CameraBearing import com.mapconductor.core.map.MapCameraPosition import com.mapconductor.core.map.MapCameraPositionInterface +import com.mapconductor.core.map.MapPaddings +import com.mapconductor.core.map.MapPaddingsInterface import com.mapconductor.core.spherical.Spherical import com.mapconductor.mappls.zoom.ZoomAltitudeConverter import com.mappls.sdk.maps.camera.CameraPosition @@ -11,19 +14,48 @@ import kotlin.math.cos import kotlin.math.tan private val converter = ZoomAltitudeConverter() + +/** + * Mappls のカメラの縦方向の視野角(度)。Mappls は MapLibre Native 派生で、既定値は地図の大きさに + * よらず一定(焦点距離 = 地図の高さ × 1.5)。TB520FU で 36.9° を実測。 + */ +internal const val MAPPLS_VERTICAL_FOV = 36.87 + +/** dp のパディング → Mappls の px のパディング(left, top, right, bottom)。 */ +internal fun MapPaddingsInterface.toMapplsPadding(density: Float): DoubleArray = + doubleArrayOf(left * density, top * density, right * density, bottom * density) + +/** Mappls の px のパディング(left, top, right, bottom)→ dp のパディング。 */ +internal fun DoubleArray.toMapPaddings(density: Float): MapPaddings? { + if (size < 4 || density <= 0f) return null + return MapPaddings( + top = this[1] / density, + left = this[0] / density, + bottom = this[3] / density, + right = this[2] / density, + ) +} + private const val NEGATIVE_TILT_TARGET_DISTANCE_SCALE = 1.83 private const val NEGATIVE_TILT_ZOOM_OFFSET_AT_MAX_TILT = -0.9 -fun MapCameraPosition.toCameraPosition(): CameraPosition { +fun MapCameraPosition.toCameraPosition(): CameraPosition = toCameraPosition(density = null) + +/** + * [density] があれば [MapCameraPosition.paddings] を Mappls のパディングとして渡す。 + * Mappls はパディングを除いた領域の中央にカメラの中心を置き、tilt の遠近もエンジンが解く。 + * Mappls のパディングは次に変えるまで残るので、null(未指定)のときは渡さない。 + */ +internal fun MapCameraPosition.toCameraPosition(density: Float?): CameraPosition { + val padding = if (density != null) paddings?.toMapplsPadding(density) else null if (tilt >= 0) { return CameraPosition .Builder() .target(GeoPoint.from(position).toLatLng()) .zoom(ZoomAltitudeConverter.googleZoomToMapplsZoom(zoom)) .tilt(tilt) - .bearing(bearing) - // TODO: -// .padding(paddings?.toEdgeInsects()) + .bearing(CameraBearing.toNativeHeading(bearing)) + .apply { padding?.let { padding(it) } } .build() } else { // tilt < 0: Mappls cannot represent an upward pitch directly. @@ -37,7 +69,7 @@ fun MapCameraPosition.toCameraPosition(): CameraPosition { cos(tiltAbsRad) * tan(tiltAbsRad) * NEGATIVE_TILT_TARGET_DISTANCE_SCALE - val target = Spherical.computeOffset(position, distanceForward, bearing) + val target = Spherical.computeOffset(position, distanceForward, CameraBearing.toNativeHeading(bearing)) val adjustedZoom = zoom + NEGATIVE_TILT_ZOOM_OFFSET_AT_MAX_TILT * (tiltAbsDeg / 60.0) return CameraPosition @@ -45,9 +77,8 @@ fun MapCameraPosition.toCameraPosition(): CameraPosition { .target(target.toLatLng()) .zoom(ZoomAltitudeConverter.googleZoomToMapplsZoom(adjustedZoom)) .tilt(tiltAbsDeg) - .bearing(bearing) - // TODO: -// .padding(paddings?.toEdgeInsects()) + .bearing(CameraBearing.toNativeHeading(bearing)) + .apply { padding?.let { padding(it) } } .build() } } @@ -61,7 +92,9 @@ fun MapCameraPosition.Companion.from(cameraPosition: MapCameraPositionInterface) zoom = cameraPosition.zoom, bearing = cameraPosition.bearing, tilt = cameraPosition.tilt, + paddings = cameraPosition.paddings, visibleRegion = cameraPosition.visibleRegion, + fov = cameraPosition.fov, ) } @@ -70,11 +103,20 @@ fun CameraPosition.toMapCameraPosition() = toMapCameraPosition(logicalTiltHint = internal data class MapplsCameraStateSnapshot( val cameraPosition: CameraPosition, val logicalTiltHint: Double?, + val density: Float? = null, ) { - fun toMapCameraPosition(): MapCameraPosition = cameraPosition.toMapCameraPosition(logicalTiltHint) + fun toMapCameraPosition(): MapCameraPosition = cameraPosition.toMapCameraPosition(logicalTiltHint, density) } -internal fun CameraPosition.toMapCameraPosition(logicalTiltHint: Double?): MapCameraPosition { +internal fun CameraPosition.toMapCameraPosition(logicalTiltHint: Double?): MapCameraPosition = + toMapCameraPosition(logicalTiltHint, density = null) + +/** [density] があれば Mappls のパディングを dp に直して paddings として返す。 */ +internal fun CameraPosition.toMapCameraPosition( + logicalTiltHint: Double?, + density: Float?, +): MapCameraPosition { + val paddings = density?.let { d -> padding?.toMapPaddings(d) } ?: MapPaddings.Zeros val pitch = tilt val pitchAbsDeg = abs(pitch).coerceIn(0.0, 60.0) @@ -82,9 +124,11 @@ internal fun CameraPosition.toMapCameraPosition(logicalTiltHint: Double?): MapCa return MapCameraPosition( position = target?.toGeoPoint() ?: GeoPoint.fromLongLat(0.0, 0.0), zoom = ZoomAltitudeConverter.mapplsZoomToGoogleZoom(zoom), - bearing = bearing, + bearing = CameraBearing.bearingFromNativeHeading(bearing), tilt = pitch, + paddings = paddings, visibleRegion = null, + fov = MAPPLS_VERTICAL_FOV, ) } @@ -104,8 +148,10 @@ internal fun CameraPosition.toMapCameraPosition(logicalTiltHint: Double?): MapCa return MapCameraPosition( position = originalPosition, zoom = originalGoogleZoom, - bearing = bear, + bearing = CameraBearing.bearingFromNativeHeading(bear), tilt = -pitchAbsDeg, + paddings = paddings, visibleRegion = null, + fov = MAPPLS_VERTICAL_FOV, ) } diff --git a/src/main/java/com/mapconductor/mappls/MapplsMapView.kt b/src/main/java/com/mapconductor/mappls/MapplsMapView.kt index 150f80e..77552ad 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsMapView.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsMapView.kt @@ -1,368 +1,391 @@ -package com.mapconductor.mappls - -import androidx.compose.runtime.Composable -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.ui.Modifier -import androidx.compose.ui.platform.LocalContext -import com.mapconductor.compose.map.MapViewBase -import com.mapconductor.core.OnCameraMoveHandler -import com.mapconductor.core.OnMapEventHandler -import com.mapconductor.core.OnMapLoadedHandler -import com.mapconductor.core.circle.CircleManager -import com.mapconductor.core.map.CameraRestriction -import com.mapconductor.core.map.MapCameraPositionInterface -import com.mapconductor.core.map.MutableMapServiceRegistry -import com.mapconductor.core.marker.MarkerEventControllerInterface -import com.mapconductor.core.marker.MarkerManager -import com.mapconductor.core.marker.MarkerOverlayRendererInterface -import com.mapconductor.core.marker.MarkerRenderingStrategyInterface -import com.mapconductor.core.marker.MarkerRenderingSupport -import com.mapconductor.core.marker.MarkerRenderingSupportKey -import com.mapconductor.core.marker.MarkerTilingOptions -import com.mapconductor.core.marker.StrategyMarkerController -import com.mapconductor.core.polygon.PolygonManager -import com.mapconductor.core.polyline.PolylineManager -import com.mapconductor.mappls.circle.MapplsCircleController -import com.mapconductor.mappls.circle.MapplsCircleLayer -import com.mapconductor.mappls.circle.MapplsCircleOverlayRenderer -import com.mapconductor.mappls.groundimage.MapplsGroundImageController -import com.mapconductor.mappls.groundimage.MapplsGroundImageOverlayRenderer -import com.mapconductor.mappls.marker.MapplsMarkerController -import com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer -import com.mapconductor.mappls.marker.MarkerDragLayer -import com.mapconductor.mappls.marker.MarkerLayer -import com.mapconductor.mappls.polygon.MapplsPolygonConductor -import com.mapconductor.mappls.polygon.MapplsPolygonLayer -import com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer -import com.mapconductor.mappls.polyline.MapplsPolylineController -import com.mapconductor.mappls.polyline.MapplsPolylineLayer -import com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer -import com.mapconductor.mappls.raster.MapplsRasterLayerController -import com.mapconductor.mappls.raster.MapplsRasterLayerOverlayRenderer -import com.mappls.sdk.maps.MapView -import com.mappls.sdk.maps.Mappls -import com.mappls.sdk.maps.MapplsMap -import com.mappls.sdk.maps.MapplsMapOptions -import com.mappls.sdk.maps.OnMapReadyCallback -import com.mappls.sdk.maps.Style -import android.app.Activity -import android.content.Context -import android.content.ContextWrapper -import android.util.Log -import kotlinx.coroutines.suspendCancellableCoroutine - -@Composable -fun MapplsMapView( - state: MapplsViewState, - modifier: Modifier = Modifier, - markerTiling: MarkerTilingOptions? = null, - cameraRestriction: CameraRestriction? = null, - sdkInitialize: (suspend (Context) -> Boolean)? = null, - onMapLoaded: OnMapLoadedHandler? = null, - onMapClick: OnMapEventHandler? = null, - onMapLongClick: OnMapEventHandler? = null, - onCameraMoveStart: OnCameraMoveHandler? = null, - onCameraMove: OnCameraMoveHandler? = null, - onCameraMoveEnd: OnCameraMoveHandler? = null, - content: (@Composable MapplsMapViewScope.() -> Unit)? = null, -) { - val context = LocalContext.current - val scope = remember { MapplsMapViewScope() } - val registry = remember { scope.buildRegistry() } - val cameraState = remember { mutableStateOf(state.cameraPosition) } - - MapViewBase( - state = state, - cameraState = cameraState, - modifier = modifier, - viewProvider = { - val cameraPosition = - state.cameraPosition.toCameraPosition() - val mapInitOptions = - MapplsMapOptions - .createFromAttributes(context) - .camera(cameraPosition) - .textureMode(true) - // Don't set style here - it will be set in holderProvider - - MapView(context, mapInitOptions) - }, - scope = scope, - registry = registry, - onMapLoaded = onMapLoaded, - holderProvider = { mapView -> - suspendCancellableCoroutine { continuation -> - mapView.getMapAsync( - object : OnMapReadyCallback { - override fun onMapReady(map: MapplsMap) { - // 認証が通ると SDK がアカウントの既定スタイルを読み込む。 - // 名前指定があればそのスタイルへ差し替え、読み込み完了後に resume する。 - val designName = state.mapDesignType.styleName - if (designName.isEmpty()) { - map.getStyle { - continuation.resume( - MapplsMapViewHolder(mapView, map), - ) { _, _, _ -> } - } - } else { - map.setMapplsStyle( - designName, - Style.OnStyleLoaded { - continuation.resume( - MapplsMapViewHolder(mapView, map), - ) { _, _, _ -> } - }, - ) - } - } - - override fun onMapError( - code: Int, - message: String?, - ) { - // 認証エラー(コンフィグファイル不一致など)はここへ来る。 - // resume しないので地図は表示されないまま — ログで原因を残す。 - Log.e("Mappls", "Map init error $code: $message") - } - }, - ) - } - }, - controllerProvider = { holder -> - createMapplsViewController( - holder = holder, - markerTiling = markerTiling ?: MarkerTilingOptions.Default, - serviceRegistry = state.serviceRegistry, - ).also { mapController -> - // Store controller reference in holder - mapController.setCameraMoveStartListener { - cameraState.value = it - state.updateCameraPosition(it) - onCameraMoveStart?.invoke(it) - } - mapController.setCameraMoveListener { - cameraState.value = it - state.updateCameraPosition(it) - onCameraMove?.invoke(it) - } - mapController.setCameraMoveEndListener { - cameraState.value = it - state.updateCameraPosition(it) - onCameraMoveEnd?.invoke(it) - } - mapController.setMapClickListener(onMapClick) - mapController.setMapDesignTypeChangeListener(state::onMapDesignTypeChange) - mapController.setMapLongClickListener(onMapLongClick) - cameraRestriction?.let { mapController.setCameraRestriction(it) } - state.setController(mapController) - // Post an initial camera update after layout to compute visibleRegion correctly - holder.mapView.post { mapController.sendInitialCameraUpdate() } - } - }, - sdkInitialize = { - // 外部タイルのホワイトリスト回避(MapplsHttpBridge のコメント参照)は - // 地図生成前に必ず入れる。sdkInitialize を差し替えられても失われないよう - // ここで無条件に呼ぶ。 - MapplsHttpBridge.install() - if (sdkInitialize != null) { - sdkInitialize(context) - } else { - Mappls.getInstance(context) - true - } - }, - // Pass content if it needs to be rendered within the overlay providers in MapViewBase, - // or handle it here if it's specific to MapplsMapView structure before calling MapViewBase. - // For now, assuming content relates to overlay definitions. - content = content, // This might need adjustment based on how overlays are handled - ) -} - -/** - * Creates the imperative controller graph used by both the Compose MapView and non-Compose hosts - * such as React Native. Keeping this construction here prevents provider-specific layer setup from - * being duplicated by each UI integration. - * - * @param serviceRegistry 登録先のサービスレジストリ。Compose からは `state.serviceRegistry` を渡す - * (react-sdk / ios-sdk と同じく持ち主は state)。React Native / Cordova のような非 Compose - * ホストは state を持たないので、自前のレジストリを渡す。 - */ -fun createMapplsViewController( - holder: MapplsMapViewHolderInterface, - markerTiling: MarkerTilingOptions = MarkerTilingOptions.Default, - serviceRegistry: MutableMapServiceRegistry? = null, -): MapplsViewController { - // 非 Compose ホスト(React Native / Cordova)はこちらが入口なので、ここでも入れる - MapplsHttpBridge.install() - val markerController = getMarkerController(holder, markerTiling) - val mapController = - MapplsViewController( - holder = holder, - markerController = markerController, - polylineController = getPolylineController(holder), - polygonController = getPolygonController(holder), - groundImageController = getGroundImageController(holder), - circleController = getCircleController(holder), - rasterLayerController = getRasterLayerController(holder), - ) - - serviceRegistry?.let { registry -> - MapplsCapabilities.declare(registry) - registry.put( - MarkerRenderingSupportKey, - object : MarkerRenderingSupport { - override fun createMarkerRenderer( - strategy: MarkerRenderingStrategyInterface, - ): MarkerOverlayRendererInterface = mapController.createMarkerRenderer(strategy) - - override fun createMarkerEventController( - controller: StrategyMarkerController, - renderer: MarkerOverlayRendererInterface, - ): MarkerEventControllerInterface = - mapController.createMarkerEventController(controller, renderer) - - override fun registerMarkerEventController( - controller: MarkerEventControllerInterface, - ) { - mapController.registerMarkerEventController(controller) - } - - override fun onMarkerRenderingReady() { - mapController.sendInitialCameraUpdate() - } - }, - ) - } - return mapController -} - -fun getMarkerController( - holder: MapplsMapViewHolderInterface, - markerTiling: MarkerTilingOptions, -): MapplsMarkerController { - val manager = MarkerManager.defaultManager() - val markerLayer = - MarkerLayer( - sourceId = "markers-source", - layerId = "markers-layer", - ) - val dragLayer = - MarkerDragLayer( - sourceId = "marker-drag-source", - layerId = "marker-drag-layer", - ) - val renderer = - MapplsMarkerOverlayRenderer( - holder = holder, - markerLayer = markerLayer, - dragLayer = dragLayer, - markerManager = manager, - ) - - val controller = - MapplsMarkerController( - renderer = renderer, - markerTiling = markerTiling, - ) - return controller -} - -fun getPolylineController(holder: MapplsMapViewHolderInterface): MapplsPolylineController { - val polylineLayer = - MapplsPolylineLayer( - sourceId = "polyline-source", - layerId = "polyline-layer", - ) - val polylineManager = PolylineManager() - - val renderer = - MapplsPolylineOverlayRenderer( - layer = polylineLayer, - polylineManager = polylineManager, - holder = holder, - ) - - val controller = - MapplsPolylineController( - renderer = renderer, - ) - return controller -} - -fun getPolygonController(holder: MapplsMapViewHolderInterface): MapplsPolygonConductor { - val polylineLayer = - MapplsPolylineLayer( - sourceId = "polygon-outline-source", - layerId = "polygon-outline-layer", - ) - val polylineManager = PolylineManager() - val polylineOverlayRenderer = - MapplsPolylineOverlayRenderer( - layer = polylineLayer, - polylineManager = polylineManager, - holder = holder, - ) - - val polygonManager = PolygonManager() - val polygonLayer = - MapplsPolygonLayer( - sourceId = "polygon-fill-source", - layerId = "polygon-fill-layer", - ) - val polygonOverlayRenderer = - MapplsPolygonOverlayRenderer( - layer = polygonLayer, - polygonManager = polygonManager, - holder = holder, - ) - - return MapplsPolygonConductor( - polygonOverlay = polygonOverlayRenderer, - polylineOverlay = polylineOverlayRenderer, - ) -} - -fun getCircleController(holder: MapplsMapViewHolderInterface): MapplsCircleController { - val circleLayer = - MapplsCircleLayer( - sourceId = "circle-source", - layerId = "circle-layer", - ) - val circleManager = CircleManager() - val renderer = - MapplsCircleOverlayRenderer( - layer = circleLayer, - circleManager = circleManager, - holder = holder, - ) - return MapplsCircleController( - renderer = renderer, - circleManager = circleManager, - ) -} - -fun getRasterLayerController(holder: MapplsMapViewHolderInterface): MapplsRasterLayerController { - val renderer = - MapplsRasterLayerOverlayRenderer( - holder = holder, - ) - return MapplsRasterLayerController( - renderer = renderer, - ) -} - -fun getGroundImageController(holder: MapplsMapViewHolderInterface): MapplsGroundImageController { - val renderer = - MapplsGroundImageOverlayRenderer( - holder = holder, - ) - return MapplsGroundImageController(renderer = renderer) -} - -internal fun Context.findActivity(): Activity? = - when (this) { - is Activity -> this - is ContextWrapper -> baseContext.findActivity() - else -> null - } +package com.mapconductor.mappls + +import androidx.compose.runtime.Composable +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext +import com.mapconductor.compose.map.MapViewBase +import com.mapconductor.core.OnCameraMoveHandler +import com.mapconductor.core.OnMapEventHandler +import com.mapconductor.core.OnMapLoadedHandler +import com.mapconductor.core.circle.CircleManager +import com.mapconductor.core.map.CameraRestriction +import com.mapconductor.core.map.MapCameraPositionInterface +import com.mapconductor.core.map.MapPaddings +import com.mapconductor.core.map.MapViewStyle +import com.mapconductor.core.map.MutableMapServiceRegistry +import com.mapconductor.core.marker.MarkerEventControllerInterface +import com.mapconductor.core.marker.MarkerManager +import com.mapconductor.core.marker.MarkerOverlayRendererInterface +import com.mapconductor.core.marker.MarkerRenderingStrategyInterface +import com.mapconductor.core.marker.MarkerRenderingSupport +import com.mapconductor.core.marker.MarkerRenderingSupportKey +import com.mapconductor.core.marker.MarkerTilingOptions +import com.mapconductor.core.marker.StrategyMarkerController +import com.mapconductor.core.polygon.PolygonManager +import com.mapconductor.core.polyline.PolylineManager +import com.mapconductor.mappls.circle.MapplsCircleController +import com.mapconductor.mappls.circle.MapplsCircleLayer +import com.mapconductor.mappls.circle.MapplsCircleOverlayRenderer +import com.mapconductor.mappls.groundimage.MapplsGroundImageController +import com.mapconductor.mappls.groundimage.MapplsGroundImageOverlayRenderer +import com.mapconductor.mappls.marker.MapplsMarkerController +import com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer +import com.mapconductor.mappls.marker.MarkerDragLayer +import com.mapconductor.mappls.marker.MarkerLayer +import com.mapconductor.mappls.polygon.MapplsPolygonCompositeRenderer +import com.mapconductor.mappls.polygon.MapplsPolygonController +import com.mapconductor.mappls.polygon.MapplsPolygonLayer +import com.mapconductor.mappls.polygon.MapplsPolygonOverlayRenderer +import com.mapconductor.mappls.polyline.MapplsPolylineController +import com.mapconductor.mappls.polyline.MapplsPolylineLayer +import com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer +import com.mapconductor.mappls.raster.MapplsRasterLayerController +import com.mapconductor.mappls.raster.MapplsRasterLayerOverlayRenderer +import com.mappls.sdk.maps.MapView +import com.mappls.sdk.maps.Mappls +import com.mappls.sdk.maps.MapplsMap +import com.mappls.sdk.maps.MapplsMapOptions +import com.mappls.sdk.maps.OnMapReadyCallback +import com.mappls.sdk.maps.Style +import android.app.Activity +import android.content.Context +import android.content.ContextWrapper +import android.util.Log +import kotlinx.coroutines.suspendCancellableCoroutine + +@Composable +fun MapplsMapView( + state: MapplsViewState, + modifier: Modifier = Modifier, + markerTiling: MarkerTilingOptions? = null, + cameraRestriction: CameraRestriction? = null, + sdkInitialize: (suspend (Context) -> Boolean)? = null, + onMapLoaded: OnMapLoadedHandler? = null, + onMapClick: OnMapEventHandler? = null, + onMapLongClick: OnMapEventHandler? = null, + onCameraMoveStart: OnCameraMoveHandler? = null, + onCameraMove: OnCameraMoveHandler? = null, + onCameraMoveEnd: OnCameraMoveHandler? = null, + /** + * How the map looks, when the app states it rather than naming a design. + * + * A vector style *is* the basemap. `com.mapconductor:vectorstyle` builds + * one; what happens underneath depends on this backend and the app does + * not have to know. + */ + style: MapViewStyle? = null, + onStyleDiagnostics: ((List) -> Unit)? = null, + content: (@Composable MapplsMapViewScope.() -> Unit)? = null, +) { + val context = LocalContext.current + val scope = remember { MapplsMapViewScope() } + val registry = remember { scope.buildRegistry() } + val cameraState = remember { mutableStateOf(state.cameraPosition) } + + MapViewBase( + state = state, + cameraState = cameraState, + modifier = modifier, + viewProvider = { + val cameraPosition = + // パディングはネイティブに渡さない。接続時の moveCamera が中心のずらしで適用する。 + state.cameraPosition.copy(paddings = MapPaddings.Zeros).toCameraPosition(context.resources.displayMetrics.density) + val mapInitOptions = + MapplsMapOptions + .createFromAttributes(context) + .camera(cameraPosition) + .textureMode(true) + // Don't set style here - it will be set in holderProvider + + MapView(context, mapInitOptions) + }, + scope = scope, + registry = registry, + onMapLoaded = onMapLoaded, + holderProvider = { mapView -> + suspendCancellableCoroutine { continuation -> + mapView.getMapAsync( + object : OnMapReadyCallback { + override fun onMapReady(map: MapplsMap) { + // 認証が通ると SDK がアカウントの既定スタイルを読み込む。 + // 名前指定があればそのスタイルへ差し替え、読み込み完了後に resume する。 + val designName = state.mapDesignType.styleName + if (designName.isEmpty()) { + map.getStyle { + continuation.resume( + MapplsMapViewHolder(mapView, map), + ) { _, _, _ -> } + } + } else { + map.setMapplsStyle( + designName, + Style.OnStyleLoaded { + continuation.resume( + MapplsMapViewHolder(mapView, map), + ) { _, _, _ -> } + }, + ) + } + } + + override fun onMapError( + code: Int, + message: String?, + ) { + // 認証エラー(コンフィグファイル不一致など)はここへ来る。 + // resume しないので地図は表示されないまま — ログで原因を残す。 + Log.e("Mappls", "Map init error $code: $message") + } + }, + ) + } + }, + controllerProvider = { holder -> + createMapplsViewController( + holder = holder, + markerTiling = markerTiling ?: MarkerTilingOptions.Default, + serviceRegistry = state.serviceRegistry, + ).also { mapController -> + // Store controller reference in holder + mapController.setCameraMoveStartListener { + cameraState.value = it + state.updateCameraPosition(it) + onCameraMoveStart?.invoke(it) + } + mapController.setCameraMoveListener { + cameraState.value = it + state.updateCameraPosition(it) + onCameraMove?.invoke(it) + } + mapController.setCameraMoveEndListener { + cameraState.value = it + state.updateCameraPosition(it) + onCameraMoveEnd?.invoke(it) + } + mapController.setMapClickListener(onMapClick) + mapController.setMapDesignTypeChangeListener(state::onMapDesignTypeChange) + mapController.setMapLongClickListener(onMapLongClick) + cameraRestriction?.let { mapController.setCameraRestriction(it) } + state.setController(mapController) + // Post an initial camera update after layout to compute visibleRegion correctly + holder.mapView.post { mapController.sendInitialCameraUpdate() } + } + }, + sdkInitialize = { + // 外部タイルのホワイトリスト回避(MapplsHttpBridge のコメント参照)は + // 地図生成前に必ず入れる。sdkInitialize を差し替えられても失われないよう + // ここで無条件に呼ぶ。 + MapplsHttpBridge.install() + if (sdkInitialize != null) { + sdkInitialize(context) + } else { + Mappls.getInstance(context) + true + } + }, + // Pass content if it needs to be rendered within the overlay providers in MapViewBase, + // or handle it here if it's specific to MapplsMapView structure before calling MapViewBase. + // For now, assuming content relates to overlay definitions. + style = style, + onStyleDiagnostics = onStyleDiagnostics, + // Never started (onStart is not called), so it is not stopped either -- + // MapView.onStop() would deactivate the shared FileSource the next map + // still uses. Destroying it ends the render thread, whose camera + // listeners otherwise keep the controller and every overlay alive. + onDestroyMapView = { mapView -> mapView.onDestroy() }, + content = content, // This might need adjustment based on how overlays are handled + ) +} + +/** + * Creates the imperative controller graph used by both the Compose MapView and non-Compose hosts + * such as React Native. Keeping this construction here prevents provider-specific layer setup from + * being duplicated by each UI integration. + * + * @param serviceRegistry 登録先のサービスレジストリ。Compose からは `state.serviceRegistry` を渡す + * (react-sdk / ios-sdk と同じく持ち主は state)。React Native / Cordova のような非 Compose + * ホストは state を持たないので、自前のレジストリを渡す。 + */ +fun createMapplsViewController( + holder: MapplsMapViewHolderInterface, + markerTiling: MarkerTilingOptions = MarkerTilingOptions.Default, + serviceRegistry: MutableMapServiceRegistry? = null, +): MapplsViewController { + // 非 Compose ホスト(React Native / Cordova)はこちらが入口なので、ここでも入れる + MapplsHttpBridge.install() + val markerController = getMarkerController(holder, markerTiling) + val mapController = + MapplsViewController( + holder = holder, + markerController = markerController, + polylineController = getPolylineController(holder), + polygonController = getPolygonController(holder), + groundImageController = getGroundImageController(holder), + circleController = getCircleController(holder), + rasterLayerController = getRasterLayerController(holder), + ) + + serviceRegistry?.let { registry -> + MapplsCapabilities.declare(registry) + registry.put( + MarkerRenderingSupportKey, + object : MarkerRenderingSupport { + override fun createMarkerRenderer( + strategy: MarkerRenderingStrategyInterface, + ): MarkerOverlayRendererInterface = mapController.createMarkerRenderer(strategy) + + override fun createMarkerEventController( + controller: StrategyMarkerController, + renderer: MarkerOverlayRendererInterface, + ): MarkerEventControllerInterface = + mapController.createMarkerEventController(controller, renderer) + + override fun registerMarkerEventController( + controller: MarkerEventControllerInterface, + ) { + mapController.registerMarkerEventController(controller) + } + + override fun onMarkerRenderingReady() { + mapController.sendInitialCameraUpdate() + } + }, + ) + } + return mapController +} + +fun getMarkerController( + holder: MapplsMapViewHolderInterface, + markerTiling: MarkerTilingOptions, +): MapplsMarkerController { + val manager = MarkerManager.defaultManager() + val markerLayer = + MarkerLayer( + sourceId = "markers-source", + layerId = "markers-layer", + ) + val dragLayer = + MarkerDragLayer( + sourceId = "marker-drag-source", + layerId = "marker-drag-layer", + ) + val renderer = + MapplsMarkerOverlayRenderer( + holder = holder, + markerLayer = markerLayer, + dragLayer = dragLayer, + markerManager = manager, + ) + + val controller = + MapplsMarkerController( + renderer = renderer, + markerTiling = markerTiling, + ) + return controller +} + +fun getPolylineController(holder: MapplsMapViewHolderInterface): MapplsPolylineController { + val polylineLayer = + MapplsPolylineLayer( + sourceId = "polyline-source", + layerId = "polyline-layer", + ) + val polylineManager = PolylineManager() + + val renderer = + MapplsPolylineOverlayRenderer( + layer = polylineLayer, + polylineManager = polylineManager, + holder = holder, + ) + + val controller = + MapplsPolylineController( + renderer = renderer, + ) + return controller +} + +fun getPolygonController(holder: MapplsMapViewHolderInterface): MapplsPolygonController { + val polylineLayer = + MapplsPolylineLayer( + sourceId = "polygon-outline-source", + layerId = "polygon-outline-layer", + ) + val polylineManager = PolylineManager() + val polylineOverlayRenderer = + MapplsPolylineOverlayRenderer( + layer = polylineLayer, + polylineManager = polylineManager, + holder = holder, + ) + + val polygonManager = PolygonManager() + val polygonLayer = + MapplsPolygonLayer( + sourceId = "polygon-fill-source", + layerId = "polygon-fill-layer", + ) + val polygonOverlayRenderer = + MapplsPolygonOverlayRenderer( + layer = polygonLayer, + polygonManager = polygonManager, + holder = holder, + ) + + return MapplsPolygonController( + renderer = + MapplsPolygonCompositeRenderer( + fill = polygonOverlayRenderer, + outline = polylineOverlayRenderer, + ), + ) +} + +fun getCircleController(holder: MapplsMapViewHolderInterface): MapplsCircleController { + val circleLayer = + MapplsCircleLayer( + sourceId = "circle-source", + layerId = "circle-layer", + ) + val circleManager = CircleManager() + val renderer = + MapplsCircleOverlayRenderer( + layer = circleLayer, + circleManager = circleManager, + holder = holder, + ) + return MapplsCircleController( + renderer = renderer, + circleManager = circleManager, + ) +} + +fun getRasterLayerController(holder: MapplsMapViewHolderInterface): MapplsRasterLayerController { + val renderer = + MapplsRasterLayerOverlayRenderer( + holder = holder, + ) + return MapplsRasterLayerController( + renderer = renderer, + ) +} + +fun getGroundImageController(holder: MapplsMapViewHolderInterface): MapplsGroundImageController { + val renderer = + MapplsGroundImageOverlayRenderer( + holder = holder, + ) + return MapplsGroundImageController(renderer = renderer) +} + +internal fun Context.findActivity(): Activity? = + when (this) { + is Activity -> this + is ContextWrapper -> baseContext.findActivity() + else -> null + } diff --git a/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt b/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt new file mode 100644 index 0000000..46c0ec8 --- /dev/null +++ b/src/main/java/com/mapconductor/mappls/MapplsOverlayStacking.kt @@ -0,0 +1,96 @@ +package com.mapconductor.mappls + +import android.util.Log +import com.mapconductor.core.controller.OverlayKind +import com.mapconductor.core.controller.OverlayLayerStack +import com.mapconductor.core.controller.OverlayStacking +import com.mappls.sdk.maps.MapplsMap +import com.mappls.sdk.maps.Style +import com.mappls.sdk.maps.style.layers.Layer +import com.mappls.sdk.maps.style.layers.SymbolLayer +import java.util.WeakHashMap + +/** + * オーバーレイの層をスタイルのどこへ入れるか([OverlayStacking] の帯の順)。 + * + * 下から: ラスター < GroundImage < ポリゴン < サークル < ポリライン < マーカー + * (マーカーのタイルはマーカーの帯の一番下、ドラッグ中の層は一番上。 + * ポリゴンのタイルはポリゴンの帯の一番下)。 + * + * 位置は毎回スタイルの今の並びから決めるので、追加した順・送り直し・ + * スタイルの読み直し(デザイン変更)に左右されない。 + * + * ラスターだけはベースマップのラベル(SDK の層でない最初の symbol 層)の下に入れる。 + * それ以外の帯はラベルの上に乗る(従来どおり)。 + */ +internal object MapplsOverlayStacking { + private val stacks = WeakHashMap() + + fun stackOf(map: MapplsMap): OverlayLayerStack = synchronized(stacks) { stacks.getOrPut(map) { OverlayLayerStack() } } + + fun key( + kind: OverlayKind, + zIndex: Int = 0, + ) = OverlayStacking.Key(kind, zIndex) + + /** マーカーのタイル(ラスター): マーカーの帯の一番下。 */ + val MARKER_TILE = key(OverlayKind.Marker, Int.MIN_VALUE) + + /** ポリゴンのタイル(ラスター): ポリゴンの帯の一番下。 */ + val POLYGON_TILE = key(OverlayKind.Polygon, Int.MIN_VALUE) + + /** 円のタイル(ラスター): サークルの帯の一番下(ポリゴンの上、ネイティブの円とポリラインのタイルの下)。 */ + val CIRCLE_TILE = key(OverlayKind.Circle, Int.MIN_VALUE) + + /** ポリラインのタイル(ラスター): ポリラインの帯の一番下(サークルの上、ネイティブのポリラインの下)。 */ + val POLYLINE_TILE = key(OverlayKind.Polyline, Int.MIN_VALUE) + + /** ドラッグ中のマーカーの層: マーカーの帯の一番上。 */ + val MARKER_DRAG = key(OverlayKind.Marker, Int.MAX_VALUE) + + /** + * [layer] を [key] の位置へ足す。同じ id の層が既にあれば何もしない + * (位置を変えたいときは先に [remove] する)。 + */ + fun add( + map: MapplsMap, + style: Style, + layer: Layer, + key: OverlayStacking.Key, + ) { + val stack = stackOf(map) + stack.put(layer.id, key) + if (style.getLayer(layer.id) != null) return + val layers = style.layers + val ids = layers.map { it.id } + var before = stack.beforeId(ids, key) + if (key.kind == OverlayKind.RasterLayer) { + val label = layers.firstOrNull { it is SymbolLayer && stack.keyOf(it.id) == null }?.id + if (label != null && (before == null || ids.indexOf(label) < ids.indexOf(before))) { + before = label + } + } + try { + if (before != null) style.addLayerBelow(layer, before) else style.addLayer(layer) + } catch (e: Exception) { + if (style.getLayer(layer.id) != null) return + try { + style.addLayer(layer) + } catch (e2: Exception) { + Log.w("Mappls", "Failed to add layer: ${layer.id} (${e2.message})") + } + } + } + + fun remove( + map: MapplsMap, + style: Style?, + layerId: String, + ) { + stackOf(map).remove(layerId) + try { + style?.removeLayer(layerId) + } catch (_: Exception) { + } + } +} diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt index e14a612..38a6b87 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewController.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewController.kt @@ -1,390 +1,438 @@ -package com.mapconductor.mappls - -import com.mapconductor.core.circle.OnCircleEventHandler -import com.mapconductor.core.controller.BaseMapViewController -import com.mapconductor.core.features.GeoPointInterface -import com.mapconductor.core.features.GeoRectBounds -import com.mapconductor.core.groundimage.OnGroundImageEventHandler -import com.mapconductor.core.map.CameraRestriction -import com.mapconductor.core.map.MapCameraPosition -import com.mapconductor.core.map.MapUISettings -import com.mapconductor.core.marker.DefaultMarkerEventController -import com.mapconductor.core.marker.MarkerAnimationOverlayHost -import com.mapconductor.core.marker.MarkerEventControllerInterface -import com.mapconductor.core.marker.MarkerOverlayRendererInterface -import com.mapconductor.core.marker.MarkerRenderingStrategyInterface -import com.mapconductor.core.marker.OnMarkerEventHandler -import com.mapconductor.core.marker.StrategyMarkerController -import com.mapconductor.core.marker.dispatchGeoMarkerClick -import com.mapconductor.core.polygon.OnPolygonEventHandler -import com.mapconductor.core.polygon.PolygonState -import com.mapconductor.core.polyline.OnPolylineEventHandler -import com.mapconductor.mappls.circle.MapplsCircleController -import com.mapconductor.mappls.groundimage.MapplsGroundImageController -import com.mapconductor.mappls.marker.MapplsMarkerController -import com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer -import com.mapconductor.mappls.marker.MarkerDragLayer -import com.mapconductor.mappls.marker.MarkerLayer -import com.mapconductor.mappls.polygon.MapplsPolygonConductor -import com.mapconductor.mappls.polyline.MapplsPolylineController -import com.mapconductor.mappls.raster.MapplsRasterLayerController -import com.mappls.sdk.gestures.MoveGestureDetector -import com.mappls.sdk.maps.MapplsMap -import com.mappls.sdk.maps.Style -import com.mappls.sdk.maps.geometry.LatLng -import com.mappls.sdk.maps.style.OnStyleLoadListener -import java.util.UUID -import android.annotation.SuppressLint -import android.util.Log -import android.view.View -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.launch - -typealias MapplsDesignTypeChangeHandler = (MapplsMapDesignTypeInterface) -> Unit - -class MapplsViewController( - override val holder: MapplsMapViewHolderInterface, - internal val markerController: MapplsMarkerController, - internal val polylineController: MapplsPolylineController, - internal val polygonController: MapplsPolygonConductor, - internal val groundImageController: MapplsGroundImageController, - internal val circleController: MapplsCircleController, - internal val rasterLayerController: MapplsRasterLayerController, - override val mainCoroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), - override val defaultCoroutine: CoroutineScope = CoroutineScope(Dispatchers.Default), -) : BaseMapViewController(), - MapplsViewControllerInterface, - MapplsMap.OnMapClickListener, - MapplsMap.OnMapLongClickListener, - MapplsMap.OnMoveListener, - MapplsMap.OnCameraMoveListener, - MapplsMap.OnCameraIdleListener { - // Keep reference to the style instance to avoid getting a new one - internal var styleInstance: Style? = null - internal var wasScrollEnabledBeforeDrag: Boolean? = null - internal var dragTouchInterceptor: View.OnTouchListener? = null - internal val polygonZLayers: MutableSet = mutableSetOf() - internal val markerEventControllers = mutableListOf>() - internal var activeDragController: DefaultMarkerEventController? = null - internal var markerClickListener: OnMarkerEventHandler? = null - internal var markerDragStartListener: OnMarkerEventHandler? = null - internal var markerDragListener: OnMarkerEventHandler? = null - internal var markerDragEndListener: OnMarkerEventHandler? = null - internal var markerAnimateStartListener: OnMarkerEventHandler? = null - internal var markerAnimateEndListener: OnMarkerEventHandler? = null - - internal var lastLogicalCameraPosition: MapCameraPosition? = null - - init { - // Style should already be loaded by holderProvider - val style = holder.map.style - if (style != null) { - setupStyle(style) - // Trigger initial camera update after style is ready - sendInitialCameraUpdate() - } - - setupListeners() - registerOverlayController(markerController) - registerOverlayController(polylineController) - registerOverlayController(polygonController) - registerOverlayController(groundImageController) - registerOverlayController(circleController) - registerOverlayController(rasterLayerController) - registerMarkerEventController(DefaultMarkerEventController(markerController)) - - markerController.setRasterLayerCallback { state -> - if (state != null) { - rasterLayerController.upsert(state) - } else { - val markerTileLayers = - rasterLayerController.rasterLayerManager - .allEntities() - .filter { it.state.id.startsWith("marker-tile-") } - markerTileLayers.forEach { entity -> rasterLayerController.removeById(entity.state.id) } - } - } - } - - fun setupListeners() { - holder.map.addOnCameraMoveListener(this) - holder.map.addOnCameraIdleListener(this) - - holder.map.removeOnMapClickListener(this) - holder.map.addOnMapClickListener(this) - - holder.map.removeOnMapLongClickListener(this) - holder.map.addOnMapLongClickListener(this) - - holder.map.removeOnMoveListener(this) - holder.map.addOnMoveListener(this) - } - - override suspend fun clearOverlays() { - markerController.clear() - polylineController.clear() - polygonController.clear() - groundImageController.clear() - circleController.clear() - rasterLayerController.clear() - } - - override fun moveCamera(position: MapCameraPosition) = handleMoveCamera(position) - - override fun animateCamera( - position: MapCameraPosition, - duration: Long, - ) = handleAnimateCamera(position, duration) - - override fun fitBounds( - bounds: GeoRectBounds, - padding: Int, - ) = handleFitBounds(bounds, padding) - - override fun setCameraRestriction(restriction: CameraRestriction?) = handleCameraRestriction(restriction) - - override fun applyUISettings(settings: MapUISettings) { - // Mappls の getUiSettings() は @Nullable(MapLibre との差分) - holder.map.uiSettings?.apply { - isScrollGesturesEnabled = settings.scrollGesture - isZoomGesturesEnabled = settings.zoomGesture - isRotateGesturesEnabled = settings.rotateGesture - isTiltGesturesEnabled = settings.tiltGesture - } - } - - // Provide access to the style instance - fun getStyleInstance(): Style? = styleInstance - - private var mapDesignTypeChangeListener: MapplsDesignTypeChangeHandler? = null - - override fun setMapDesignType(value: MapplsMapDesignTypeInterface) { - mainCoroutine.launch { - // 空文字は「アカウントの既定スタイル」。既に既定が載っているので何もしない - // (setMapplsStyle("") は無効なスタイル名として弾かれる)。 - if (value.styleName.isEmpty()) return@launch - holder.map.setMapplsStyle( - value.styleName, - object : OnStyleLoadListener { - override fun onStyleLoaded(newStyle: Style) { - Log.d("Mappls", "Style changed to ${value.styleName}") - setupStyle(newStyle) - } - - override fun onError(message: String?) { - // スタイル名はアカウント紐付き。存在しない名前はここへ来る - Log.w("Mappls", "setMapplsStyle(${value.styleName}) failed: $message") - } - }, - ) - } - } - - fun sendInitialCameraUpdate() { - mainCoroutine.launch { - notifyMapInitialized() - val mapWidth = holder.mapView.width.toFloat() - val mapHeight = holder.mapView.height.toFloat() - if (mapWidth <= 0 || mapHeight <= 0) return@launch - - val camera = readLogicalCameraPosition() - getMapCameraPosition(camera)?.let { mapCameraPosition -> - defaultCoroutine.launch { notifyMapCameraPosition(mapCameraPosition) } - } - } - } - - override fun setMapDesignTypeChangeListener(listener: MapplsDesignTypeChangeHandler) { - mapDesignTypeChangeListener = listener - // Don't call listener immediately - it may trigger style reload - // listener(mapDesignType) - } - - override fun setMarkerAnimationOverlayHost(host: MarkerAnimationOverlayHost?) { - (markerController.renderer as MapplsMarkerOverlayRenderer).animationOverlayHost = host - } - - override suspend fun compositionPolygons(data: List) { - polygonController.add(data) - getStyleInstance()?.let { ensurePolygonZLayers(it) } - } - - override suspend fun updatePolygon(state: PolygonState) { - polygonController.update(state) - getStyleInstance()?.let { ensurePolygonZLayers(it) } - } - - @Deprecated("Use MarkerState.onDragStart instead.") - override fun setOnMarkerDragStart(listener: OnMarkerEventHandler?) { - markerDragStartListener = listener - markerEventControllers.forEach { it.setDragStartListener(listener) } - } - - @Deprecated("Use MarkerState.onDrag instead.") - override fun setOnMarkerDrag(listener: OnMarkerEventHandler?) { - markerDragListener = listener - markerEventControllers.forEach { it.setDragListener(listener) } - } - - @Deprecated("Use MarkerState.onDragEnd instead.") - override fun setOnMarkerDragEnd(listener: OnMarkerEventHandler?) { - markerDragEndListener = listener - markerEventControllers.forEach { it.setDragEndListener(listener) } - } - - @Deprecated("Use PolylineState.onClick instead.") - override fun setOnPolylineClickListener(listener: OnPolylineEventHandler?) { - polylineController.clickListener = listener - } - - @Deprecated("Use PolygonState.onClick instead.") - override fun setOnPolygonClickListener(listener: OnPolygonEventHandler?) { - polygonController.clickListener = listener - } - - @Deprecated("Use CircleState.onClick instead.") - override fun setOnCircleClickListener(listener: OnCircleEventHandler?) { - this.circleController.clickListener = listener - } - - @Deprecated("Use MarkerState.onAnimateStart instead.") - override fun setOnMarkerAnimateStart(listener: OnMarkerEventHandler?) { - markerAnimateStartListener = listener - markerEventControllers.forEach { it.setAnimateStartListener(listener) } - } - - @Deprecated("Use MarkerState.onAnimateEnd instead.") - override fun setOnMarkerAnimateEnd(listener: OnMarkerEventHandler?) { - markerAnimateEndListener = listener - markerEventControllers.forEach { it.setAnimateEndListener(listener) } - } - - @Deprecated("Use MarkerState.onClick instead.") - override fun setOnMarkerClickListener(listener: OnMarkerEventHandler?) { - markerClickListener = listener - markerEventControllers.forEach { it.setClickListener(listener) } - } - - @Deprecated("Use GroundImageState.onClick instead.") - override fun setOnGroundImageClickListener(listener: OnGroundImageEventHandler?) { - this.groundImageController.clickListener = listener - } - - /** - * マーカーのヒットテスト。クリックカスケードの先頭。 - * - * Mappls は地図クリックの座標からそのまま引けるので、コアの - * [dispatchGeoMarkerClick] に委ねる(`clickable = false` の透過もそちら)。 - */ - override fun dispatchMarkerTap(position: GeoPointInterface): Boolean = - markerEventControllers.dispatchGeoMarkerClick(position) - - // 拡張ファイル(Gestures / Camera)からは基底クラスの protected へ触れないため、 - // ここで internal の入口を用意しておく。 - internal fun emitCameraMoveStart(position: MapCameraPosition) { - cameraMoveStartCallback?.invoke(position) - } - - internal fun emitCameraMoveEnd(position: MapCameraPosition) { - cameraMoveEndCallback?.invoke(position) - } - - override fun onMapClick(point: LatLng): Boolean = handleMapClick(point) - - override fun onMapLongClick(point: LatLng): Boolean = handleMapLongClick(point) - - override fun onMoveBegin(detector: MoveGestureDetector) = handleMoveBegin(detector) - - override fun onMove(detector: MoveGestureDetector) = handleMove(detector) - - override fun onMoveEnd(detector: MoveGestureDetector) = handleMoveEnd(detector) - - @SuppressLint("ClickableViewAccessibility") - override fun onCameraMove() { - mainCoroutine.launch { - getMapCameraPosition(readLogicalCameraPosition())?.let { mapCameraPosition -> - defaultCoroutine.launch { - notifyMapCameraPosition(mapCameraPosition) - } - cameraMoveCallback?.invoke(mapCameraPosition) - } - } - } - - override fun onCameraIdle() { - mainCoroutine.launch { - getMapCameraPosition(readLogicalCameraPosition())?.let { mapCameraPosition -> - defaultCoroutine.launch { - notifyMapCameraPosition(mapCameraPosition) - } - cameraMoveEndCallback?.invoke(mapCameraPosition) - } - } - } - - internal fun registerMarkerEventController(controller: DefaultMarkerEventController) { - if (markerEventControllers.contains(controller)) return - markerEventControllers.add(controller) - controller.setClickListener(markerClickListener) - controller.setDragStartListener(markerDragStartListener) - controller.setDragListener(markerDragListener) - controller.setDragEndListener(markerDragEndListener) - controller.setAnimateStartListener(markerAnimateStartListener) - controller.setAnimateEndListener(markerAnimateEndListener) - - val renderer = controller.renderer as MapplsMarkerOverlayRenderer - styleInstance?.let { style -> - renderer.ensureDefaultIcon(style) - ensureGeoJsonSource(style, renderer.markerLayer.sourceId) - addLayerAboveSafely( - style = style, - layer = renderer.markerLayer.layer, - layerId = renderer.markerLayer.layerId, - aboveId = polylineController.renderer.layer.layerId, - ) - ensureGeoJsonSource(style, renderer.dragLayer.sourceId) - addLayerAboveSafely( - style = style, - layer = renderer.dragLayer.layer, - layerId = renderer.dragLayer.layerId, - aboveId = renderer.markerLayer.layerId, - ) - renderer.redraw() - renderer.drawDragLayer() - } - } - - fun createMarkerRenderer( - strategy: MarkerRenderingStrategyInterface, - ): MarkerOverlayRendererInterface { - val groupId = UUID.randomUUID().toString() - val markerLayer = - MarkerLayer( - sourceId = "markers-source-$groupId", - layerId = "markers-layer-$groupId", - ) - val dragLayer = - MarkerDragLayer( - sourceId = "marker-drag-source-$groupId", - layerId = "marker-drag-layer-$groupId", - ) - return MapplsMarkerOverlayRenderer( - holder = holder, - markerManager = strategy.markerManager, - markerLayer = markerLayer, - dragLayer = dragLayer, - ) - } - - fun createMarkerEventController( - controller: StrategyMarkerController, - renderer: MarkerOverlayRendererInterface, - ): MarkerEventControllerInterface = DefaultMarkerEventController(controller) - - fun registerMarkerEventController(controller: MarkerEventControllerInterface) { - @Suppress("UNCHECKED_CAST") - val typed = controller as? DefaultMarkerEventController ?: return - registerMarkerEventController(typed) - } -} +package com.mapconductor.mappls + +import com.mapconductor.core.circle.CIRCLE_TILE_LAYER_ID +import com.mapconductor.core.circle.CircleTiler +import com.mapconductor.core.circle.circleTileRasterLayerState +import com.mapconductor.core.circle.OnCircleEventHandler +import com.mapconductor.core.controller.BaseMapViewController +import com.mapconductor.core.features.GeoPointInterface +import com.mapconductor.core.features.GeoRectBounds +import com.mapconductor.core.groundimage.OnGroundImageEventHandler +import com.mapconductor.core.map.CameraRestriction +import com.mapconductor.core.map.MapCameraPosition +import com.mapconductor.core.map.MapPaddings +import com.mapconductor.core.map.MapPaddingsInterface +import com.mapconductor.core.map.MapUISettings +import com.mapconductor.core.marker.DefaultMarkerEventController +import com.mapconductor.core.marker.MarkerAnimationOverlayHost +import com.mapconductor.core.marker.MarkerEventControllerInterface +import com.mapconductor.core.marker.MarkerOverlayRendererInterface +import com.mapconductor.core.marker.MarkerRenderingStrategyInterface +import com.mapconductor.core.marker.OnMarkerEventHandler +import com.mapconductor.core.marker.StrategyMarkerController +import com.mapconductor.core.marker.dispatchGeoMarkerClick +import com.mapconductor.core.polygon.OnPolygonEventHandler +import com.mapconductor.core.polygon.POLYGON_TILE_LAYER_ID +import com.mapconductor.core.polygon.PolygonState +import com.mapconductor.core.polygon.PolygonTiler +import com.mapconductor.core.polygon.polygonTileRasterLayerState +import com.mapconductor.core.polyline.OnPolylineEventHandler +import com.mapconductor.core.polyline.POLYLINE_TILE_LAYER_ID +import com.mapconductor.core.polyline.PolylineTiler +import com.mapconductor.core.polyline.polylineTileRasterLayerState +import com.mapconductor.mappls.circle.MapplsCircleController +import com.mapconductor.mappls.groundimage.MapplsGroundImageController +import com.mapconductor.mappls.marker.MapplsMarkerController +import com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer +import com.mapconductor.mappls.marker.MarkerDragLayer +import com.mapconductor.mappls.marker.MarkerLayer +import com.mapconductor.mappls.polygon.MapplsPolygonController +import com.mapconductor.mappls.polyline.MapplsPolylineController +import com.mapconductor.mappls.raster.MapplsRasterLayerController +import com.mappls.sdk.gestures.MoveGestureDetector +import com.mappls.sdk.maps.MapplsMap +import com.mappls.sdk.maps.Style +import com.mappls.sdk.maps.geometry.LatLng +import com.mappls.sdk.maps.style.OnStyleLoadListener +import java.util.UUID +import android.annotation.SuppressLint +import android.util.Log +import android.view.View +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch + +typealias MapplsDesignTypeChangeHandler = (MapplsMapDesignTypeInterface) -> Unit + +class MapplsViewController( + override val holder: MapplsMapViewHolderInterface, + internal val markerController: MapplsMarkerController, + internal val polylineController: MapplsPolylineController, + internal val polygonController: MapplsPolygonController, + internal val groundImageController: MapplsGroundImageController, + internal val circleController: MapplsCircleController, + internal val rasterLayerController: MapplsRasterLayerController, + override val mainCoroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), + override val defaultCoroutine: CoroutineScope = CoroutineScope(Dispatchers.Default), +) : BaseMapViewController(), + MapplsViewControllerInterface, + MapplsMap.OnMapClickListener, + MapplsMap.OnMapLongClickListener, + MapplsMap.OnMoveListener, + MapplsMap.OnCameraMoveListener, + MapplsMap.OnCameraIdleListener { + // Keep reference to the style instance to avoid getting a new one + internal var styleInstance: Style? = null + internal var wasScrollEnabledBeforeDrag: Boolean? = null + internal var dragTouchInterceptor: View.OnTouchListener? = null + internal val polygonZLayers: MutableSet = mutableSetOf() + internal val markerEventControllers = mutableListOf>() + internal var activeDragController: DefaultMarkerEventController? = null + internal var markerClickListener: OnMarkerEventHandler? = null + internal var markerDragStartListener: OnMarkerEventHandler? = null + internal var markerDragListener: OnMarkerEventHandler? = null + internal var markerDragEndListener: OnMarkerEventHandler? = null + internal var markerAnimateStartListener: OnMarkerEventHandler? = null + internal var markerAnimateEndListener: OnMarkerEventHandler? = null + + internal var lastLogicalCameraPosition: MapCameraPosition? = null + + /** アプリが指定したパディング(dp)。ネイティブには渡さず、中心のずらしで再現する。 */ + internal var cameraPaddings: MapPaddingsInterface = MapPaddings.Zeros + + init { + // Style should already be loaded by holderProvider + val style = holder.map.style + if (style != null) { + setupStyle(style) + // Trigger initial camera update after style is ready + sendInitialCameraUpdate() + } + + setupListeners() + registerOverlayController(markerController) + registerOverlayController(polylineController) + registerOverlayController(polygonController) + registerOverlayController(groundImageController) + registerOverlayController(circleController) + registerOverlayController(rasterLayerController) + registerMarkerEventController(DefaultMarkerEventController(markerController)) + + markerController.setRasterLayerCallback { state -> + if (state != null) { + rasterLayerController.upsert(state) + } else { + val markerTileLayers = + rasterLayerController.rasterLayerManager + .allEntities() + .filter { it.state.id.startsWith("marker-tile-") } + markerTileLayers.forEach { entity -> rasterLayerController.removeById(entity.state.id) } + } + } + + // Many polygons are drawn as raster tiles, shown through the same RasterLayer + // controller as the marker tiles (upsert / removeById, never the app's layers). + polygonController.tiler = + PolygonTiler().apply { + onTemplate = { template, tileSize -> + if (template != null) { + rasterLayerController.upsert(polygonTileRasterLayerState(template, tileSize)) + } else { + rasterLayerController.removeById(POLYGON_TILE_LAYER_ID) + } + } + } + + // Many circles too: the same raster layer path, in the circle band. + circleController.tiler = + CircleTiler().apply { + onTemplate = { template, tileSize -> + if (template != null) { + rasterLayerController.upsert(circleTileRasterLayerState(template, tileSize)) + } else { + rasterLayerController.removeById(CIRCLE_TILE_LAYER_ID) + } + } + } + + // Many polylines too: the same raster layer path, in the polyline band. + polylineController.tiler = + PolylineTiler().apply { + onTemplate = { template, tileSize -> + if (template != null) { + rasterLayerController.upsert(polylineTileRasterLayerState(template, tileSize)) + } else { + rasterLayerController.removeById(POLYLINE_TILE_LAYER_ID) + } + } + } + } + + fun setupListeners() { + holder.map.addOnCameraMoveListener(this) + holder.map.addOnCameraIdleListener(this) + + holder.map.removeOnMapClickListener(this) + holder.map.addOnMapClickListener(this) + + holder.map.removeOnMapLongClickListener(this) + holder.map.addOnMapLongClickListener(this) + + holder.map.removeOnMoveListener(this) + holder.map.addOnMoveListener(this) + } + + override suspend fun clearOverlays() { + markerController.clear() + polylineController.clear() + polygonController.clear() + groundImageController.clear() + circleController.clear() + rasterLayerController.clear() + // 拡張モジュール(クラスタリングなど)が登録した Strategy のマーカーも消す。 + clearStrategyMarkerControllers() + } + + override fun moveCamera(position: MapCameraPosition) = handleMoveCamera(position) + + override fun animateCamera( + position: MapCameraPosition, + duration: Long, + ) = handleAnimateCamera(position, duration) + + override fun fitBounds( + bounds: GeoRectBounds, + padding: Int, + ) = handleFitBounds(bounds, padding) + + override fun setCameraRestriction(restriction: CameraRestriction?) = handleCameraRestriction(restriction) + + override fun applyUISettings(settings: MapUISettings) { + // Mappls の getUiSettings() は @Nullable(MapLibre との差分) + holder.map.uiSettings?.apply { + isScrollGesturesEnabled = settings.scrollGesture + isZoomGesturesEnabled = settings.zoomGesture + isRotateGesturesEnabled = settings.rotateGesture + isTiltGesturesEnabled = settings.tiltGesture + } + } + + // Provide access to the style instance + fun getStyleInstance(): Style? = styleInstance + + private var mapDesignTypeChangeListener: MapplsDesignTypeChangeHandler? = null + + override fun setMapDesignType(value: MapplsMapDesignTypeInterface) { + mainCoroutine.launch { + // 空文字は「アカウントの既定スタイル」。既に既定が載っているので何もしない + // (setMapplsStyle("") は無効なスタイル名として弾かれる)。 + if (value.styleName.isEmpty()) return@launch + holder.map.setMapplsStyle( + value.styleName, + object : OnStyleLoadListener { + override fun onStyleLoaded(newStyle: Style) { + Log.d("Mappls", "Style changed to ${value.styleName}") + setupStyle(newStyle) + } + + override fun onError(message: String?) { + // スタイル名はアカウント紐付き。存在しない名前はここへ来る + Log.w("Mappls", "setMapplsStyle(${value.styleName}) failed: $message") + } + }, + ) + } + } + + fun sendInitialCameraUpdate() { + mainCoroutine.launch { + notifyMapInitialized() + val mapWidth = holder.mapView.width.toFloat() + val mapHeight = holder.mapView.height.toFloat() + if (mapWidth <= 0 || mapHeight <= 0) return@launch + + val camera = readLogicalCameraPosition() + getMapCameraPosition(camera)?.let { mapCameraPosition -> + defaultCoroutine.launch { notifyMapCameraPosition(mapCameraPosition) } + } + } + } + + override fun setMapDesignTypeChangeListener(listener: MapplsDesignTypeChangeHandler) { + mapDesignTypeChangeListener = listener + // Don't call listener immediately - it may trigger style reload + // listener(mapDesignType) + } + + override fun setMarkerAnimationOverlayHost(host: MarkerAnimationOverlayHost?) { + (markerController.renderer as MapplsMarkerOverlayRenderer).animationOverlayHost = host + } + + override suspend fun compositionPolygons(data: List) { + polygonController.add(data) + getStyleInstance()?.let { ensurePolygonZLayers(it) } + } + + override suspend fun updatePolygon(state: PolygonState) { + polygonController.update(state) + getStyleInstance()?.let { ensurePolygonZLayers(it) } + } + + @Deprecated("Use MarkerState.onDragStart instead.") + override fun setOnMarkerDragStart(listener: OnMarkerEventHandler?) { + markerDragStartListener = listener + markerEventControllers.forEach { it.setDragStartListener(listener) } + } + + @Deprecated("Use MarkerState.onDrag instead.") + override fun setOnMarkerDrag(listener: OnMarkerEventHandler?) { + markerDragListener = listener + markerEventControllers.forEach { it.setDragListener(listener) } + } + + @Deprecated("Use MarkerState.onDragEnd instead.") + override fun setOnMarkerDragEnd(listener: OnMarkerEventHandler?) { + markerDragEndListener = listener + markerEventControllers.forEach { it.setDragEndListener(listener) } + } + + @Deprecated("Use PolylineState.onClick instead.") + override fun setOnPolylineClickListener(listener: OnPolylineEventHandler?) { + polylineController.clickListener = listener + } + + @Deprecated("Use PolygonState.onClick instead.") + override fun setOnPolygonClickListener(listener: OnPolygonEventHandler?) { + polygonController.clickListener = listener + } + + @Deprecated("Use CircleState.onClick instead.") + override fun setOnCircleClickListener(listener: OnCircleEventHandler?) { + this.circleController.clickListener = listener + } + + @Deprecated("Use MarkerState.onAnimateStart instead.") + override fun setOnMarkerAnimateStart(listener: OnMarkerEventHandler?) { + markerAnimateStartListener = listener + markerEventControllers.forEach { it.setAnimateStartListener(listener) } + } + + @Deprecated("Use MarkerState.onAnimateEnd instead.") + override fun setOnMarkerAnimateEnd(listener: OnMarkerEventHandler?) { + markerAnimateEndListener = listener + markerEventControllers.forEach { it.setAnimateEndListener(listener) } + } + + @Deprecated("Use MarkerState.onClick instead.") + override fun setOnMarkerClickListener(listener: OnMarkerEventHandler?) { + markerClickListener = listener + markerEventControllers.forEach { it.setClickListener(listener) } + } + + @Deprecated("Use GroundImageState.onClick instead.") + override fun setOnGroundImageClickListener(listener: OnGroundImageEventHandler?) { + this.groundImageController.clickListener = listener + } + + /** + * マーカーのヒットテスト。クリックカスケードの先頭。 + * + * Mappls は地図クリックの座標からそのまま引けるので、コアの + * [dispatchGeoMarkerClick] に委ねる(`clickable = false` の透過もそちら)。 + */ + override fun dispatchMarkerTap(position: GeoPointInterface): Boolean = + markerEventControllers.dispatchGeoMarkerClick(position) + + // 拡張ファイル(Gestures / Camera)からは基底クラスの protected へ触れないため、 + // ここで internal の入口を用意しておく。 + internal fun emitCameraMoveStart(position: MapCameraPosition) { + cameraMoveStartCallback?.invoke(position) + } + + internal fun emitCameraMoveEnd(position: MapCameraPosition) { + cameraMoveEndCallback?.invoke(position) + } + + override fun onMapClick(point: LatLng): Boolean = handleMapClick(point) + + override fun onMapLongClick(point: LatLng): Boolean = handleMapLongClick(point) + + override fun onMoveBegin(detector: MoveGestureDetector) = handleMoveBegin(detector) + + override fun onMove(detector: MoveGestureDetector) = handleMove(detector) + + override fun onMoveEnd(detector: MoveGestureDetector) = handleMoveEnd(detector) + + @SuppressLint("ClickableViewAccessibility") + override fun onCameraMove() { + mainCoroutine.launch { + getMapCameraPosition(readLogicalCameraPosition())?.let { mapCameraPosition -> + defaultCoroutine.launch { + notifyMapCameraPosition(mapCameraPosition) + } + cameraMoveCallback?.invoke(mapCameraPosition) + } + } + } + + override fun onCameraIdle() { + mainCoroutine.launch { + getMapCameraPosition(readLogicalCameraPosition())?.let { mapCameraPosition -> + defaultCoroutine.launch { + notifyMapCameraPosition(mapCameraPosition) + } + cameraMoveEndCallback?.invoke(mapCameraPosition) + } + } + } + + internal fun registerMarkerEventController(controller: DefaultMarkerEventController) { + if (markerEventControllers.contains(controller)) return + markerEventControllers.add(controller) + controller.setClickListener(markerClickListener) + controller.setDragStartListener(markerDragStartListener) + controller.setDragListener(markerDragListener) + controller.setDragEndListener(markerDragEndListener) + controller.setAnimateStartListener(markerAnimateStartListener) + controller.setAnimateEndListener(markerAnimateEndListener) + + val renderer = controller.renderer as MapplsMarkerOverlayRenderer + styleInstance?.let { style -> + renderer.ensureDefaultIcon(style) + ensureGeoJsonSource(style, renderer.markerLayer.sourceId) + MapplsOverlayStacking.add( + holder.map, + style, + renderer.markerLayer.layer, + MapplsOverlayStacking.key(com.mapconductor.core.controller.OverlayKind.Marker), + ) + ensureGeoJsonSource(style, renderer.dragLayer.sourceId) + MapplsOverlayStacking.add(holder.map, style, renderer.dragLayer.layer, MapplsOverlayStacking.MARKER_DRAG) + renderer.redraw() + renderer.drawDragLayer() + } + } + + fun createMarkerRenderer( + strategy: MarkerRenderingStrategyInterface, + ): MarkerOverlayRendererInterface { + val groupId = UUID.randomUUID().toString() + val markerLayer = + MarkerLayer( + sourceId = "markers-source-$groupId", + layerId = "markers-layer-$groupId", + ) + val dragLayer = + MarkerDragLayer( + sourceId = "marker-drag-source-$groupId", + layerId = "marker-drag-layer-$groupId", + ) + return MapplsMarkerOverlayRenderer( + holder = holder, + markerManager = strategy.markerManager, + markerLayer = markerLayer, + dragLayer = dragLayer, + ) + } + + fun createMarkerEventController( + controller: StrategyMarkerController, + renderer: MarkerOverlayRendererInterface, + ): MarkerEventControllerInterface = DefaultMarkerEventController(controller) + + fun registerMarkerEventController(controller: MarkerEventControllerInterface) { + @Suppress("UNCHECKED_CAST") + val typed = controller as? DefaultMarkerEventController ?: return + registerMarkerEventController(typed) + } +} diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewControllerCamera.kt b/src/main/java/com/mapconductor/mappls/MapplsViewControllerCamera.kt index 8e4e6ac..76850d5 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewControllerCamera.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewControllerCamera.kt @@ -1,9 +1,12 @@ package com.mapconductor.mappls +import android.view.View import com.mapconductor.core.features.GeoRectBounds +import com.mapconductor.core.map.CameraPaddingEmulation import com.mapconductor.core.map.CameraRestriction import com.mapconductor.core.map.MapCameraPosition import com.mapconductor.core.map.MapCameraPositionInterface +import com.mapconductor.core.map.MapPaddings import com.mapconductor.core.map.buildVisibleRegion import com.mapconductor.mappls.zoom.ZoomAltitudeConverter import com.mappls.sdk.maps.camera.CameraUpdateFactory @@ -17,10 +20,65 @@ import kotlinx.coroutines.launch * 1 段ずれる。読むときも書くときも [ZoomAltitudeConverter] を通す。 */ internal fun MapplsViewController.readLogicalCameraPosition(): MapCameraPosition = - MapplsCameraStateSnapshot( - cameraPosition = holder.map.cameraPosition, - logicalTiltHint = lastLogicalCameraPosition?.tilt, - ).toMapCameraPosition() + CameraPaddingEmulation.fromNativeCamera( + MapplsCameraStateSnapshot( + cameraPosition = holder.map.cameraPosition, + logicalTiltHint = lastLogicalCameraPosition?.tilt, + density = density(), + ).toMapCameraPosition(), + cameraPaddings, + MAPPLS_VERTICAL_FOV, + viewportHeightDp(), + ) + +/** 地図の高さ(dp)。パディングのエミュレーションで遠近を解くのに使う。 */ +internal fun MapplsViewController.viewportHeightDp(): Double = holder.mapView.height / density().toDouble() + +/** + * パディングを中心のずらしに置き換えたカメラ。Mappls のパディングは常に 0 にする。 + * + * ネイティブのパディングは視錐台を上へ広げる。tilt があると上のパディングが + * 大きいほど画面の上端が地平線の先まで届き、そこまでタイルを読みに行って固まる + * (パディング中は tilt も 56° 前後に下げられる)。中心をずらせば、パディング無しと + * 同じ視錐台のまま target をパディング中央に置ける。paddings が null なら今のパディングを使い続ける。 + */ +internal fun MapplsViewController.toNativeCamera(position: MapCameraPosition): MapCameraPosition { + position.paddings?.let { cameraPaddings = it } + return CameraPaddingEmulation + .toNativeCamera(position.copy(paddings = cameraPaddings), MAPPLS_VERTICAL_FOV, viewportHeightDp()) + .copy(paddings = MapPaddings.Zeros) +} + +/** 地図がまだ大きさを持たない(レイアウト前)ときは、パディングを解けないので最初のレイアウトまで待つ。 */ +private fun MapplsViewController.needsLayoutFor(position: MapCameraPosition): Boolean { + val paddings = position.paddings ?: cameraPaddings + val padded = paddings.top != 0.0 || paddings.left != 0.0 || paddings.bottom != 0.0 || paddings.right != 0.0 + return padded && holder.mapView.height <= 0 +} + +private fun MapplsViewController.afterFirstLayout(action: () -> Unit) { + holder.mapView.addOnLayoutChangeListener( + object : View.OnLayoutChangeListener { + override fun onLayoutChange( + v: View, + left: Int, + top: Int, + right: Int, + bottom: Int, + oldLeft: Int, + oldTop: Int, + oldRight: Int, + oldBottom: Int, + ) { + if (bottom - top <= 0) return + v.removeOnLayoutChangeListener(this) + action() + } + }, + ) +} + +internal fun MapplsViewController.density(): Float = holder.mapView.resources.displayMetrics.density internal fun MapplsViewController.getMapCameraPosition(camera: MapCameraPositionInterface): MapCameraPosition? { // 4 隅の逆投影は全プロバイダ共通なのでコアの buildVisibleRegion を使う。 @@ -31,7 +89,11 @@ internal fun MapplsViewController.getMapCameraPosition(camera: MapCameraPosition internal fun MapplsViewController.handleMoveCamera(position: MapCameraPosition) { lastLogicalCameraPosition = position mainCoroutine.launch { - val cameraPos = position.toCameraPosition() + if (needsLayoutFor(position)) { + afterFirstLayout { handleMoveCamera(position) } + return@launch + } + val cameraPos = toNativeCamera(position).toCameraPosition(density()) val cameraUpdate = CameraUpdateFactory .newCameraPosition(cameraPos) @@ -46,7 +108,11 @@ internal fun MapplsViewController.handleAnimateCamera( ) { lastLogicalCameraPosition = position mainCoroutine.launch { - val cameraPos = position.toCameraPosition() + if (needsLayoutFor(position)) { + afterFirstLayout { handleAnimateCamera(position, duration) } + return@launch + } + val cameraPos = toNativeCamera(position).toCameraPosition(density()) val cameraUpdate = CameraUpdateFactory .newCameraPosition(cameraPos) diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewControllerStyle.kt b/src/main/java/com/mapconductor/mappls/MapplsViewControllerStyle.kt index 91af46a..177c03f 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewControllerStyle.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewControllerStyle.kt @@ -1,5 +1,6 @@ package com.mapconductor.mappls +import com.mapconductor.core.controller.OverlayKind import com.mapconductor.mappls.marker.MapplsMarkerOverlayRenderer import com.mappls.sdk.maps.Style import com.mappls.sdk.maps.style.expressions.Expression @@ -17,7 +18,9 @@ import kotlinx.coroutines.launch * * Mappls はスタイルが読み込み直されるたびにレイヤーが全部消えるため、ここは * 何度呼ばれても同じ状態になるように書いてある(`ensureGeoJsonSource` / - * `addLayerSafely` はいずれも既存があれば作らない)。 + * [MapplsOverlayStacking.add] はいずれも既存があれば作らない)。層の位置は + * [MapplsOverlayStacking] が帯の順(ラスター < GroundImage < ポリゴン < サークル < + * ポリライン < マーカー)で決める。 * * ポリゴンの z 順は**レイヤーを z 値ごとに用意して**表現する。Mappls には * フィーチャー単位の z 指定が無く、レイヤーの並び順だけが順序を決めるため。 @@ -34,6 +37,7 @@ internal fun MapplsViewController.ensureGeoJsonSource( } } +// 層の位置は MapplsOverlayStacking が決める。以下 2 つは公開 API の互換のために残している(SDK 内では未使用)。 internal fun MapplsViewController.addLayerSafely( style: Style, layer: Layer, @@ -81,54 +85,31 @@ internal fun MapplsViewController.setupStyle(style: Style) { (markerController.renderer as MapplsMarkerOverlayRenderer).ensureDefaultIcon(style) // Polygon sources only (layers will be added per zIndex) - ensureGeoJsonSource(style, polygonController.polylineOverlay.layer.sourceId) - ensureGeoJsonSource(style, polygonController.polygonOverlay.layer.sourceId) + ensureGeoJsonSource(style, polygonController.renderer.outline.layer.sourceId) + ensureGeoJsonSource(style, polygonController.renderer.fill.layer.sourceId) + + // 層の位置は MapplsOverlayStacking が帯の順で決める(追加の順に依らない)。 + val stacking = MapplsOverlayStacking + val map = holder.map + val markerRenderer = markerController.renderer as MapplsMarkerOverlayRenderer - // Circle cts as anchor above polygons ensureGeoJsonSource(style, circleController.renderer.layer.sourceId) - addLayerSafely( - style = style, - layer = circleController.renderer.layer.layer, - layerId = circleController.renderer.layer.layerId, - ) - // Circle stroke (LineLayer) directly above the circle fill - addLayerAboveSafely( - style = style, - layer = circleController.renderer.layer.strokeLayer, - layerId = circleController.renderer.layer.strokeLayerId, - aboveId = circleController.renderer.layer.layerId, - ) + stacking.add(map, style, circleController.renderer.layer.layer, stacking.key(OverlayKind.Circle)) + // 線は塗りの直後(同じ鍵なら後から入れたものが上)。 + stacking.add(map, style, circleController.renderer.layer.strokeLayer, stacking.key(OverlayKind.Circle)) - // Polyline (general) acts as anchor above circles ensureGeoJsonSource(style, polylineController.renderer.layer.sourceId) - addLayerSafely( - style = style, - layer = polylineController.renderer.layer.layer, - layerId = polylineController.renderer.layer.layerId, - ) + stacking.add(map, style, polylineController.renderer.layer.layer, stacking.key(OverlayKind.Polyline)) - // Add z-indexed polygon layers below general polylines ensurePolygonZLayers(style) - // Marker - add source and layer at the top - ensureGeoJsonSource(style, (markerController.renderer as MapplsMarkerOverlayRenderer).markerLayer.sourceId) - addLayerAboveSafely( - style = style, - layer = (markerController.renderer as MapplsMarkerOverlayRenderer).markerLayer.layer, - layerId = (markerController.renderer as MapplsMarkerOverlayRenderer).markerLayer.layerId, - aboveId = polylineController.renderer.layer.layerId, - ) - (markerController.renderer as MapplsMarkerOverlayRenderer).redraw() + ensureGeoJsonSource(style, markerRenderer.markerLayer.sourceId) + stacking.add(map, style, markerRenderer.markerLayer.layer, stacking.key(OverlayKind.Marker)) + markerRenderer.redraw() - // Drag layer above marker layer - ensureGeoJsonSource(style, (markerController.renderer as MapplsMarkerOverlayRenderer).dragLayer.sourceId) - addLayerAboveSafely( - style = style, - layer = (markerController.renderer as MapplsMarkerOverlayRenderer).dragLayer.layer, - layerId = (markerController.renderer as MapplsMarkerOverlayRenderer).dragLayer.layerId, - aboveId = (markerController.renderer as MapplsMarkerOverlayRenderer).markerLayer.layerId, - ) - (markerController.renderer as MapplsMarkerOverlayRenderer).redraw() + ensureGeoJsonSource(style, markerRenderer.dragLayer.sourceId) + stacking.add(map, style, markerRenderer.dragLayer.layer, stacking.MARKER_DRAG) + markerRenderer.redraw() markerEventControllers .map { it.renderer as MapplsMarkerOverlayRenderer } @@ -136,19 +117,9 @@ internal fun MapplsViewController.setupStyle(style: Style) { .forEach { renderer -> renderer.ensureDefaultIcon(style) ensureGeoJsonSource(style, renderer.markerLayer.sourceId) - addLayerAboveSafely( - style = style, - layer = renderer.markerLayer.layer, - layerId = renderer.markerLayer.layerId, - aboveId = polylineController.renderer.layer.layerId, - ) + stacking.add(map, style, renderer.markerLayer.layer, stacking.key(OverlayKind.Marker)) ensureGeoJsonSource(style, renderer.dragLayer.sourceId) - addLayerAboveSafely( - style = style, - layer = renderer.dragLayer.layer, - layerId = renderer.dragLayer.layerId, - aboveId = renderer.markerLayer.layerId, - ) + stacking.add(map, style, renderer.dragLayer.layer, stacking.MARKER_DRAG) renderer.redraw() renderer.drawDragLayer() } @@ -157,7 +128,7 @@ internal fun MapplsViewController.setupStyle(style: Style) { (markerController.renderer as MapplsMarkerOverlayRenderer).redraw() circleController.renderer.redraw() polylineController.renderer.redraw() -// polygonController.polygonOverlay.onPostProcess() +// polygonController.renderer.fill.onPostProcess() mainCoroutine.launch { groundImageController.reapplyStyle() rasterLayerController.reapplyStyle() @@ -165,12 +136,11 @@ internal fun MapplsViewController.setupStyle(style: Style) { } internal fun MapplsViewController.ensurePolygonZLayers(style: Style) { - val fillSourceId = polygonController.polygonOverlay.layer.sourceId - val outlineSourceId = polygonController.polylineOverlay.layer.sourceId - val anchorId = polylineController.renderer.layer.layerId + val fillSourceId = polygonController.renderer.fill.layer.sourceId + val outlineSourceId = polygonController.renderer.outline.layer.sourceId val zSet = - polygonController.polygonOverlay.polygonManager + polygonController.polygonManager .allEntities() .map { it.state.zIndex } .toSet() @@ -180,14 +150,8 @@ internal fun MapplsViewController.ensurePolygonZLayers(style: Style) { toRemove.forEach { z -> val fillId = "polygon-fill-layer-$z" val outlineId = "polygon-outline-layer-$z" - try { - style.removeLayer(outlineId) - } catch (_: Exception) { - } - try { - style.removeLayer(fillId) - } catch (_: Exception) { - } + MapplsOverlayStacking.remove(holder.map, style, outlineId) + MapplsOverlayStacking.remove(holder.map, style, fillId) } val zList = zSet.toList().sorted() @@ -213,11 +177,7 @@ internal fun MapplsViewController.ensurePolygonZLayers(style: Style) { ), ) } - try { - style.addLayerBelow(fill, anchorId) - } catch (_: Exception) { - style.addLayer(fill) - } + MapplsOverlayStacking.add(holder.map, style, fill, MapplsOverlayStacking.key(OverlayKind.Polygon, z)) } if (style.getLayer(outlineId) == null) { @@ -246,11 +206,8 @@ internal fun MapplsViewController.ensurePolygonZLayers(style: Style) { ), ) } - try { - style.addLayerAbove(outline, fillId) - } catch (_: Exception) { - style.addLayer(outline) - } + // 塗りの直後(同じ鍵なら後から入れたものが上)。 + MapplsOverlayStacking.add(holder.map, style, outline, MapplsOverlayStacking.key(OverlayKind.Polygon, z)) } } polygonZLayers.clear() diff --git a/src/main/java/com/mapconductor/mappls/MapplsViewStateImpl.kt b/src/main/java/com/mapconductor/mappls/MapplsViewStateImpl.kt index 50dac25..64c1656 100644 --- a/src/main/java/com/mapconductor/mappls/MapplsViewStateImpl.kt +++ b/src/main/java/com/mapconductor/mappls/MapplsViewStateImpl.kt @@ -8,6 +8,7 @@ import com.mapconductor.compose.map.BaseMapViewSaver import com.mapconductor.core.map.MapCameraPosition import com.mapconductor.core.map.MapCameraPositionInterface import com.mapconductor.core.map.MapViewState +import com.mapconductor.core.map.MapViewStateBundle import com.mapconductor.core.map.MapViewStateInterface import java.util.UUID import android.os.Bundle @@ -20,7 +21,10 @@ class MapplsViewState( cameraPosition: MapCameraPosition = MapCameraPosition.Default, ) : MapViewState(cameraPosition), MapplsViewStateInterface { - private var controller: MapplsViewControllerInterface? = null + // Read through the base so that letting go of the controller there (MapViewBase + // does it when the map is torn down) leaves nothing behind here. + private val controller: MapplsViewControllerInterface? + get() = attachedMapController as? MapplsViewControllerInterface private var _mapDesignType: MapplsMapDesignTypeInterface = mapDesignType override var mapDesignType: MapplsMapDesignTypeInterface @@ -31,7 +35,6 @@ class MapplsViewState( get() = _mapDesignType internal fun setController(controller: MapplsViewControllerInterface) { - this.controller = controller attachController(controller) } @@ -53,7 +56,10 @@ class MapplsMapViewSaver : BaseMapViewSaver() { state: MapplsViewState, bundle: Bundle, ) { - bundle.putString("styleName", state.mapDesignType.styleName) + val design = state.mapDesignType + bundle.putString("id", design.id) + bundle.putString("styleName", design.styleName) + MapViewStateBundle.putAttributionRules(bundle, design.attributionRules) } override fun createState( @@ -71,6 +77,7 @@ class MapplsMapViewSaver : BaseMapViewSaver() { styleName = mapDesignBundle?.getString("styleName") ?: MapplsDesign.Default.styleName, + attributionRules = MapViewStateBundle.getAttributionRules(mapDesignBundle), ), cameraPosition = cameraPosition, ) diff --git a/src/main/java/com/mapconductor/mappls/circle/MapplsCircleOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/circle/MapplsCircleOverlayRenderer.kt index b808576..e040fca 100644 --- a/src/main/java/com/mapconductor/mappls/circle/MapplsCircleOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/circle/MapplsCircleOverlayRenderer.kt @@ -42,7 +42,7 @@ class MapplsCircleOverlayRenderer( /** Reapply the current composition after a Mappls style is created or replaced. */ fun redraw() { - val circles = circleManager.allEntities() + val circles = circleManager.nativeEntities().filter { (it.circle as MapplsActualCircle?) != null } holder.map.style?.let { style -> coroutine.launch { layer.draw(circles, style) } } diff --git a/src/main/java/com/mapconductor/mappls/groundimage/MapplsGroundImageOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/groundimage/MapplsGroundImageOverlayRenderer.kt index 0dcc9eb..1b7059e 100644 --- a/src/main/java/com/mapconductor/mappls/groundimage/MapplsGroundImageOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/groundimage/MapplsGroundImageOverlayRenderer.kt @@ -1,5 +1,6 @@ package com.mapconductor.mappls.groundimage +import com.mapconductor.core.controller.OverlayKind import com.mapconductor.core.features.GeoRectBounds import com.mapconductor.core.groundimage.AbstractGroundImageOverlayRenderer import com.mapconductor.core.groundimage.GroundImageEntityInterface @@ -7,6 +8,7 @@ import com.mapconductor.core.groundimage.GroundImageFingerPrint import com.mapconductor.core.groundimage.GroundImageState import com.mapconductor.mappls.MapplsActualGroundImage import com.mapconductor.mappls.MapplsMapViewHolderInterface +import com.mapconductor.mappls.MapplsOverlayStacking import com.mappls.sdk.maps.Style import com.mappls.sdk.maps.geometry.LatLng import com.mappls.sdk.maps.geometry.LatLngQuad @@ -104,25 +106,20 @@ class MapplsGroundImageOverlayRenderer( Log.w("Mappls", "Failed to add ground image source: ${e.message}") } - try { - style.addLayerBelow(layer, BELOW_LAYER_ID) - } catch (_: Exception) { - try { - style.addLayer(layer) - } catch (e: Exception) { - Log.w("Mappls", "Failed to add ground image layer: ${e.message}") - } - } + // GroundImage の帯(ラスターの上、ポリゴンの下)。送り直しても同じ位置。 + MapplsOverlayStacking.add( + holder.map, + style, + layer, + MapplsOverlayStacking.key(OverlayKind.GroundImage), + ) } private fun removeSourceAndLayerIfExists( style: Style, handle: MapplsGroundImageHandle, ) { - try { - style.removeLayer(handle.layerId) - } catch (_: Exception) { - } + MapplsOverlayStacking.remove(holder.map, style, handle.layerId) try { style.removeSource(handle.sourceId) } catch (_: Exception) { @@ -185,7 +182,6 @@ class MapplsGroundImageOverlayRenderer( opacity = opacity, ) - companion object { - private const val BELOW_LAYER_ID = "polyline-layer" - } + // 公開 API(Companion)の互換のために残している。 + companion object } diff --git a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt index 8c8ee8d..45ef10c 100644 --- a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt +++ b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerController.kt @@ -1,318 +1,358 @@ -package com.mapconductor.mappls.marker - -import com.mapconductor.core.controller.OnCameraChangeReceiverInterface -import com.mapconductor.core.map.MapCameraPosition -import com.mapconductor.core.marker.AbstractMarkerController -import com.mapconductor.core.marker.BitmapIcon -import com.mapconductor.core.marker.DefaultMarkerIcon -import com.mapconductor.core.marker.MarkerEntity -import com.mapconductor.core.marker.MarkerEntityInterface -import com.mapconductor.core.marker.MarkerIngestionEngine -import com.mapconductor.core.marker.MarkerOverlayRendererInterface -import com.mapconductor.core.marker.MarkerState -import com.mapconductor.core.marker.MarkerTileRasterLayerCallback -import com.mapconductor.core.marker.MarkerTileRenderer -import com.mapconductor.core.marker.MarkerTilingOptions -import com.mapconductor.core.marker.MarkerViewportSwitch -import com.mapconductor.core.raster.RasterLayerSource -import com.mapconductor.core.raster.RasterLayerState -import com.mapconductor.core.raster.TileScheme -import com.mapconductor.core.tileserver.TileServerRegistry -import com.mapconductor.mappls.MapplsActualMarker -import java.util.UUID -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.launch -import kotlinx.coroutines.sync.withPermit - -class MapplsMarkerController( - renderer: MapplsMarkerOverlayRenderer, - private val markerTiling: MarkerTilingOptions = MarkerTilingOptions.Default, - private val coroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), -) : AbstractMarkerController( - markerManager = renderer.markerManager, - renderer = renderer, - ), - OnCameraChangeReceiverInterface { - private val defaultMarkerIcon: BitmapIcon = DefaultMarkerIcon().toBitmapIcon() - private val tiledMarkerIds = LinkedHashSet() - - private lateinit var lastCameraPosition: MapCameraPosition - - private val tileServer = TileServerRegistry.get() - private var markerTileRenderer: MarkerTileRenderer? = null - private var markerTileGroupId: String? = null - private var markerTileRasterLayerState: RasterLayerState? = null - private var rasterLayerCallback: MarkerTileRasterLayerCallback? = null - private var cacheVersion: Int = 0 - - /** - * ビューポート内が少ないときだけタイルをやめてネイティブマーカーで描く切り替え器。 - * - * レンダラ/マネージャ/semaphore を共有するので、コントローラと同じ排他の下で動く。 - */ - private val viewportSwitch = - MarkerViewportSwitch( - markerManager = markerManager, - renderer = renderer, - defaultMarkerIcon = defaultMarkerIcon, - semaphore = semaphore, - policy = markerTiling.viewport, - setTileLayerVisible = ::setTileLayerVisible, - invalidateTiles = ::updateRasterLayerSource, - ) - - fun setRasterLayerCallback(callback: MarkerTileRasterLayerCallback?) { - rasterLayerCallback = callback - } - - override suspend fun add(data: List) { - // ingest はタイル担当 entity を marker = null で登録し直すので、先に昇格を戻す。 - // semaphore は再入不可なので withPermit の外で呼ぶこと。 - viewportSwitch.retract() - semaphore.withPermit { - val tilingEnabled = - markerTiling.enabled && data.size >= markerManager.minMarkerCount - val result = - MarkerIngestionEngine.ingest( - data = data, - markerManager = markerManager, - renderer = renderer, - defaultMarkerIcon = defaultMarkerIcon, - tilingEnabled = tilingEnabled, - tiledMarkerIds = tiledMarkerIds, - shouldTile = { state -> !state.draggable && state.getAnimation() == null }, - ) - - if (result.tiledDataChanged) { - syncTiledOverlay() - } else if (result.hasTiledMarkers) { - if (markerTileRenderer == null || markerTileRasterLayerState == null) { - syncTiledOverlay() - } - } else { - removeTileOverlay() - } - } - viewportSwitch.requestReapply() - } - - override suspend fun update(state: MarkerState) { - if (!markerManager.hasEntity(state.id)) return - - // 昇格中の 1 件なら先に取り下げる(下で marker = null 登録があるため)。 - // 昇格していないマーカー(ドラッグ中など)では何もしないので、ドラッグは素通りする。 - if (viewportSwitch.isPromoted(state.id)) viewportSwitch.release(state.id) - - val prevEntity = markerManager.getEntity(state.id) ?: return - val currentFinger = state.fingerPrint() - val prevFinger = prevEntity.fingerPrint - if (currentFinger == prevFinger) return - - semaphore.withPermit { - val tilingEnabled = - markerTiling.enabled && markerManager.allEntities().size >= markerManager.minMarkerCount - val wantsTiled = tilingEnabled && !state.draggable && state.getAnimation() == null - val wasTiled = tiledMarkerIds.contains(state.id) - val markerIcon = state.icon?.toBitmapIcon() ?: defaultMarkerIcon - - if (wantsTiled) { - if (!wasTiled) { - prevEntity.marker?.let { renderer.onRemove(listOf(prevEntity)) } - tiledMarkerIds.add(state.id) - } - markerManager.updateEntity( - MarkerEntity( - marker = null, - state = state, - visible = prevEntity.visible, - isRendered = true, - // tiling を立てないと MarkerTileRenderer の絞り込みから漏れ、 - // タイル昇格したのにタイルへ描かれないマーカーになる。 - tiling = true, - ), - ) - renderer.onPostProcess() - syncTiledOverlay() - return@withPermit - } - - if (wasTiled) { - tiledMarkerIds.remove(state.id) - } - - val params = - object : MarkerOverlayRendererInterface.ChangeParamsInterface { - override val current: MarkerEntityInterface = - MarkerEntity( - marker = prevEntity.marker, - state = state, - visible = prevEntity.visible, - isRendered = true, - ) - override val bitmapIcon: BitmapIcon = markerIcon - override val prev: MarkerEntityInterface = prevEntity - } - val markers = renderer.onChange(listOf(params)) - markers.firstOrNull()?.let { actual -> - markerManager.updateEntity( - MarkerEntity( - marker = actual, - state = state, - visible = prevEntity.visible, - isRendered = true, - ), - ) - if (prevFinger.animation != currentFinger.animation) { - state.getAnimation()?.let { renderer.onAnimate(markerManager.getEntity(state.id)!!) } - } - } - renderer.onPostProcess() - - if (tiledMarkerIds.isNotEmpty()) { - syncTiledOverlay() - } else { - removeTileOverlay() - } - } - viewportSwitch.requestReapply() - } - - override suspend fun clear() { - viewportSwitch.destroy() - semaphore.withPermit { - val entities = markerManager.allEntities() - val toRemove = entities.filter { it.marker != null } - if (toRemove.isNotEmpty()) { - renderer.onRemove(toRemove) - } - markerManager.clear() - tiledMarkerIds.clear() - removeTileOverlay() - } - } - - override suspend fun onCameraChanged(mapCameraPosition: MapCameraPosition) { - lastCameraPosition = mapCameraPosition - // 判定と昇格は debounce したうえで切り替え器の中で走る(パン中は動かない)。 - viewportSwitch.onCameraChanged(mapCameraPosition) - } - - /** - * マーカータイルのラスターレイヤの表示だけを切り替える。 - * - * source(URL)には触らない。触るとタイルを取り直すことになり、切り替えのたびに - * タイルキャッシュを捨てるのと同じになる。 - */ - private suspend fun setTileLayerVisible(visible: Boolean) { - val current = markerTileRasterLayerState ?: return - if (current.visible == visible) return - val newState = current.copy(visible = visible) - markerTileRasterLayerState = newState - rasterLayerCallback?.onRasterLayerUpdate(newState) - } - - override fun destroy() { - viewportSwitch.destroy() - // Clean up tile server registration - // Unregister this map's route only. Never stop the server here: it is - // a process-wide singleton shared by all map controllers and overlay - // modules; stopping it breaks tile loading for every other live map. - markerTileGroupId?.let { groupId -> - tileServer.unregister(groupId) - } - markerTileGroupId = null - markerTileRenderer = null - - coroutine.launch { - rasterLayerCallback?.onRasterLayerUpdate(null) - } - markerTileRasterLayerState = null - super.destroy() - } - - private suspend fun updateRasterLayerSource() { - val groupId = markerTileGroupId ?: return - val tileRenderer = markerTileRenderer ?: return - val oldState = markerTileRasterLayerState ?: return - cacheVersion = (cacheVersion + 1) and 0x7fffffff - tileRenderer.invalidate() - - val newState = - oldState.copy( - source = - RasterLayerSource.UrlTemplate( - template = "${tileServer.urlTemplate(groupId, tileRenderer.tileSize)}?v=$cacheVersion", - tileSize = tileRenderer.tileSize, - maxZoom = 22, - scheme = TileScheme.XYZ, - ), - id = oldState.id, - ) - markerTileRasterLayerState = newState - rasterLayerCallback?.onRasterLayerUpdate(newState) - } - - private suspend fun syncTiledOverlay() { - if (tiledMarkerIds.isEmpty()) { - removeTileOverlay() - return - } - if (!markerTiling.enabled) { - removeTileOverlay() - tiledMarkerIds.clear() - return - } - - getOrCreateTileRenderer() - updateRasterLayerSource() - } - - private fun getOrCreateTileRenderer(): MarkerTileRenderer { - synchronized(this) { - markerTileRenderer?.let { return it } - - val groupId = UUID.randomUUID().toString() - markerTileGroupId = groupId - - val tileRenderer = - MarkerTileRenderer( - markerManager = markerManager, - tileSize = 256, - cacheSizeBytes = markerTiling.cacheSize, - debugTileOverlay = markerTiling.debugTileOverlay, - iconScaleCallback = markerTiling.iconScaleCallback, - ) - markerTileRenderer = tileRenderer - - tileServer.register(groupId, tileRenderer) - - markerTileRasterLayerState = - RasterLayerState( - id = "marker-tile-$groupId", - source = - RasterLayerSource.UrlTemplate( - template = tileServer.urlTemplate(groupId, tileRenderer.tileSize), - tileSize = tileRenderer.tileSize, - maxZoom = 22, - scheme = TileScheme.XYZ, - ), - opacity = 1.0f, - visible = true, - ) - - return tileRenderer - } - } - - private suspend fun removeTileOverlay() { - markerTileGroupId?.let { groupId -> - tileServer.unregister(groupId) - } - markerTileGroupId = null - markerTileRenderer = null - - rasterLayerCallback?.onRasterLayerUpdate(null) - markerTileRasterLayerState = null - } -} +package com.mapconductor.mappls.marker + +import com.mapconductor.core.controller.OnCameraChangeReceiverInterface +import com.mapconductor.core.map.MapCameraPosition +import com.mapconductor.core.marker.AbstractMarkerController +import com.mapconductor.core.marker.BitmapIcon +import com.mapconductor.core.marker.DefaultMarkerIcon +import com.mapconductor.core.marker.MarkerEntity +import com.mapconductor.core.marker.MarkerEntityInterface +import com.mapconductor.core.marker.MarkerIngestionEngine +import com.mapconductor.core.marker.MarkerOverlayRendererInterface +import com.mapconductor.core.marker.MarkerState +import com.mapconductor.core.marker.MarkerTileRasterLayerCallback +import com.mapconductor.core.marker.MarkerTileRenderer +import com.mapconductor.core.marker.MarkerTilingOptions +import com.mapconductor.core.marker.MarkerViewportSwitch +import com.mapconductor.core.raster.RasterLayerSource +import com.mapconductor.core.raster.RasterLayerState +import com.mapconductor.core.raster.TileScheme +import com.mapconductor.core.tileserver.TileServerRegistry +import com.mapconductor.mappls.MapplsActualMarker +import java.util.UUID +import kotlin.time.Duration.Companion.milliseconds +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch +import kotlinx.coroutines.sync.withPermit + +class MapplsMarkerController( + renderer: MapplsMarkerOverlayRenderer, + private val markerTiling: MarkerTilingOptions = MarkerTilingOptions.Default, + private val coroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), +) : AbstractMarkerController( + markerManager = renderer.markerManager, + renderer = renderer, + ), + OnCameraChangeReceiverInterface { + private val defaultMarkerIcon: BitmapIcon = DefaultMarkerIcon().toBitmapIcon() + private val tiledMarkerIds = LinkedHashSet() + + private lateinit var lastCameraPosition: MapCameraPosition + + private val tileServer = TileServerRegistry.get() + private var markerTileRenderer: MarkerTileRenderer? = null + private var markerTileGroupId: String? = null + private var markerTileRasterLayerState: RasterLayerState? = null + private var rasterLayerCallback: MarkerTileRasterLayerCallback? = null + private var cacheVersion: Int = 0 + + /** + * ビューポート内が少ないときだけタイルをやめてネイティブマーカーで描く切り替え器。 + * + * レンダラ/マネージャ/semaphore を共有するので、コントローラと同じ排他の下で動く。 + */ + private val viewportSwitch = + MarkerViewportSwitch( + markerManager = markerManager, + renderer = renderer, + defaultMarkerIcon = defaultMarkerIcon, + semaphore = semaphore, + policy = markerTiling.viewport, + setTileLayerVisible = ::setTileLayerVisible, + invalidateTiles = ::updateRasterLayerSource, + ) + + fun setRasterLayerCallback(callback: MarkerTileRasterLayerCallback?) { + rasterLayerCallback = callback + } + + override suspend fun add(data: List) { + // ingest はタイル担当 entity を marker = null で登録し直すので、先に昇格を戻す。 + // semaphore は再入不可なので withPermit の外で呼ぶこと。 + viewportSwitch.retract() + semaphore.withPermit { + val tilingEnabled = + markerTiling.enabled && data.size >= markerManager.minMarkerCount + val result = + MarkerIngestionEngine.ingest( + data = data, + markerManager = markerManager, + renderer = renderer, + defaultMarkerIcon = defaultMarkerIcon, + tilingEnabled = tilingEnabled, + tiledMarkerIds = tiledMarkerIds, + shouldTile = { state -> !state.draggable && state.getAnimation() == null }, + ) + + if (result.tiledDataChanged) { + syncTiledOverlay() + } else if (result.hasTiledMarkers) { + if (markerTileRenderer == null || markerTileRasterLayerState == null) { + syncTiledOverlay() + } + } else { + removeTileOverlay() + } + } + viewportSwitch.requestReapply() + } + + override suspend fun update(state: MarkerState) { + if (!markerManager.hasEntity(state.id)) return + + // 昇格中の 1 件なら先に取り下げる(下で marker = null 登録があるため)。 + // 昇格していないマーカー(ドラッグ中など)では何もしないので、ドラッグは素通りする。 + if (viewportSwitch.isPromoted(state.id)) viewportSwitch.release(state.id) + + val prevEntity = markerManager.getEntity(state.id) ?: return + val currentFinger = state.fingerPrint() + val prevFinger = prevEntity.fingerPrint + if (currentFinger == prevFinger) return + + semaphore.withPermit { + // 件数だけが要る。allEntities() は全件の写しを作るので、ラベルの付け替えのように + // 数十本が続けて変わると、そのたびに 14 万件を写すことになる。 + val tilingEnabled = + markerTiling.enabled && markerManager.getMemoryStats().entityCount >= markerManager.minMarkerCount + val wantsTiled = tilingEnabled && !state.draggable && state.getAnimation() == null + val wasTiled = tiledMarkerIds.contains(state.id) + + if (wantsTiled) { + if (!wasTiled) { + prevEntity.marker?.let { renderer.onRemove(listOf(prevEntity)) } + tiledMarkerIds.add(state.id) + } + markerManager.updateEntity( + MarkerEntity( + marker = null, + state = state, + visible = prevEntity.visible, + isRendered = true, + // tiling を立てないと MarkerTileRenderer の絞り込みから漏れ、 + // タイル昇格したのにタイルへ描かれないマーカーになる。 + tiling = true, + ), + ) + // タイル担当のままなら、ネイティブのマーカーには何も起きていない。onPostProcess は + // 全件を写してネイティブ分を描き直すので(14 万件で 1 回 50ms)、ネイティブから + // タイルへ移ったときだけ呼ぶ。 + if (!wasTiled) renderer.onPostProcess() + scheduleTileRefresh() + return@withPermit + } + + if (wasTiled) { + tiledMarkerIds.remove(state.id) + } + // ネイティブマーカーとして描くときだけ焼き込む。タイル担当なら要らない。 + val markerIcon = state.icon?.toBitmapIcon() ?: defaultMarkerIcon + + val params = + object : MarkerOverlayRendererInterface.ChangeParamsInterface { + override val current: MarkerEntityInterface = + MarkerEntity( + marker = prevEntity.marker, + state = state, + visible = prevEntity.visible, + isRendered = true, + ) + override val bitmapIcon: BitmapIcon = markerIcon + override val prev: MarkerEntityInterface = prevEntity + } + val markers = renderer.onChange(listOf(params)) + markers.firstOrNull()?.let { actual -> + markerManager.updateEntity( + MarkerEntity( + marker = actual, + state = state, + visible = prevEntity.visible, + isRendered = true, + ), + ) + if (prevFinger.animation != currentFinger.animation) { + state.getAnimation()?.let { renderer.onAnimate(markerManager.getEntity(state.id)!!) } + } + } + renderer.onPostProcess() + + if (tiledMarkerIds.isNotEmpty()) { + scheduleTileRefresh() + } else { + removeTileOverlay() + } + } + viewportSwitch.requestReapply() + } + + private var tileRefreshJob: Job? = null + + /** + * 1 本ずつの変更からの描き直しを 1 回にまとめる。 + * + * ラベルの付け替えのように数十本が続けて変わると、1 本ごとにラスターソースを差し替え、 + * そのたびに地図が見えているタイルを全部取り直していた(MapLibre・Pixel 5a で 45 回、 + * 描き直したタイル 494 枚、最後のタイルまで 6 秒)。続けて来た変更は + * [TILE_REFRESH_COALESCE] の間に受けて、まとめて 1 回だけ差し替える。 + */ + private fun scheduleTileRefresh() { + if (tileRefreshJob?.isActive == true) return + tileRefreshJob = + coroutine.launch { + delay(TILE_REFRESH_COALESCE) + semaphore.withPermit { syncTiledOverlay() } + } + } + + override suspend fun clear() { + viewportSwitch.destroy() + semaphore.withPermit { + val entities = markerManager.allEntities() + val toRemove = entities.filter { it.marker != null } + if (toRemove.isNotEmpty()) { + renderer.onRemove(toRemove) + } + markerManager.clear() + tiledMarkerIds.clear() + removeTileOverlay() + // onRemove はアイコンの参照数を減らすだけで、地図のソースは onPostProcess が + // manager の中身から描き直すまで変わらない。空にした後で呼ばないと、 + // clearOverlays() の後もマーカーが地図に残る。 + renderer.onPostProcess() + } + } + + override suspend fun onCameraChanged(mapCameraPosition: MapCameraPosition) { + lastCameraPosition = mapCameraPosition + // 判定と昇格は debounce したうえで切り替え器の中で走る(パン中は動かない)。 + viewportSwitch.onCameraChanged(mapCameraPosition) + } + + /** + * マーカータイルのラスターレイヤの表示だけを切り替える。 + * + * source(URL)には触らない。触るとタイルを取り直すことになり、切り替えのたびに + * タイルキャッシュを捨てるのと同じになる。 + */ + private suspend fun setTileLayerVisible(visible: Boolean) { + val current = markerTileRasterLayerState ?: return + if (current.visible == visible) return + val newState = current.copy(visible = visible) + markerTileRasterLayerState = newState + rasterLayerCallback?.onRasterLayerUpdate(newState) + } + + override fun destroy() { + viewportSwitch.destroy() + // 待っている描き直しが後から走ると、外したタイル経路をまた登録してしまう。 + tileRefreshJob?.cancel() + // Clean up tile server registration + // Unregister this map's route only. Never stop the server here: it is + // a process-wide singleton shared by all map controllers and overlay + // modules; stopping it breaks tile loading for every other live map. + markerTileGroupId?.let { groupId -> + tileServer.unregister(groupId) + } + markerTileGroupId = null + markerTileRenderer = null + + coroutine.launch { + rasterLayerCallback?.onRasterLayerUpdate(null) + } + markerTileRasterLayerState = null + super.destroy() + } + + private suspend fun updateRasterLayerSource() { + val groupId = markerTileGroupId ?: return + val tileRenderer = markerTileRenderer ?: return + val oldState = markerTileRasterLayerState ?: return + cacheVersion = (cacheVersion + 1) and 0x7fffffff + tileRenderer.invalidate() + + val newState = + oldState.copy( + source = + RasterLayerSource.UrlTemplate( + template = "${tileServer.urlTemplate(groupId, tileRenderer.tileSize)}?v=$cacheVersion", + tileSize = tileRenderer.tileSize, + maxZoom = 22, + scheme = TileScheme.XYZ, + ), + id = oldState.id, + ) + markerTileRasterLayerState = newState + rasterLayerCallback?.onRasterLayerUpdate(newState) + } + + private suspend fun syncTiledOverlay() { + if (tiledMarkerIds.isEmpty()) { + removeTileOverlay() + return + } + if (!markerTiling.enabled) { + removeTileOverlay() + tiledMarkerIds.clear() + return + } + + getOrCreateTileRenderer() + updateRasterLayerSource() + } + + private fun getOrCreateTileRenderer(): MarkerTileRenderer { + synchronized(this) { + markerTileRenderer?.let { return it } + + val groupId = UUID.randomUUID().toString() + markerTileGroupId = groupId + + val tileRenderer = + MarkerTileRenderer( + markerManager = markerManager, + tileSize = 256, + cacheSizeBytes = markerTiling.cacheSize, + debugTileOverlay = markerTiling.debugTileOverlay, + iconScaleCallback = markerTiling.iconScaleCallback, + declutterPx = markerTiling.declutterPx, + ) + markerTileRenderer = tileRenderer + + tileServer.register(groupId, tileRenderer) + + markerTileRasterLayerState = + RasterLayerState( + id = "marker-tile-$groupId", + source = + RasterLayerSource.UrlTemplate( + template = tileServer.urlTemplate(groupId, tileRenderer.tileSize), + tileSize = tileRenderer.tileSize, + maxZoom = 22, + scheme = TileScheme.XYZ, + ), + opacity = 1.0f, + visible = true, + ) + + return tileRenderer + } + } + + private suspend fun removeTileOverlay() { + markerTileGroupId?.let { groupId -> + tileServer.unregister(groupId) + } + markerTileGroupId = null + markerTileRenderer = null + + rasterLayerCallback?.onRasterLayerUpdate(null) + markerTileRasterLayerState = null + } + + private companion object { + /** 続けて来る変更を 1 回の描き直しにまとめる窓。1 フレーム分。 */ + val TILE_REFRESH_COALESCE = 16.milliseconds + } +} diff --git a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerOverlayRenderer.kt index fbae120..e1fb8fb 100644 --- a/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/marker/MapplsMarkerOverlayRenderer.kt @@ -1,437 +1,417 @@ -package com.mapconductor.mappls.marker - -import com.google.gson.JsonArray -import com.google.gson.JsonObject -import com.mapconductor.core.ResourceProvider -import com.mapconductor.core.calculateZIndex -import com.mapconductor.core.features.GeoPoint -import com.mapconductor.core.features.GeoPointInterface -import com.mapconductor.core.marker.AbstractMarkerOverlayRenderer -import com.mapconductor.core.marker.BitmapIcon -import com.mapconductor.core.marker.DefaultMarkerIcon -import com.mapconductor.core.marker.MarkerEntityInterface -import com.mapconductor.core.marker.MarkerIconInterface -import com.mapconductor.core.marker.MarkerManager -import com.mapconductor.core.marker.MarkerOverlayRendererInterface -import com.mapconductor.mappls.MapplsActualMarker -import com.mapconductor.mappls.MapplsMapViewHolderInterface -import com.mapconductor.mappls.toPoint -import com.mappls.sdk.geojson.Feature -import com.mappls.sdk.geojson.FeatureCollection -import android.graphics.Bitmap -import android.os.SystemClock -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.launch -import kotlinx.coroutines.withContext -import kotlinx.coroutines.yield - -class MapplsMarkerOverlayRenderer( - holder: MapplsMapViewHolderInterface, - val markerManager: MarkerManager, - val markerLayer: MarkerLayer, - val dragLayer: MarkerDragLayer, - coroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), -) : AbstractMarkerOverlayRenderer( - holder = holder, - coroutine = coroutine, - ) { - override val supportsAnimationOverlay: Boolean = true - - private val iconRefCounter: MutableMap = mutableMapOf() - private val pendingStyleImageRemovals: MutableMap = mutableMapOf() - private val iconBitmapCache: MutableMap = mutableMapOf() - private val defaultMarkerIcon: BitmapIcon = DefaultMarkerIcon().toBitmapIcon() - - object Prop { - const val ICON_ID = "icon_id" - const val DEFAULT_MARKER_ID = "default" - const val SCALE = "scale" - const val ICON_ANCHOR = "icon-offset" - const val Z_INDEX = "zIndex" - } - - object IconAnchor { - const val CENTER = "center" - const val LEFT = "left" - const val RIGHT = "right" - const val BOTTOM = "bottom" - const val TOP_LEFT = "top-left" - const val TOP_RIGHT = "top-right" - const val BOTTOM_LEFT = "bottom-left" - const val BOTTOM_RIGHT = "bottom-right" - } - - object IconTranslateAnchor { - const val MAP = "map" - const val VIEWPORT = "viewport" - } - - init { - val style = holder.map.style - if (style != null) { - style.addImage(Prop.DEFAULT_MARKER_ID, defaultMarkerIcon.bitmap) - } else { - holder.map.getStyle { style -> - style.addImage(Prop.DEFAULT_MARKER_ID, defaultMarkerIcon.bitmap) - } - } - } - - // Ensure marker images exist on the given style (used after style reload). - fun ensureDefaultIcon(style: com.mappls.sdk.maps.Style) { - ensureStyleImages(style) - } - - fun ensureStyleImages(style: com.mappls.sdk.maps.Style) { - val startedAt = SystemClock.elapsedRealtime() - try { - style.addImage(Prop.DEFAULT_MARKER_ID, defaultMarkerIcon.bitmap) - } catch (_: Exception) { - } - - val entities = markerManager.allEntities() - val styleIcons = linkedMapOf() - var nativeMarkerCount = 0 - entities.forEach { entity -> - // Tiled markers have no Mappls Feature and are drawn by MarkerTileRenderer. - // Registering their images with the style is both unnecessary and extremely - // expensive for large data sets (the same bitmap may otherwise be added tens of - // thousands of times during a style reload). - if (entity.marker == null) return@forEach - nativeMarkerCount++ - val icon = entity.state.icon ?: return@forEach - val iconKey = icon.hashCode().toString() - if (!styleIcons.containsKey(iconKey)) { - styleIcons[iconKey] = iconBitmapCache[iconKey] ?: icon.toBitmapIcon().bitmap - } - } - - styleIcons.forEach { (iconKey, bitmap) -> - try { - style.addImage(iconKey, bitmap, false) - } catch (_: Exception) { - } - iconBitmapCache[iconKey] = bitmap - } - } - - private fun decrementIconRef(iconKey: String) { - if (iconKey == Prop.DEFAULT_MARKER_ID) return - val next = (iconRefCounter[iconKey] ?: 0) - 1 - if (next <= 0) { - iconRefCounter.remove(iconKey) - // Mappls can render one frame behind GeoJSON source updates during marker animation. - // Keep images briefly after last use so icon-image references never point at a missing image. - pendingStyleImageRemovals[iconKey] = System.currentTimeMillis() + STYLE_IMAGE_REMOVAL_GRACE_MS - } else { - iconRefCounter[iconKey] = next - } - } - - private fun incrementIconRef(iconKey: String) { - if (iconKey == Prop.DEFAULT_MARKER_ID) return - pendingStyleImageRemovals.remove(iconKey) - iconRefCounter[iconKey] = (iconRefCounter[iconKey] ?: 0) + 1 - } - - override fun setMarkerVisible( - markerEntity: MarkerEntityInterface, - visible: Boolean, - ) { - markerEntity.visible = visible - redraw() - } - - override fun setMarkerPosition( - markerEntity: MarkerEntityInterface, - position: GeoPoint, - ) { - val entities = markerManager.allEntities() - val props = (markerEntity.marker?.properties() ?: JsonObject()).deepCopy() - val previousZIndex = - props - .get(Prop.Z_INDEX) - ?.takeIf { it.isJsonPrimitive && it.asJsonPrimitive.isNumber } - ?.asInt - props.addProperty( - Prop.Z_INDEX, - markerEntity.state.zIndex - ?: previousZIndex - ?: calculateZIndex(position), - ) - val feature = - Feature.fromGeometry( - position.toPoint(), - props, - "marker-${markerEntity.state.id}", - ) - markerEntity.marker = feature - val features = - entities.map { - if (it.state.id == markerEntity.state.id) { - feature - } else { - it.marker - } - } - // Execute directly instead of launching a new coroutine - holder.map.style?.let { style -> - val styleSource = style.getSourceAs(markerLayer.sourceId) - styleSource?.setGeoJson(FeatureCollection.fromFeatures(features)) - } - } - - override suspend fun onAdd( - data: List, - ): List = - withContext(Dispatchers.Main) { - val style = holder.map.style ?: return@withContext emptyList() - - data.forEach { - it.state.icon?.let { icon -> - val iconKey = icon.hashCode().toString() - try { - style.addImage(iconKey, it.bitmapIcon.bitmap, false) - } catch (_: Exception) { - } - iconBitmapCache[iconKey] = it.bitmapIcon.bitmap - if (!iconRefCounter.contains(iconKey)) iconRefCounter[iconKey] = 0 - } - } - - data.map { - val featureId = "marker-${it.state.id}" - val position = GeoPoint.from(it.state.position).toPoint() - val properties = - JsonObject().apply { - if (it.state.icon != null) { - it.state.icon?.let { icon -> - val iconKey = icon.hashCode().toString() - incrementIconRef(iconKey) - addProperty(Prop.ICON_ID, iconKey) - // icon offset property - add(Prop.ICON_ANCHOR, createIconOffset(icon)) - } - } else { - addProperty(Prop.ICON_ID, Prop.DEFAULT_MARKER_ID) - add(Prop.ICON_ANCHOR, getDefaultIconOffsetProperty()) - } - // We don't use the Mappls SDK's scaling system - // addProperty(Prop.SCALE, 1.0) - addProperty(Prop.Z_INDEX, it.state.zIndex ?: calculateZIndex(it.state.position)) - } - Feature.fromGeometry(position, properties, featureId) - } - } - - private fun getDefaultIconOffsetProperty(): JsonArray = createIconOffset(defaultMarkerIcon) - - private fun createIconOffset(icon: BitmapIcon): JsonArray = - JsonArray().apply { - add(-(icon.size.width * icon.anchor.x) / ResourceProvider.getDensity()) - add(-(icon.size.height * icon.anchor.y) / ResourceProvider.getDensity()) - } - - private fun createIconOffset(icon: MarkerIconInterface): JsonArray = createIconOffset(icon.toBitmapIcon()) - - override suspend fun onRemove(data: List>) { - data.forEach { entity -> - val iconKey = - entity.marker - ?.properties() - ?.get(Prop.ICON_ID) - ?.asString - ?: entity.state.icon - ?.hashCode() - ?.toString() - if (iconKey != null) { - decrementIconRef(iconKey) - } - } - } - - fun drawDragLayer() { - holder.map.style?.let { - coroutine.launch { - dragLayer.draw(it) - } - } - } - - fun redraw() { - val entities = markerManager.allEntities() - // Get style from controller to use the same instance - holder.map.style?.let { - coroutine.launch { - markerLayer.draw(entities, it) - } - } - } - - override suspend fun onPostProcess() { - val target = markerManager.allEntities().filter { !it.tiling } - - // withContext(Dispatchers.Main) below is a real cross-thread hop when onPostProcess() - // is invoked from a background ingest dispatcher (as the React Native wrapper does for - // large marker batches) rather than already running on Main (as the native Compose - // sample does). That hop, immediately following a large tiled-marker ingest, lines up - // with severe GC stalls on-device even though the Main-side work below is a few ms at - // most - so skip the hop entirely when there's nothing for it to do. - if (markerLayer.wouldSkipDraw(target) && pendingStyleImageRemovals.isEmpty()) { - return - } - - return withContext(Dispatchers.Main) { - val style = holder.map.style ?: return@withContext - markerLayer.draw(target, style) - yield() - - val now = System.currentTimeMillis() - val expired = - pendingStyleImageRemovals - .asSequence() - .filter { (_, deadline) -> deadline <= now } - .map { (key, _) -> key } - .toList() - - expired.forEach { iconKey -> - if (iconRefCounter.containsKey(iconKey)) { - pendingStyleImageRemovals.remove(iconKey) - return@forEach - } - try { - style.removeImage(iconKey) - } catch (_: Exception) { - } finally { - pendingStyleImageRemovals.remove(iconKey) - iconBitmapCache.remove(iconKey) - } - } - } - } - - override suspend fun onChange( - data: List>, - ): List = - withContext(Dispatchers.Main) { - val style = holder.map.style ?: return@withContext emptyList() - - data.map { params -> - val prevFinger = params.prev.fingerPrint - val currFinger = params.current.fingerPrint - val prevProperties = params.prev.marker?.properties() - - val properties = - JsonObject().apply { - // No additional scaling needed - bitmap is created with device density - // and Bitmap.density is set to prevent Mappls's automatic scaling - // addProperty(Prop.SCALE, 1.0) - if (currFinger.icon == prevFinger.icon) { - addProperty( - Prop.ICON_ID, - prevProperties?.get(Prop.ICON_ID)?.asString ?: Prop.DEFAULT_MARKER_ID, - ) - - add( - Prop.ICON_ANCHOR, - prevProperties?.get(Prop.ICON_ANCHOR) ?: getDefaultIconOffsetProperty(), - ) - } else { - val prevIconKey = - prevProperties - ?.get(Prop.ICON_ID) - ?.asString - ?: params.prev.state.icon - ?.hashCode() - ?.toString() - ?: Prop.DEFAULT_MARKER_ID - decrementIconRef(prevIconKey) - - if (currFinger.icon == null) { - addProperty(Prop.ICON_ID, Prop.DEFAULT_MARKER_ID) - add(Prop.ICON_ANCHOR, getDefaultIconOffsetProperty()) - } else { - params.current.state.icon?.let { icon -> - // icon id - val iconKey = icon.hashCode().toString() - style.addImage(iconKey, params.bitmapIcon.bitmap, false) - iconBitmapCache[iconKey] = params.bitmapIcon.bitmap - if (!iconRefCounter.contains(iconKey)) iconRefCounter[iconKey] = 0 - incrementIconRef(iconKey) - addProperty(Prop.ICON_ID, iconKey) - add(Prop.ICON_ANCHOR, createIconOffset(icon)) - } - } - } - addProperty( - Prop.Z_INDEX, - resolveZIndexForChange( - current = params.current, - prev = params.prev, - prevProperties = prevProperties, - ), - ) - } - - val position = - GeoPoint.from(params.current.state.position).toPoint() - val featureId = "marker-${params.current.state.id}" - Feature.fromGeometry(position, properties, featureId) - } - } - - private fun resolveZIndexForChange( - current: MarkerEntityInterface, - prev: MarkerEntityInterface, - prevProperties: JsonObject?, - ): Int { - current.state.zIndex?.let { return it } - - if (current.fingerPrint.zIndex == prev.fingerPrint.zIndex) { - prevProperties - ?.get(Prop.Z_INDEX) - ?.takeIf { it.isJsonPrimitive && it.asJsonPrimitive.isNumber } - ?.asInt - ?.let { return it } - } - - return calculateZIndex(current.state.position) - } - - /** - * ドラッグ対象の入れ替え。 - * - * ドラッグ中のマーカーは通常のレイヤ([markerLayer])から外して専用の - * [dragLayer] へ移す。そうしないと GeoJSON ソースを丸ごと描き直すたびに - * 指の位置と食い違う。以前は各プロバイダのマーカーコントローラと - * ストラテジ用イベントコントローラに同じものが 2 本ずつあった。 - */ - override fun onDragSelectionChanged( - previous: MarkerEntityInterface?, - current: MarkerEntityInterface?, - ) { - if (current == null) { - previous?.let { - dragLayer.updatePosition(GeoPoint.from(it.state.position)) - dragLayer.selected = null - drawDragLayer() - markerManager.registerEntity(it) - redraw() - } - return - } - markerManager.removeEntity(current.state.id) - dragLayer.selected = current - dragLayer.updatePosition(GeoPoint.from(current.state.position)) - redraw() - drawDragLayer() - } - - override fun onDragPositionChanged(position: GeoPointInterface) { - dragLayer.updatePosition(GeoPoint.from(position)) - drawDragLayer() - } -} - -private const val STYLE_IMAGE_REMOVAL_GRACE_MS: Long = 1500L +package com.mapconductor.mappls.marker + +import com.google.gson.JsonArray +import com.google.gson.JsonObject +import com.mapconductor.core.ResourceProvider +import com.mapconductor.core.features.GeoPoint +import com.mapconductor.core.features.GeoPointInterface +import com.mapconductor.core.marker.AbstractMarkerOverlayRenderer +import com.mapconductor.core.marker.BitmapIcon +import com.mapconductor.core.marker.DefaultMarkerIcon +import com.mapconductor.core.marker.MarkerDrawOrder +import com.mapconductor.core.marker.MarkerEntityInterface +import com.mapconductor.core.marker.MarkerIconInterface +import com.mapconductor.core.marker.MarkerManager +import com.mapconductor.core.marker.MarkerOverlayRendererInterface +import com.mapconductor.mappls.MapplsActualMarker +import com.mapconductor.mappls.MapplsMapViewHolderInterface +import com.mapconductor.mappls.toPoint +import com.mappls.sdk.geojson.Feature +import com.mappls.sdk.geojson.FeatureCollection +import android.graphics.Bitmap +import android.os.SystemClock +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import kotlinx.coroutines.yield + +class MapplsMarkerOverlayRenderer( + holder: MapplsMapViewHolderInterface, + val markerManager: MarkerManager, + val markerLayer: MarkerLayer, + val dragLayer: MarkerDragLayer, + coroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), +) : AbstractMarkerOverlayRenderer( + holder = holder, + coroutine = coroutine, + ) { + override val supportsAnimationOverlay: Boolean = true + + private val iconRefCounter: MutableMap = mutableMapOf() + private val pendingStyleImageRemovals: MutableMap = mutableMapOf() + private val iconBitmapCache: MutableMap = mutableMapOf() + private val defaultMarkerIcon: BitmapIcon = DefaultMarkerIcon().toBitmapIcon() + + object Prop { + const val ICON_ID = "icon_id" + const val DEFAULT_MARKER_ID = "default" + const val SCALE = "scale" + const val ICON_ANCHOR = "icon-offset" + const val Z_INDEX = "zIndex" + } + + object IconAnchor { + const val CENTER = "center" + const val LEFT = "left" + const val RIGHT = "right" + const val BOTTOM = "bottom" + const val TOP_LEFT = "top-left" + const val TOP_RIGHT = "top-right" + const val BOTTOM_LEFT = "bottom-left" + const val BOTTOM_RIGHT = "bottom-right" + } + + object IconTranslateAnchor { + const val MAP = "map" + const val VIEWPORT = "viewport" + } + + init { + val style = holder.map.style + if (style != null) { + style.addImage(Prop.DEFAULT_MARKER_ID, defaultMarkerIcon.bitmap) + } else { + holder.map.getStyle { style -> + style.addImage(Prop.DEFAULT_MARKER_ID, defaultMarkerIcon.bitmap) + } + } + } + + // Ensure marker images exist on the given style (used after style reload). + fun ensureDefaultIcon(style: com.mappls.sdk.maps.Style) { + ensureStyleImages(style) + } + + fun ensureStyleImages(style: com.mappls.sdk.maps.Style) { + val startedAt = SystemClock.elapsedRealtime() + try { + style.addImage(Prop.DEFAULT_MARKER_ID, defaultMarkerIcon.bitmap) + } catch (_: Exception) { + } + + val entities = markerManager.allEntities() + val styleIcons = linkedMapOf() + var nativeMarkerCount = 0 + entities.forEach { entity -> + // Tiled markers have no Mappls Feature and are drawn by MarkerTileRenderer. + // Registering their images with the style is both unnecessary and extremely + // expensive for large data sets (the same bitmap may otherwise be added tens of + // thousands of times during a style reload). + if (entity.marker == null) return@forEach + nativeMarkerCount++ + val icon = entity.state.icon ?: return@forEach + val iconKey = icon.hashCode().toString() + if (!styleIcons.containsKey(iconKey)) { + styleIcons[iconKey] = iconBitmapCache[iconKey] ?: icon.toBitmapIcon().bitmap + } + } + + styleIcons.forEach { (iconKey, bitmap) -> + try { + style.addImage(iconKey, bitmap, false) + } catch (_: Exception) { + } + iconBitmapCache[iconKey] = bitmap + } + } + + private fun decrementIconRef(iconKey: String) { + if (iconKey == Prop.DEFAULT_MARKER_ID) return + val next = (iconRefCounter[iconKey] ?: 0) - 1 + if (next <= 0) { + iconRefCounter.remove(iconKey) + // Mappls can render one frame behind GeoJSON source updates during marker animation. + // Keep images briefly after last use so icon-image references never point at a missing image. + pendingStyleImageRemovals[iconKey] = System.currentTimeMillis() + STYLE_IMAGE_REMOVAL_GRACE_MS + } else { + iconRefCounter[iconKey] = next + } + } + + private fun incrementIconRef(iconKey: String) { + if (iconKey == Prop.DEFAULT_MARKER_ID) return + pendingStyleImageRemovals.remove(iconKey) + iconRefCounter[iconKey] = (iconRefCounter[iconKey] ?: 0) + 1 + } + + override fun setMarkerVisible( + markerEntity: MarkerEntityInterface, + visible: Boolean, + ) { + markerEntity.visible = visible + redraw() + } + + override fun setMarkerPosition( + markerEntity: MarkerEntityInterface, + position: GeoPoint, + ) { + val entities = markerManager.allEntities() + val props = (markerEntity.marker?.properties() ?: JsonObject()).deepCopy() + props.addProperty(Prop.Z_INDEX, MarkerDrawOrder.of(markerEntity.state.zIndex, position, drawOrderFrame)) + val feature = + Feature.fromGeometry( + position.toPoint(), + props, + "marker-${markerEntity.state.id}", + ) + markerEntity.marker = feature + val features = + entities.map { + if (it.state.id == markerEntity.state.id) { + feature + } else { + it.marker + } + } + // Execute directly instead of launching a new coroutine + holder.map.style?.let { style -> + val styleSource = style.getSourceAs(markerLayer.sourceId) + styleSource?.setGeoJson(FeatureCollection.fromFeatures(features)) + } + } + + override suspend fun onAdd( + data: List, + ): List = + withContext(Dispatchers.Main) { + val style = holder.map.style ?: return@withContext emptyList() + + data.forEach { + it.state.icon?.let { icon -> + val iconKey = icon.hashCode().toString() + try { + style.addImage(iconKey, it.bitmapIcon.bitmap, false) + } catch (_: Exception) { + } + iconBitmapCache[iconKey] = it.bitmapIcon.bitmap + if (!iconRefCounter.contains(iconKey)) iconRefCounter[iconKey] = 0 + } + } + + data.map { + val featureId = "marker-${it.state.id}" + val position = GeoPoint.from(it.state.position).toPoint() + val properties = + JsonObject().apply { + if (it.state.icon != null) { + it.state.icon?.let { icon -> + val iconKey = icon.hashCode().toString() + incrementIconRef(iconKey) + addProperty(Prop.ICON_ID, iconKey) + // icon offset property + add(Prop.ICON_ANCHOR, createIconOffset(icon)) + } + } else { + addProperty(Prop.ICON_ID, Prop.DEFAULT_MARKER_ID) + add(Prop.ICON_ANCHOR, getDefaultIconOffsetProperty()) + } + // We don't use the Mappls SDK's scaling system + // addProperty(Prop.SCALE, 1.0) + addProperty(Prop.Z_INDEX, drawOrderOf(it.state)) + } + Feature.fromGeometry(position, properties, featureId) + } + } + + private fun getDefaultIconOffsetProperty(): JsonArray = createIconOffset(defaultMarkerIcon) + + private fun createIconOffset(icon: BitmapIcon): JsonArray = + JsonArray().apply { + add(-(icon.size.width * icon.anchor.x) / ResourceProvider.getDensity()) + add(-(icon.size.height * icon.anchor.y) / ResourceProvider.getDensity()) + } + + private fun createIconOffset(icon: MarkerIconInterface): JsonArray = createIconOffset(icon.toBitmapIcon()) + + override suspend fun onRemove(data: List>) { + data.forEach { entity -> + val iconKey = + entity.marker + ?.properties() + ?.get(Prop.ICON_ID) + ?.asString + ?: entity.state.icon + ?.hashCode() + ?.toString() + if (iconKey != null) { + decrementIconRef(iconKey) + } + } + } + + fun drawDragLayer() { + holder.map.style?.let { + coroutine.launch { + dragLayer.draw(it) + } + } + } + + fun redraw() { + val entities = markerManager.allEntities() + // Get style from controller to use the same instance + holder.map.style?.let { + coroutine.launch { + markerLayer.draw(entities, it) + } + } + } + + // 地図が回ったら、各フィーチャーの並び順キー(symbol-sort-key)を付け直して流し直す。 + override suspend fun applyDrawOrder(entities: List>) { + val target = entities.filter { !it.tiling } + withContext(Dispatchers.Main) { + target.forEach { entity -> + entity.marker?.properties()?.addProperty(Prop.Z_INDEX, drawOrderOf(entity.state)) + } + val style = holder.map.style ?: return@withContext + markerLayer.draw(target, style) + } + } + + override suspend fun onPostProcess() { + val target = markerManager.allEntities().filter { !it.tiling } + + // withContext(Dispatchers.Main) below is a real cross-thread hop when onPostProcess() + // is invoked from a background ingest dispatcher (as the React Native wrapper does for + // large marker batches) rather than already running on Main (as the native Compose + // sample does). That hop, immediately following a large tiled-marker ingest, lines up + // with severe GC stalls on-device even though the Main-side work below is a few ms at + // most - so skip the hop entirely when there's nothing for it to do. + if (markerLayer.wouldSkipDraw(target) && pendingStyleImageRemovals.isEmpty()) { + return + } + + return withContext(Dispatchers.Main) { + val style = holder.map.style ?: return@withContext + markerLayer.draw(target, style) + yield() + + val now = System.currentTimeMillis() + val expired = + pendingStyleImageRemovals + .asSequence() + .filter { (_, deadline) -> deadline <= now } + .map { (key, _) -> key } + .toList() + + expired.forEach { iconKey -> + if (iconRefCounter.containsKey(iconKey)) { + pendingStyleImageRemovals.remove(iconKey) + return@forEach + } + try { + style.removeImage(iconKey) + } catch (_: Exception) { + } finally { + pendingStyleImageRemovals.remove(iconKey) + iconBitmapCache.remove(iconKey) + } + } + } + } + + override suspend fun onChange( + data: List>, + ): List = + withContext(Dispatchers.Main) { + val style = holder.map.style ?: return@withContext emptyList() + + data.map { params -> + val prevFinger = params.prev.fingerPrint + val currFinger = params.current.fingerPrint + val prevProperties = params.prev.marker?.properties() + + val properties = + JsonObject().apply { + // No additional scaling needed - bitmap is created with device density + // and Bitmap.density is set to prevent Mappls's automatic scaling + // addProperty(Prop.SCALE, 1.0) + if (currFinger.icon == prevFinger.icon) { + addProperty( + Prop.ICON_ID, + prevProperties?.get(Prop.ICON_ID)?.asString ?: Prop.DEFAULT_MARKER_ID, + ) + + add( + Prop.ICON_ANCHOR, + prevProperties?.get(Prop.ICON_ANCHOR) ?: getDefaultIconOffsetProperty(), + ) + } else { + val prevIconKey = + prevProperties + ?.get(Prop.ICON_ID) + ?.asString + ?: params.prev.state.icon + ?.hashCode() + ?.toString() + ?: Prop.DEFAULT_MARKER_ID + decrementIconRef(prevIconKey) + + if (currFinger.icon == null) { + addProperty(Prop.ICON_ID, Prop.DEFAULT_MARKER_ID) + add(Prop.ICON_ANCHOR, getDefaultIconOffsetProperty()) + } else { + params.current.state.icon?.let { icon -> + // icon id + val iconKey = icon.hashCode().toString() + style.addImage(iconKey, params.bitmapIcon.bitmap, false) + iconBitmapCache[iconKey] = params.bitmapIcon.bitmap + if (!iconRefCounter.contains(iconKey)) iconRefCounter[iconKey] = 0 + incrementIconRef(iconKey) + addProperty(Prop.ICON_ID, iconKey) + add(Prop.ICON_ANCHOR, createIconOffset(icon)) + } + } + } + addProperty( + Prop.Z_INDEX, + drawOrderOf(params.current.state), + ) + } + + val position = + GeoPoint.from(params.current.state.position).toPoint() + val featureId = "marker-${params.current.state.id}" + Feature.fromGeometry(position, properties, featureId) + } + } + + /** + * ドラッグ対象の入れ替え。 + * + * ドラッグ中のマーカーは通常のレイヤ([markerLayer])から外して専用の + * [dragLayer] へ移す。そうしないと GeoJSON ソースを丸ごと描き直すたびに + * 指の位置と食い違う。以前は各プロバイダのマーカーコントローラと + * ストラテジ用イベントコントローラに同じものが 2 本ずつあった。 + */ + override fun onDragSelectionChanged( + previous: MarkerEntityInterface?, + current: MarkerEntityInterface?, + ) { + if (current == null) { + previous?.let { + dragLayer.updatePosition(GeoPoint.from(it.state.position)) + dragLayer.selected = null + drawDragLayer() + markerManager.registerEntity(it) + redraw() + } + return + } + markerManager.removeEntity(current.state.id) + dragLayer.selected = current + dragLayer.updatePosition(GeoPoint.from(current.state.position)) + redraw() + drawDragLayer() + } + + override fun onDragPositionChanged(position: GeoPointInterface) { + dragLayer.updatePosition(GeoPoint.from(position)) + drawDragLayer() + } +} + +private const val STYLE_IMAGE_REMOVAL_GRACE_MS: Long = 1500L diff --git a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonCompositeRenderer.kt b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonCompositeRenderer.kt new file mode 100644 index 0000000..b64ecca --- /dev/null +++ b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonCompositeRenderer.kt @@ -0,0 +1,78 @@ +package com.mapconductor.mappls.polygon + +import com.mapconductor.core.polygon.PolygonEntityInterface +import com.mapconductor.core.polygon.PolygonOverlayRendererInterface +import com.mapconductor.core.polygon.PolygonState +import com.mapconductor.core.polyline.PolylineEntity +import com.mapconductor.core.polyline.PolylineState +import com.mapconductor.mappls.MapplsActualPolygon +import com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer + +/** + * 塗りと輪郭を 1 つのレンダラとして [com.mapconductor.core.polygon.PolygonController] に渡すための合成レンダラ。 + * + * fill レイヤーは幅 1 px の輪郭しか描けないので、`strokeWidth` を守るために輪郭は + * 別のポリライン(`outline-`)として [outline] で描く。差分計算はコアの + * PolygonController に任せ、ここは「塗りへの指示を輪郭にも写す」ことだけをする。 + * + * 塗りのエンティティはコントローラと同じ [fill] の polygonManager に載る。輪郭は + * [outline] の polylineManager に載り、コントローラからは見えない。 + */ +class MapplsPolygonCompositeRenderer( + val fill: MapplsPolygonOverlayRenderer, + val outline: MapplsPolylineOverlayRenderer, +) : PolygonOverlayRendererInterface { + override suspend fun onAdd(data: List): List { + val polygons = fill.onAdd(data) + data.forEachIndexed { index, params -> + if (polygons[index] != null) putOutline(params.state) + } + return polygons + } + + override suspend fun onChange( + data: List>, + ): List { + val polygons = fill.onChange(data) + data.forEachIndexed { index, params -> + if (polygons[index] != null) putOutline(params.current.state) + } + return polygons + } + + override suspend fun onRemove(data: List>) { + data.forEach { outline.polylineManager.removeEntity(outlineId(it.state.id)) } + // clear() は onPostProcess を呼ばないので、消した結果はここで描き直す。 + fill.onRemove(data) + outline.onPostProcess() + } + + override suspend fun onPostProcess() { + fill.onPostProcess() + outline.onPostProcess() + } + + private suspend fun putOutline(state: PolygonState) { + val outlineState = state.toOutlineState() ?: return + outline.createPolyline(outlineState)?.let { polyline -> + outline.polylineManager.registerEntity(PolylineEntity(polyline = polyline, state = outlineState)) + } + } +} + +private fun outlineId(polygonId: String): String = "outline-$polygonId" + +/** 外周だけを閉じたポリラインにする(穴の輪郭は描かない)。 */ +private fun PolygonState.toOutlineState(): PolylineState? { + if (points.isEmpty()) return null + val closedPoints = if (points.first() != points.last()) points + points.first() else points + return PolylineState( + points = closedPoints, + id = outlineId(id), + strokeColor = strokeColor, + strokeWidth = strokeWidth, + geodesic = geodesic, + zIndex = zIndex, + extra = extra, + ) +} diff --git a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt deleted file mode 100644 index 25bb1a9..0000000 --- a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonConductor.kt +++ /dev/null @@ -1,153 +0,0 @@ -package com.mapconductor.mappls.polygon - -import com.mapconductor.core.controller.OverlayHit -import com.mapconductor.core.controller.OverlayKind -import com.mapconductor.core.controller.SlottedOverlayController -import com.mapconductor.core.features.GeoPointInterface -import com.mapconductor.core.polygon.PolygonEntity -import com.mapconductor.core.polygon.PolygonEntityInterface -import com.mapconductor.core.polygon.PolygonEvent -import com.mapconductor.core.polygon.PolygonState -import com.mapconductor.core.polyline.PolylineEntity -import com.mapconductor.core.polyline.PolylineState -import com.mapconductor.mappls.polyline.MapplsPolylineOverlayRenderer - -class MapplsPolygonConductor( - val polygonOverlay: MapplsPolygonOverlayRenderer, - val polylineOverlay: MapplsPolylineOverlayRenderer, -) : SlottedOverlayController< - PolygonState, - PolygonEntityInterface, - > { - override val zIndex: Int = 2 - - var clickListener: ((PolygonEvent) -> Unit)? = null - - override suspend fun add(data: List) { - val nextIds = data.asSequence().map { it.id }.toSet() - val prevIds = - polygonOverlay.polygonManager - .allEntities() - .asSequence() - .map { it.state.id } - .toSet() - val removeIds = prevIds - nextIds - - removeIds.forEach { id -> - polygonOverlay.polygonManager.removeEntity(id) - polylineOverlay.polylineManager.removeEntity("outline-$id") - } - - data.forEach { polygonState -> - - polygonOverlay.createPolygon(polygonState)?.let { polygon -> - val polygonEntity = - PolygonEntity( - polygon = polygon, - state = polygonState, - ) - polygonOverlay.polygonManager.registerEntity(polygonEntity) - } - - val polylineState = polygonState.toPolylineState() - polylineOverlay.createPolyline(polylineState)?.let { polyline -> - val polylineEntity = - PolylineEntity( - polyline = polyline, - state = polylineState, - ) - polylineOverlay.polylineManager.registerEntity(polylineEntity) - } - } - polygonOverlay.onPostProcess() - polylineOverlay.onPostProcess() - } - - override suspend fun update(state: PolygonState) { - polygonOverlay.createPolygon(state)?.let { polygon -> - val polygonEntity = - PolygonEntity( - polygon = polygon, - state = state, - ) - polygonOverlay.polygonManager.registerEntity(polygonEntity) - } - - val polylineState = state.toPolylineState() - polylineOverlay.createPolyline(polylineState)?.let { polyline -> - val polylineEntity = - PolylineEntity( - polyline = polyline, - state = polylineState, - ) - polylineOverlay.polylineManager.registerEntity(polylineEntity) - } - polygonOverlay.onPostProcess() - polylineOverlay.onPostProcess() - } - - fun dispatchClick(event: PolygonEvent) { - // 配送座標の wrap は PolygonEvent の生成時に一元化済み。 - event.state.onClick?.invoke(event) - clickListener?.invoke(event) - } - - @Suppress("UNCHECKED_CAST") - override fun find(position: GeoPointInterface): PolygonEntityInterface? = - polygonOverlay.polygonManager.find(position) as? PolygonEntityInterface - - override suspend fun clear() { - polygonOverlay.polygonManager.clear() - polylineOverlay.polylineManager.clear() - polygonOverlay.onPostProcess() - polylineOverlay.onPostProcess() - } - - // ── Capable ファサードのスロットとクリックカスケードへの参加 ────────── - // - // このコンダクタはコアの PolygonController を継承していない(ポリゴンの輪郭を - // ポリラインとして描くために polygon と polyline の 2 レンダラを束ねている)。 - // それでも扱いは他プロバイダのポリゴンと同じでなければならないので、 - // スロットの契約はここで自前で満たす。 - // - // 実際、Step 4 でこれを実装し忘れて `hasPolygon` が常に false になり、 - // ポリゴン単体の状態更新が黙って捨てられていた。 - - override val kind: OverlayKind = OverlayKind.Polygon - - override fun has(id: String): Boolean = polygonOverlay.polygonManager.hasEntity(id) - - @Suppress("UNCHECKED_CAST") - override fun setClickListenerAny(listener: Any?) { - clickListener = listener as? ((PolygonEvent) -> Unit) - } - - override fun resolveTap(position: GeoPointInterface): OverlayHit? = - find(position)?.let { entity -> - OverlayHit(OverlayKind.Polygon, position) { - dispatchClick(PolygonEvent(entity.state, position)) - } - } - - override fun destroy() { - // No native resources to clean up for polygons - } -} - -private fun PolygonState.toPolylineState(): PolylineState { - val closedPoints = - if (points.first() != points.last()) { - points + points.first() - } else { - points - } - return PolylineState( - points = closedPoints, - id = "outline-${this.id}", - strokeColor = this.strokeColor, - strokeWidth = this.strokeWidth, - geodesic = this.geodesic, - zIndex = this.zIndex, - extra = this.extra, - ) -} diff --git a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonController.kt b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonController.kt new file mode 100644 index 0000000..83d8507 --- /dev/null +++ b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonController.kt @@ -0,0 +1,24 @@ +package com.mapconductor.mappls.polygon + +import com.mapconductor.core.polygon.PolygonController +import com.mapconductor.mappls.MapplsActualPolygon + +/** + * Mappls 用のポリゴンコントローラ。 + * + * 追加・更新・削除の差分計算、`has`、クリックカスケードはコアの [PolygonController] が担う。 + * 塗りと輪郭(幅のある LineLayer)の 2 系統の描画は [MapplsPolygonCompositeRenderer] が束ねる。 + */ +class MapplsPolygonController( + override val renderer: MapplsPolygonCompositeRenderer, +) : PolygonController(renderer.fill.polygonManager, renderer) { + // 旧 MapplsPolygonConductor と同じ値を保つ。 + override val zIndex: Int = 2 + + override fun destroy() { + super.destroy() + // The outlines live in the outline renderer's manager, which core does not + // know about; a destroyed controller that is still referenced keeps none. + renderer.outline.polylineManager.clear() + } +} diff --git a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonOverlayRenderer.kt index 15f49de..eeb7550 100644 --- a/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/polygon/MapplsPolygonOverlayRenderer.kt @@ -23,10 +23,13 @@ class MapplsPolygonOverlayRenderer( override val holder: MapplsMapViewHolderInterface, override val coroutine: CoroutineScope = CoroutineScope(Dispatchers.Main), ) : AbstractPolygonOverlayRenderer() { + // 消えた分を除いた残りで描き直す。コントローラはこの呼び出しの後で polygonManager から + // 外すので(clear() では onPostProcess も来ない)、ここで除外しておかないと消えずに残る。 override suspend fun onRemove(data: List>) { - coroutine.launch { - holder.map.style?.let { - layer.draw(getAllPolygonEntities(), it) + val polygons = getRemainingPolygonEntities(data) + holder.map.style?.let { + coroutine.launch { + layer.draw(polygons, it) } } } @@ -77,6 +80,16 @@ class MapplsPolygonOverlayRenderer( return polygon } + // Polygons drawn as tiles (PolygonController.tiler) stay in the manager, for + // taps, with no features: their entity's polygon is null. + @Suppress("USELESS_CAST") private fun getAllPolygonEntities(): List> = - polygonManager.allEntities() + polygonManager.allEntities().filter { (it.polygon as MapplsActualPolygon?) != null } + + private fun getRemainingPolygonEntities( + removed: List>, + ): List> { + val removedIds = removed.mapTo(HashSet()) { it.state.id } + return getAllPolygonEntities().filter { it.state.id !in removedIds } + } } diff --git a/src/main/java/com/mapconductor/mappls/polyline/MapplsPolylineOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/polyline/MapplsPolylineOverlayRenderer.kt index 89bc4cf..55f89f8 100644 --- a/src/main/java/com/mapconductor/mappls/polyline/MapplsPolylineOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/polyline/MapplsPolylineOverlayRenderer.kt @@ -67,11 +67,11 @@ class MapplsPolylineOverlayRenderer( private fun getAllPolylineEntities(): List> { // This would need access to the polyline manager // For now, we'll implement a simple workaround - return polylineManager.allEntities() + return polylineManager.allEntities().filter { (it.polyline as MapplsActualPolyline?) != null } } fun redraw() { - val entities = polylineManager.allEntities() + val entities = polylineManager.allEntities().filter { (it.polyline as MapplsActualPolyline?) != null } holder.map.style?.let { coroutine.launch { layer.draw(entities, it) diff --git a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerController.kt b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerController.kt index d75fad1..bc865f5 100644 --- a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerController.kt +++ b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerController.kt @@ -1,10 +1,8 @@ package com.mapconductor.mappls.raster import com.mapconductor.core.raster.RasterLayerController -import com.mapconductor.core.raster.RasterLayerEntity import com.mapconductor.core.raster.RasterLayerManager import com.mapconductor.core.raster.RasterLayerManagerInterface -import com.mapconductor.core.raster.RasterLayerOverlayRendererInterface import com.mapconductor.core.raster.RasterLayerState class MapplsRasterLayerController( @@ -35,27 +33,4 @@ class MapplsRasterLayerController( MapplsRasterHeaderInjector.remove(this) super.destroy() } - - suspend fun reapplyStyle() { - val states = rasterLayerManager.allEntities().map { it.state } - if (states.isEmpty()) return - val addParams = - states.map { state -> - object : RasterLayerOverlayRendererInterface.AddParamsInterface { - override val state: RasterLayerState = state - } - } - val layers = renderer.onAdd(addParams) - layers.forEachIndexed { index, layer -> - layer?.let { - rasterLayerManager.registerEntity( - RasterLayerEntity( - layer = it, - state = states[index], - ), - ) - } - } - renderer.onPostProcess() - } } diff --git a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt index 92eff24..d1aa328 100644 --- a/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt +++ b/src/main/java/com/mapconductor/mappls/raster/MapplsRasterLayerOverlayRenderer.kt @@ -1,11 +1,16 @@ package com.mapconductor.mappls.raster +import com.mapconductor.core.circle.CIRCLE_TILE_LAYER_ID +import com.mapconductor.core.controller.OverlayKind +import com.mapconductor.core.polygon.POLYGON_TILE_LAYER_ID +import com.mapconductor.core.polyline.POLYLINE_TILE_LAYER_ID import com.mapconductor.core.raster.RasterLayerEntityInterface import com.mapconductor.core.raster.RasterLayerOverlayRendererInterface import com.mapconductor.core.raster.RasterLayerSource import com.mapconductor.core.raster.RasterLayerState import com.mapconductor.core.raster.TileScheme import com.mapconductor.mappls.MapplsMapViewHolderInterface +import com.mapconductor.mappls.MapplsOverlayStacking import com.mappls.sdk.maps.style.layers.Property import com.mappls.sdk.maps.style.layers.PropertyFactory import com.mappls.sdk.maps.style.layers.RasterLayer @@ -24,6 +29,12 @@ class MapplsRasterLayerOverlayRenderer( private fun isMarkerTileRaster(state: RasterLayerState): Boolean = state.id.startsWith(MARKER_TILE_RASTER_ID_PREFIX) + private fun isPolygonTileRaster(state: RasterLayerState): Boolean = state.id == POLYGON_TILE_LAYER_ID + + private fun isPolylineTileRaster(state: RasterLayerState): Boolean = state.id == POLYLINE_TILE_LAYER_ID + + private fun isCircleTileRaster(state: RasterLayerState): Boolean = state.id == CIRCLE_TILE_LAYER_ID + override suspend fun onAdd( data: List, ): List = @@ -93,38 +104,33 @@ class MapplsRasterLayerOverlayRenderer( } catch (e: Exception) { Log.w("Mappls", "Failed to add raster source: ${e.message}") } - try { - if (isMarkerTileRaster(state)) { - addLayerForMarkerTile(style, layer) - } else { - style.addLayer(layer) - } - } catch (e: Exception) { - Log.w("Mappls", "Failed to add raster layer: ${e.message}") - } + addToStack(style, layer, state) return handle } - private fun addLayerForMarkerTile( + /** + * 帯の順([MapplsOverlayStacking])で足す。アプリのラスターはラスターの帯 + * (一番下、ベースマップのラベルの下)、マーカーのタイルはマーカーの帯の一番下、 + * ポリゴンのタイルはポリゴンの帯の一番下(画像になったポリゴンであって、地図の画像ではない)。 + */ + private fun addToStack( style: com.mappls.sdk.maps.Style, layer: RasterLayer, + state: RasterLayerState, ) { - // Insert the raster tiles below the marker symbol layer so they don't cover markers, - // but remain above vector overlays that are anchored below markers (polyline/circle/etc). - try { - style.addLayerBelow(layer, MARKERS_LAYER_ID) - return - } catch (_: Exception) { - } - - // Best-effort fallback: place above polylines if marker layer isn't present yet. - try { - style.addLayerAbove(layer, POLYLINE_LAYER_ID) - return - } catch (_: Exception) { - } - - style.addLayer(layer) + val key = + if (isMarkerTileRaster(state)) { + MapplsOverlayStacking.MARKER_TILE + } else if (isPolygonTileRaster(state)) { + MapplsOverlayStacking.POLYGON_TILE + } else if (isCircleTileRaster(state)) { + MapplsOverlayStacking.CIRCLE_TILE + } else if (isPolylineTileRaster(state)) { + MapplsOverlayStacking.POLYLINE_TILE + } else { + MapplsOverlayStacking.key(OverlayKind.RasterLayer, state.zIndex) + } + MapplsOverlayStacking.add(holder.map, style, layer, key) } private fun updateLayer( @@ -145,10 +151,7 @@ class MapplsRasterLayerOverlayRenderer( private fun removeLayer(entity: RasterLayerEntityInterface) { val style = holder.map.style ?: return val handle = entity.layer - try { - style.removeLayer(handle.layerId) - } catch (_: Exception) { - } + MapplsOverlayStacking.remove(holder.map, style, handle.layerId) try { style.removeSource(handle.sourceId) } catch (_: Exception) { @@ -159,16 +162,15 @@ class MapplsRasterLayerOverlayRenderer( val ordered = stateById.values .asSequence() - .filter { !isMarkerTileRaster(it) } + .filter { !isMarkerTileRaster(it) && !isPolygonTileRaster(it) && !isPolylineTileRaster(it) && !isCircleTileRaster(it) } .sortedBy { it.zIndex } .mapNotNull { state -> handleById[state.id]?.let { handle -> state to handle } } .toList() + // zIndex が変わったときのために、いったん外して zIndex の順に入れ直す + // (同じ zIndex なら渡された順)。位置は帯の順で決まる。 ordered.forEach { (_, handle) -> - try { - style.removeLayer(handle.layerId) - } catch (_: Exception) { - } + MapplsOverlayStacking.remove(holder.map, style, handle.layerId) } ordered.forEach { (state, handle) -> @@ -180,10 +182,7 @@ class MapplsRasterLayerOverlayRenderer( if (state.visible) Property.VISIBLE else Property.NONE, ), ) - try { - style.addLayer(layer) - } catch (_: Exception) { - } + addToStack(style, layer, state) } } @@ -214,8 +213,6 @@ class MapplsRasterLayerOverlayRenderer( private companion object { private const val MARKER_TILE_RASTER_ID_PREFIX = "marker-tile-" - private const val MARKERS_LAYER_ID = "markers-layer" - private const val POLYLINE_LAYER_ID = "polyline-layer" } }