diff --git a/src/main/java/com/mapconductor/compose/AddProgress.kt b/src/main/java/com/mapconductor/compose/AddProgress.kt index 2737438..d883ee9 100644 --- a/src/main/java/com/mapconductor/compose/AddProgress.kt +++ b/src/main/java/com/mapconductor/compose/AddProgress.kt @@ -3,6 +3,7 @@ package com.mapconductor.compose import android.os.SystemClock import androidx.compose.runtime.Composable import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.SideEffect import androidx.compose.runtime.remember import androidx.compose.runtime.rememberCoroutineScope @@ -12,6 +13,9 @@ import com.mapconductor.core.OverlayAddedListeners import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Job import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.flow.distinctUntilChanged import kotlinx.coroutines.launch /** @@ -20,20 +24,25 @@ import kotlinx.coroutines.launch * nothing until they are drawn, and these say that work is going on. * * "On the map" is what each state's `onAdded` means: drawn natively, or, for a - * state drawn in tiles, its tiles handed to the map (their images may still be - * loading). + * state drawn in tiles, its tiles handed to the map. The work does not end + * there for tiles, so the collection also counts as busy while its tiles are + * being drawn ([drawingChanged]): after a filter change, and while the camera + * moves to where tiles are not drawn yet. * - * - `onAddStart(total)`: a list brought states that are not on the map yet; - * `total` is how many. + * - `onAddStart(total)`: a list was handed over, or tiles have been drawn for + * [DRAW_START_DELAY_MS] without one; `total` is how many states the list + * brought that are not on the map yet (0 when it only removed or updated + * states, or for tiles alone). * - `onAddProgress(added, total)`: how many of them are on the map so far, at - * most every 100 ms, and once more with `added == total` before the end. - * - `onAddEnd(total)`: all of them are on the map. A state taken out of the - * list before it got there no longer counts against the end. + * most every 100 ms, and once more with `added == total` before the end + * when `total` is not 0. + * - `onAddEnd(total)`: all of them are on the map and nothing has been drawn + * for [SETTLE_MS]. A state taken out of the list before it got there no + * longer counts against the end. * * A list that brings new states while an earlier one is still being added * starts over: a new `onAddStart` with only the new states, and no `onAddEnd` - * for the earlier list. A list that only updates or removes states calls - * nothing. All three run on the main thread. + * for the earlier list. All three run on the main thread. */ @InternalMapConductorApi internal class AddProgressTracker( @@ -57,6 +66,20 @@ internal class AddProgressTracker( private var lastProgressAt = Long.MIN_VALUE / 2 private var timer: Job? = null + /** Between an onAddStart and its onAddEnd. */ + private var started = false + + /** The last list had states: an empty list after an empty one hands nothing over. */ + private var hadStates = false + + /** The collection's tiles are being drawn (or its tiler is taking a list). */ + private var drawing = false + + /** When the last reason to be busy ended: a hand-over, the last arrival, drawing stopping. */ + private var quietSince = Long.MIN_VALUE / 2 + private var settle: Job? = null + private var drawStart: Job? = null + /** * The states of [states] whose id is not in [prevIds], or none when no one * listens. Call it off the main thread; it walks the whole list. @@ -77,6 +100,9 @@ internal class AddProgressTracker( nextIds: Set, newStates: List, ) { + val hadStates = this.hadStates + this.hadStates = states.isNotEmpty() + if (states.isEmpty() && !hadStates) return if (pending.isNotEmpty()) { val before = pending.size pending.keys.retainAll(nextIds) @@ -86,20 +112,26 @@ internal class AddProgressTracker( if (pending.isNotEmpty() && newStates.isEmpty()) { for (state in states) if (state.id in pending) pending[state.id] = state } - if (newStates.isEmpty()) finishIfDone() } - if (newStates.isEmpty()) return - timer?.cancel() - timer = null - // Room for every state without a resize at the 0.75 load factor, and no more. - pending = - HashMap((newStates.size / 0.75f).toInt() + 1).apply { - for (s in newStates) put(s.id, s) - } - total = newStates.size - added = 0 - lastProgressAt = Long.MIN_VALUE / 2 - onAddStart?.invoke(total) + quietSince = now() + if (newStates.isNotEmpty()) { + timer?.cancel() + timer = null + // Room for every state without a resize at the 0.75 load factor, and no more. + pending = + HashMap((newStates.size / 0.75f).toInt() + 1).apply { + for (s in newStates) put(s.id, s) + } + total = newStates.size + added = 0 + lastProgressAt = Long.MIN_VALUE / 2 + begin(total) + } else if (!started) { + total = 0 + added = 0 + begin(0) + } + scheduleSettle() } /** States reached the map (any collection's, any map's: only ours count). */ @@ -114,22 +146,86 @@ internal class AddProgressTracker( } } if (!hit) return - if (pending.isEmpty()) finishIfDone() else reportProgress() + if (pending.isEmpty()) { + // A HashMap keeps its table at the largest size it reached. + pending = HashMap() + quietSince = now() + scheduleSettle() + } else { + reportProgress() + } + } + + /** Whether the collection's tiles are being drawn now. */ + fun drawingChanged(drawing: Boolean) { + if (drawing == this.drawing) return + this.drawing = drawing + if (drawing) { + settle?.cancel() + settle = null + if (!started && drawStart == null) { + drawStart = + scope.launch { + delay(DRAW_START_DELAY_MS) + drawStart = null + if (this@AddProgressTracker.drawing && !started) { + total = 0 + added = 0 + begin(0) + } + } + } + } else { + drawStart?.cancel() + drawStart = null + quietSince = now() + scheduleSettle() + } } fun dispose() { timer?.cancel() timer = null + settle?.cancel() + settle = null + drawStart?.cancel() + drawStart = null pending = HashMap() } - private fun finishIfDone() { - if (pending.isNotEmpty()) return - pending = HashMap() + private fun begin(total: Int) { + started = true + drawStart?.cancel() + drawStart = null + onAddStart?.invoke(total) + } + + private fun scheduleSettle() { + if (!started) return + settle?.cancel() + settle = + scope.launch { + delay(SETTLE_MS) + settle = null + finishIfIdle() + } + } + + private fun finishIfIdle() { + if (!started || drawing || pending.isNotEmpty()) return + val wait = quietSince + SETTLE_MS - now() + if (wait > 0) { + scheduleSettle() + return + } timer?.cancel() timer = null - onAddProgress?.invoke(total, total) - onAddEnd?.invoke(total) + started = false + val count = total + total = 0 + added = 0 + if (count > 0) onAddProgress?.invoke(count, count) + onAddEnd?.invoke(count) } private fun reportProgress() { @@ -154,18 +250,29 @@ internal class AddProgressTracker( } @InternalMapConductorApi - private companion object { + companion object { const val PROGRESS_INTERVAL_MS = 100L + + /** Drawing alone counts as work only once it has lasted this long: a camera move over cached tiles does not. */ + const val DRAW_START_DELAY_MS = 200L + + /** Quiet this long -- nothing handed over, arriving or drawn -- before onAddEnd. */ + const val SETTLE_MS = 400L } } -/** The tracker for one collection, listening only while one of the callbacks is set. */ +/** + * The tracker for one collection, listening only while one of the callbacks + * is set. [activity] says whether the map's tilers for this kind of overlay + * are drawing (see `BaseMapViewController.tileActivity`). + */ @InternalMapConductorApi @Composable internal fun rememberAddProgress( onAddStart: ((total: Int) -> Unit)?, onAddProgress: ((added: Int, total: Int) -> Unit)?, onAddEnd: ((total: Int) -> Unit)?, + activity: List> = emptyList(), ): AddProgressTracker { val scope = rememberCoroutineScope() val tracker = remember { AddProgressTracker(scope) } @@ -179,6 +286,12 @@ internal fun rememberAddProgress( val remove = if (wanted) OverlayAddedListeners.add(tracker::arrived) else null onDispose { remove?.invoke() } } + LaunchedEffect(tracker, wanted, activity) { + if (!wanted || activity.isEmpty()) return@LaunchedEffect + combine(activity) { busy -> busy.any { it } } + .distinctUntilChanged() + .collect { tracker.drawingChanged(it) } + } DisposableEffect(tracker) { onDispose { tracker.dispose() } } return tracker } diff --git a/src/main/java/com/mapconductor/compose/OverlayTileActivity.kt b/src/main/java/com/mapconductor/compose/OverlayTileActivity.kt new file mode 100644 index 0000000..7bc837e --- /dev/null +++ b/src/main/java/com/mapconductor/compose/OverlayTileActivity.kt @@ -0,0 +1,15 @@ +package com.mapconductor.compose + +import androidx.compose.runtime.compositionLocalOf +import com.mapconductor.core.InternalMapConductorApi +import com.mapconductor.core.controller.OverlayKind +import kotlinx.coroutines.flow.StateFlow + +/** + * Whether this map's tilers of each overlay kind are busy, for the collections' + * onAddStart / onAddEnd (see [AddProgressTracker]). Nothing outside a map view + * that provides it: the collections then go by their hand-overs alone. + */ +@InternalMapConductorApi +val LocalOverlayTileActivity = + compositionLocalOf<(OverlayKind) -> List>> { { emptyList() } } diff --git a/src/main/java/com/mapconductor/compose/circle/CircleCompose.kt b/src/main/java/com/mapconductor/compose/circle/CircleCompose.kt index 263883e..42fc93f 100644 --- a/src/main/java/com/mapconductor/compose/circle/CircleCompose.kt +++ b/src/main/java/com/mapconductor/compose/circle/CircleCompose.kt @@ -1,5 +1,7 @@ package com.mapconductor.compose.circle +import com.mapconductor.compose.LocalOverlayTileActivity +import com.mapconductor.core.controller.OverlayKind import com.mapconductor.compose.rememberAddProgress import androidx.compose.runtime.Composable import androidx.compose.runtime.DisposableEffect @@ -66,7 +68,9 @@ fun MapViewScope.Circles( val prevIdsState = remember { mutableStateOf>(emptySet()) } // The membership this Circles() last published as its own list, while it is still the published one. val ownList = remember { arrayOfNulls>(1) } - val progress = rememberAddProgress(onAddStart, onAddProgress, onAddEnd) + val activityOf = LocalOverlayTileActivity.current + val tileActivity = remember(activityOf) { activityOf(OverlayKind.Circle) } + val progress = rememberAddProgress(onAddStart, onAddProgress, onAddEnd, tileActivity) val tracking = onAddStart != null || onAddProgress != null || onAddEnd != null LaunchedEffect(states) { diff --git a/src/main/java/com/mapconductor/compose/map/MapViewBase.kt b/src/main/java/com/mapconductor/compose/map/MapViewBase.kt index d049d37..b9e5fc7 100644 --- a/src/main/java/com/mapconductor/compose/map/MapViewBase.kt +++ b/src/main/java/com/mapconductor/compose/map/MapViewBase.kt @@ -1,5 +1,8 @@ package com.mapconductor.compose.map +import com.mapconductor.core.controller.overlayTileActivity +import com.mapconductor.core.controller.OverlayKind +import com.mapconductor.compose.LocalOverlayTileActivity import androidx.compose.foundation.background import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.fillMaxSize @@ -297,6 +300,10 @@ fun < subcompose("slotid") { @Suppress("UNUSED_VARIABLE") // KtLint: backing property rule workaround val localController = controllerRef.value ?: return@subcompose + val tileActivityOf = + remember(localController) { + { kind: OverlayKind -> (localController as? BaseMapViewController)?.overlayTileActivity(kind).orEmpty() } + } // 子コンポーネントを収集する // **ここで初めて CompositionLocalProvider を差し込む** @@ -304,6 +311,7 @@ fun < LocalMapOverlayRegistry provides registry, LocalMapServiceRegistry provides state.serviceRegistry, LocalMapViewController provides localController, + LocalOverlayTileActivity provides tileActivityOf, LocalMarkerCollector provides scope.markerCollector, LocalInfoBubbleCollector provides scope.bubbleFlow, LocalCircleCollector provides scope.circleCollector, diff --git a/src/main/java/com/mapconductor/compose/polygon/PolygonComponent.kt b/src/main/java/com/mapconductor/compose/polygon/PolygonComponent.kt index 2b0684d..91a958e 100644 --- a/src/main/java/com/mapconductor/compose/polygon/PolygonComponent.kt +++ b/src/main/java/com/mapconductor/compose/polygon/PolygonComponent.kt @@ -1,5 +1,7 @@ package com.mapconductor.compose.polygon +import com.mapconductor.compose.LocalOverlayTileActivity +import com.mapconductor.core.controller.OverlayKind import com.mapconductor.compose.rememberAddProgress import androidx.compose.runtime.Composable import androidx.compose.runtime.DisposableEffect @@ -64,7 +66,9 @@ fun MapViewScope.Polygons( ) { val collector = LocalPolygonCollector.current val prevIdsState = remember { mutableStateOf>(emptySet()) } - val progress = rememberAddProgress(onAddStart, onAddProgress, onAddEnd) + val activityOf = LocalOverlayTileActivity.current + val tileActivity = remember(activityOf) { activityOf(OverlayKind.Polygon) } + val progress = rememberAddProgress(onAddStart, onAddProgress, onAddEnd, tileActivity) val tracking = onAddStart != null || onAddProgress != null || onAddEnd != null LaunchedEffect(states) { diff --git a/src/main/java/com/mapconductor/compose/polyline/PolylineComponent.kt b/src/main/java/com/mapconductor/compose/polyline/PolylineComponent.kt index 28c83ed..b1265f0 100644 --- a/src/main/java/com/mapconductor/compose/polyline/PolylineComponent.kt +++ b/src/main/java/com/mapconductor/compose/polyline/PolylineComponent.kt @@ -1,5 +1,7 @@ package com.mapconductor.compose.polyline +import com.mapconductor.compose.LocalOverlayTileActivity +import com.mapconductor.core.controller.OverlayKind import com.mapconductor.compose.rememberAddProgress import androidx.compose.runtime.Composable import androidx.compose.runtime.DisposableEffect @@ -63,7 +65,9 @@ fun MapViewScope.Polylines( ) { val collector = LocalPolylineCollector.current val prevIdsState = remember { mutableStateOf>(emptySet()) } - val progress = rememberAddProgress(onAddStart, onAddProgress, onAddEnd) + val activityOf = LocalOverlayTileActivity.current + val tileActivity = remember(activityOf) { activityOf(OverlayKind.Polyline) } + val progress = rememberAddProgress(onAddStart, onAddProgress, onAddEnd, tileActivity) val tracking = onAddStart != null || onAddProgress != null || onAddEnd != null LaunchedEffect(states) { diff --git a/src/test/java/com/mapconductor/compose/AddProgressTrackerTest.kt b/src/test/java/com/mapconductor/compose/AddProgressTrackerTest.kt index 4a43d8f..9e54f35 100644 --- a/src/test/java/com/mapconductor/compose/AddProgressTrackerTest.kt +++ b/src/test/java/com/mapconductor/compose/AddProgressTrackerTest.kt @@ -11,13 +11,15 @@ import org.junit.Test /** * `Markers` / `Circles` / `Polylines` / `Polygons` の onAddStart / onAddProgress / onAddEnd - * (AddProgressTracker)。js-sdk-react の `addProgress.test.mjs` と同じ内容。 + * (AddProgressTracker)。js-sdk-react の `addProgress.test.mjs`、ios-sdk の + * `AddProgressTests` と同じ内容。 * - * - 地図に未だ無い state を持ち込んだリストで onAddStart(total)。 + * - リストを渡したら onAddStart(total)。total は地図に未だ無い state の数(削除・更新だけなら 0、空のあとの空は何も呼ばない)。 * - 各 state の onAdded と同じ時点で 1 つ数える。途中経過は 100 ms に 1 回まで。 - * - 全部載ったら onAddProgress(total, total) と onAddEnd(total)。 + * - 全部載り、タイルの描画も止まって 400 ms 静かになったら onAddProgress(total, total) と onAddEnd(total)。 + * - タイルの描画だけ(カメラの移動)は 200 ms 続いたら onAddStart(0)。それより短ければ何も呼ばない。 * - 載る前に外された state は数から抜ける。新しい追加は数え直し、前のリストの onAddEnd は来ない。 - * - 更新・削除だけのリストは何も呼ばない。他のコレクション・他の地図の state は数えない。 + * - 他のコレクション・他の地図の state は数えない。 */ @OptIn(ExperimentalCoroutinesApi::class) class AddProgressTrackerTest { @@ -40,12 +42,21 @@ class AddProgressTrackerTest { prevIds = nextIds } + private fun elapse(ms: Long) { + scope.advanceTimeBy(ms) + scope.runCurrent() + } + + private fun settle() = elapse(AddProgressTracker.SETTLE_MS) + @Test - fun `all on the map - start, progress at the total, end`() { + fun `all on the map - start, progress at the total, end once quiet`() { val states = listOf(circle("a"), circle("b"), circle("c")) set(states) tracker.arrived(listOf(states[0])) tracker.arrived(listOf(states[1], states[2])) + assertEquals(listOf("start 3", "progress 1/3"), calls) + settle() assertEquals(listOf("start 3", "progress 1/3", "progress 3/3", "end 3"), calls) } @@ -57,10 +68,10 @@ class AddProgressTrackerTest { tracker.arrived(listOf(states[1])) // held tracker.arrived(listOf(states[2])) // held assertEquals(listOf("start 5", "progress 1/5"), calls) - scope.advanceTimeBy(100) - scope.runCurrent() + elapse(100) assertEquals(listOf("start 5", "progress 1/5", "progress 3/5"), calls) tracker.arrived(listOf(states[3], states[4])) + settle() assertEquals("end 5", calls.last()) } @@ -71,15 +82,17 @@ class AddProgressTrackerTest { tracker.arrived(listOf(a)) set(listOf(a, b)) tracker.arrived(listOf(b)) + settle() assertEquals(listOf("progress 2/2", "end 2"), calls.takeLast(2)) } @Test - fun `removing the rest ends at once`() { + fun `removing the rest ends once quiet`() { val (a, b) = listOf(circle("a"), circle("b")) set(listOf(a, b)) tracker.arrived(listOf(a)) set(listOf(a)) + settle() assertEquals(listOf("progress 1/1", "end 1"), calls.takeLast(2)) } @@ -90,6 +103,7 @@ class AddProgressTrackerTest { val a2 = circle("a") set(listOf(a2)) tracker.arrived(listOf(a2)) + settle() assertEquals(listOf("start 1", "progress 1/1", "end 1"), calls) } @@ -101,17 +115,64 @@ class AddProgressTrackerTest { assertEquals(listOf("start 2", "start 1"), calls) tracker.arrived(listOf(a, b)) tracker.arrived(listOf(c)) + settle() assertEquals(listOf("start 2", "start 1", "progress 1/1", "end 1"), calls) } @Test - fun `updates, removals and other collections' states call nothing`() { + fun `updates and removals start and end with 0, and other collections' states do not count`() { val (a, b) = listOf(circle("a"), circle("b")) set(listOf(a, b)) tracker.arrived(listOf(a, b)) + settle() calls.clear() set(listOf(circle("a"))) // a updated, b removed tracker.arrived(listOf(circle("other"), circle("a"))) + assertEquals(listOf("start 0"), calls) + settle() + assertEquals(listOf("start 0", "end 0"), calls) + } + + @Test + fun `drawing keeps the end waiting until it has been quiet`() { + val a = circle("a") + set(listOf(a)) + tracker.arrived(listOf(a)) + tracker.drawingChanged(true) + elapse(2000) + assertEquals(listOf("start 1"), calls) + tracker.drawingChanged(false) + elapse(AddProgressTracker.SETTLE_MS - 1) + assertEquals(listOf("start 1"), calls) + elapse(1) + assertEquals(listOf("start 1", "progress 1/1", "end 1"), calls) + } + + @Test + fun `drawing alone starts after 200 ms and ends once quiet`() { + tracker.drawingChanged(true) + elapse(AddProgressTracker.DRAW_START_DELAY_MS - 1) + assertEquals(emptyList(), calls) + elapse(1) + assertEquals(listOf("start 0"), calls) + tracker.drawingChanged(false) + settle() + assertEquals(listOf("start 0", "end 0"), calls) + } + + @Test + fun `an empty list after nothing calls nothing`() { + set(emptyList()) + settle() + assertEquals(emptyList(), calls) + } + + @Test + fun `brief drawing calls nothing`() { + tracker.drawingChanged(true) + elapse(AddProgressTracker.DRAW_START_DELAY_MS / 2) + tracker.drawingChanged(false) + elapse(2000) assertEquals(emptyList(), calls) } }