Spatial cache for OsmQuestController, OsmNoteQuestController and MapDataController

app/src/main/java/de/westnordost/streetcomplete/StreetCompleteApplication.kt

@@ -1,12 +1,14 @@
 package de.westnordost.streetcomplete
 
 import android.app.Application
+import android.content.ComponentCallbacks2
 import android.content.SharedPreferences
 import androidx.appcompat.app.AppCompatDelegate
 import androidx.core.content.edit
 import androidx.work.ExistingPeriodicWorkPolicy
 import androidx.work.PeriodicWorkRequest
 import androidx.work.WorkManager
+import de.westnordost.streetcomplete.data.CacheTrimmer
 import de.westnordost.streetcomplete.data.CleanerWorker
 import de.westnordost.streetcomplete.data.Preloader
 import de.westnordost.streetcomplete.data.dbModule
@@ -68,6 +70,7 @@ class StreetCompleteApplication : Application() {
     private val prefs: SharedPreferences by inject()
     private val editHistoryController: EditHistoryController by inject()
     private val userLoginStatusController: UserLoginStatusController by inject()
+    private val cacheTrimmer: CacheTrimmer by inject()
 
     private val applicationScope = CoroutineScope(SupervisorJob() + CoroutineName("Application"))
 
@@ -156,6 +159,20 @@ class StreetCompleteApplication : Application() {
         applicationScope.cancel()
     }
 
+    override fun onTrimMemory(level: Int) {
+        super.onTrimMemory(level)
+        when (level) {
+            ComponentCallbacks2.TRIM_MEMORY_COMPLETE, ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL -> {
+                // very low on memory -> drop caches
+                cacheTrimmer.clearCaches()
+            }
+            ComponentCallbacks2.TRIM_MEMORY_MODERATE, ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW -> {
+                // memory needed, but not critical -> trim only
+                cacheTrimmer.trimCaches()
+            }
+        }
+    }
+
     private fun setDefaultLocales() {
         val locale = getSelectedLocale(this)
         if (locale != null) {

app/src/main/java/de/westnordost/streetcomplete/data/CacheTrimmer.kt

@@ -0,0 +1,19 @@
+package de.westnordost.streetcomplete.data
+
+import de.westnordost.streetcomplete.data.osm.mapdata.MapDataController
+import de.westnordost.streetcomplete.data.quest.VisibleQuestsSource
+
+class CacheTrimmer(
+    private val visibleQuestsSource: VisibleQuestsSource,
+    private val mapDataController: MapDataController,
+) {
+    fun trimCaches() {
+        mapDataController.trimCache()
+        visibleQuestsSource.trimCache()
+    }
+
+    fun clearCaches() {
+        mapDataController.clearCache()
+        visibleQuestsSource.clearCache()
+    }
+}

app/src/main/java/de/westnordost/streetcomplete/data/OsmApiModule.kt

@@ -17,6 +17,7 @@ import org.koin.dsl.module
 
 val osmApiModule = module {
     factory { Cleaner(get(), get(), get()) }
+    factory { CacheTrimmer(get(), get())}
     factory<MapDataApi> { MapDataApiImpl(get()) }
     factory<NotesApi> { NotesApiImpl(get()) }
     factory<TracksApi> { TracksApiImpl(get()) }

app/src/main/java/de/westnordost/streetcomplete/data/osm/mapdata/MapDataController.kt

@@ -6,7 +6,6 @@ import de.westnordost.streetcomplete.data.osm.geometry.ElementGeometry
 import de.westnordost.streetcomplete.data.osm.geometry.ElementGeometryCreator
 import de.westnordost.streetcomplete.data.osm.geometry.ElementGeometryDao
 import de.westnordost.streetcomplete.data.osm.geometry.ElementGeometryEntry
-import de.westnordost.streetcomplete.data.osm.geometry.ElementPointGeometry
 import de.westnordost.streetcomplete.util.ktx.format
 import java.lang.System.currentTimeMillis
 import java.util.concurrent.CopyOnWriteArrayList
@@ -39,27 +38,42 @@ class MapDataController internal constructor(
     }
     private val listeners: MutableList<Listener> = CopyOnWriteArrayList()
 
-    /** update element data because in the given bounding box, fresh data from the OSM API has been
-     *  downloaded */
+    private val cache = MapDataCache(
+        SPATIAL_CACHE_TILE_ZOOM,
+        SPATIAL_CACHE_TILES,
+        SPATIAL_CACHE_INITIAL_CAPACITY
+    ) { bbox ->
+        val elements = elementDB.getAll(bbox)
+        val elementGeometries = geometryDB.getAllEntries(
+            elements.mapNotNull { if (it !is Node) ElementKey(it.type, it.id) else null }
+        )
+        elements to elementGeometries
+    }
+
+    /** update element data with [mapData] in the given [bbox] (fresh data from the OSM API has been
+     *  downloaded) */
     fun putAllForBBox(bbox: BoundingBox, mapData: MutableMapData) {
         val time = currentTimeMillis()
 
         val oldElementKeys: Set<ElementKey>
-        val geometryEntries: List<ElementGeometryEntry>
+        val geometryEntries: Collection<ElementGeometryEntry>
         synchronized(this) {
             // for incompletely downloaded relations, complete the map data (as far as possible) with
             // local data, i.e. with local nodes and ways (still) in local storage
             completeMapData(mapData)
 
-            geometryEntries = mapData.mapNotNull { element ->
-                val geometry = elementGeometryCreator.create(element, mapData, true)
-                geometry?.let { ElementGeometryEntry(element.type, element.id, it) }
-            }
+            geometryEntries = createGeometries(mapData, mapData)
 
+            // don't use cache here, because if not everything is already cached, db call will be faster
             oldElementKeys = elementDB.getAllKeys(mapData.boundingBox!!).toMutableSet()
             for (element in mapData) {
                 oldElementKeys.remove(ElementKey(element.type, element.id))
             }
+
+            // for the cache, use bbox and not mapData.boundingBox because the latter is padded,
+            // see comment for QUEST_FILTER_PADDING
+            cache.update(oldElementKeys, mapData, geometryEntries, bbox)
+
             elementDB.deleteAll(oldElementKeys)
             geometryDB.deleteAll(oldElementKeys)
             geometryDB.putAll(geometryEntries)
@@ -77,25 +91,25 @@ class MapDataController internal constructor(
         onReplacedForBBox(bbox, mapDataWithGeometry)
     }
 
+    /** incorporate the [mapDataUpdates] (data has been updated after upload) */
     fun updateAll(mapDataUpdates: MapDataUpdates) {
         val elements = mapDataUpdates.updated
         // need mapData in order to create (updated) geometry
         val mapData = MutableMapData(elements)
 
         val deletedKeys: List<ElementKey>
-        val geometryEntries: List<ElementGeometryEntry>
+        val geometryEntries: Collection<ElementGeometryEntry>
         synchronized(this) {
             completeMapData(mapData)
 
-            geometryEntries = elements.mapNotNull { element ->
-                val geometry = elementGeometryCreator.create(element, mapData, true)
-                geometry?.let { ElementGeometryEntry(element.type, element.id, geometry) }
-            }
+            geometryEntries = createGeometries(elements, mapData)
 
             val newElementKeys = mapDataUpdates.idUpdates.map { ElementKey(it.elementType, it.newElementId) }
             val oldElementKeys = mapDataUpdates.idUpdates.map { ElementKey(it.elementType, it.oldElementId) }
             deletedKeys = mapDataUpdates.deleted + oldElementKeys
 
+            cache.update(deletedKeys, elements, geometryEntries)
+
             elementDB.deleteAll(deletedKeys)
             geometryDB.deleteAll(deletedKeys)
             geometryDB.putAll(geometryEntries)
@@ -109,6 +123,13 @@ class MapDataController internal constructor(
         onUpdated(updated = mapDataWithGeom, deleted = deletedKeys)
     }
 
+    /** Create ElementGeometryEntries for [elements] using [mapData] to supply the necessary geometry */
+    private fun createGeometries(elements: Iterable<Element>, mapData: MapData): Collection<ElementGeometryEntry> =
+        elements.mapNotNull { element ->
+            val geometry = elementGeometryCreator.create(element, mapData, true)
+            geometry?.let { ElementGeometryEntry(element.type, element.id, geometry) }
+        }
+
     private fun completeMapData(mapData: MutableMapData) {
         val missingNodeIds = mutableListOf<Long>()
         val missingWayIds = mutableListOf<Long>()
@@ -125,70 +146,60 @@ class MapDataController internal constructor(
             }
         }
 
-        val ways = wayDB.getAll(missingWayIds)
+        val ways = getWays(missingWayIds)
         for (way in mapData.ways + ways) {
             for (nodeId in way.nodeIds) {
                 if (mapData.getNode(nodeId) == null) {
                     missingNodeIds.add(nodeId)
                 }
             }
         }
-        val nodes = nodeDB.getAll(missingNodeIds)
+        val nodes = getNodes(missingNodeIds)
 
         mapData.addAll(nodes)
         mapData.addAll(ways)
     }
 
-    fun get(type: ElementType, id: Long): Element? =
-        elementDB.get(type, id)
+    fun get(type: ElementType, id: Long): Element? = cache.getElement(type, id, elementDB::get)
 
-    fun getGeometry(type: ElementType, id: Long): ElementGeometry? =
-        geometryDB.get(type, id)
+    fun getGeometry(type: ElementType, id: Long): ElementGeometry? = cache.getGeometry(type, id, geometryDB::get)
 
-    fun getGeometries(keys: Collection<ElementKey>): List<ElementGeometryEntry> =
-        geometryDB.getAllEntries(keys)
+    fun getGeometries(keys: Collection<ElementKey>): List<ElementGeometryEntry> = cache.getGeometries(keys, geometryDB::getAllEntries)
 
     fun getMapDataWithGeometry(bbox: BoundingBox): MutableMapDataWithGeometry {
         val time = currentTimeMillis()
-        val elements = elementDB.getAll(bbox)
-        /* performance improvement over geometryDB.getAllEntries(elements): no need to query
-           nodeDB twice (once for the element, another time for the geometry */
-        val elementGeometries = geometryDB.getAllEntries(
-            elements.mapNotNull { if (it !is Node) ElementKey(it.type, it.id) else null }
-        ) + elements.mapNotNull { if (it is Node) it.toElementGeometryEntry() else null }
-        val result = MutableMapDataWithGeometry(elements, elementGeometries)
-        result.boundingBox = bbox
-        Log.i(TAG, "Fetched ${elements.size} elements and geometries in ${currentTimeMillis() - time}ms")
+        val result = cache.getMapDataWithGeometry(bbox)
+        Log.i(TAG, "Fetched ${result.size} elements and geometries in ${currentTimeMillis() - time}ms")
+
         return result
     }
 
-    private fun Node.toElementGeometryEntry() =
-        ElementGeometryEntry(type, id, ElementPointGeometry(position))
-
     data class ElementCounts(val nodes: Int, val ways: Int, val relations: Int)
+    // this is used after downloading one tile with auto-download, so we should always have it cached
     fun getElementCounts(bbox: BoundingBox): ElementCounts {
-        val keys = elementDB.getAllKeys(bbox)
+        val data = getMapDataWithGeometry(bbox)
         return ElementCounts(
-            keys.count { it.type == ElementType.NODE },
-            keys.count { it.type == ElementType.WAY },
-            keys.count { it.type == ElementType.RELATION }
+            data.count { it is Node },
+            data.count { it is Way },
+            data.count { it is Relation }
         )
     }
 
-    override fun getNode(id: Long): Node? = nodeDB.get(id)
-    override fun getWay(id: Long): Way? = wayDB.get(id)
-    override fun getRelation(id: Long): Relation? = relationDB.get(id)
+    override fun getNode(id: Long): Node? = get(ElementType.NODE, id) as? Node
+    override fun getWay(id: Long): Way? = get(ElementType.WAY, id) as? Way
+    override fun getRelation(id: Long): Relation? = get(ElementType.RELATION, id) as? Relation
 
-    fun getAll(elementKeys: Collection<ElementKey>): List<Element> = elementDB.getAll(elementKeys)
+    fun getAll(elementKeys: Collection<ElementKey>): List<Element> =
+        cache.getElements(elementKeys, elementDB::getAll)
 
-    fun getNodes(ids: Collection<Long>): List<Node> = nodeDB.getAll(ids)
-    fun getWays(ids: Collection<Long>): List<Way> = wayDB.getAll(ids)
-    fun getRelations(ids: Collection<Long>): List<Relation> = relationDB.getAll(ids)
+    fun getNodes(ids: Collection<Long>): List<Node> = cache.getNodes(ids, nodeDB::getAll)
+    fun getWays(ids: Collection<Long>): List<Way> = cache.getWays(ids, wayDB::getAll)
+    fun getRelations(ids: Collection<Long>): List<Relation> = cache.getRelations(ids, relationDB::getAll)
 
-    override fun getWaysForNode(id: Long): List<Way> = wayDB.getAllForNode(id)
-    override fun getRelationsForNode(id: Long): List<Relation> = relationDB.getAllForNode(id)
-    override fun getRelationsForWay(id: Long): List<Relation> = relationDB.getAllForWay(id)
-    override fun getRelationsForRelation(id: Long): List<Relation> = relationDB.getAllForRelation(id)
+    override fun getWaysForNode(id: Long): List<Way> = cache.getWaysForNode(id, wayDB::getAllForNode)
+    override fun getRelationsForNode(id: Long): List<Relation> = cache.getRelationsForNode(id, relationDB::getAllForNode)
+    override fun getRelationsForWay(id: Long): List<Relation> = cache.getRelationsForWay(id, relationDB::getAllForWay)
+    override fun getRelationsForRelation(id: Long): List<Relation> = cache.getRelationsForRelation(id, relationDB::getAllForRelation)
 
     override fun getWayComplete(id: Long): MapData? {
         val way = getWay(id) ?: return null
@@ -214,6 +225,7 @@ class MapDataController internal constructor(
             elements = elementDB.getIdsOlderThan(timestamp, limit)
             if (elements.isEmpty()) return 0
 
+            cache.update(deletedKeys = elements)
             elementCount = elementDB.deleteAll(elements)
             geometryCount = geometryDB.deleteAll(elements)
             createdElementsController.deleteAll(elements)
@@ -226,12 +238,19 @@ class MapDataController internal constructor(
     }
 
     fun clear() {
-        elementDB.clear()
-        geometryDB.clear()
-        createdElementsController.clear()
+        synchronized(this) {
+            clearCache()
+            elementDB.clear()
+            geometryDB.clear()
+            createdElementsController.clear()
+        }
         onCleared()
     }
 
+    fun clearCache() = synchronized(this) { cache.clear() }
+
+    fun trimCache() = synchronized(this) { cache.trim(SPATIAL_CACHE_TILES / 3) }
+
     fun addListener(listener: Listener) {
         listeners.add(listener)
     }
@@ -260,3 +279,15 @@ class MapDataController internal constructor(
         private const val TAG = "MapDataController"
     }
 }
+
+// StyleableOverlayManager loads z16 tiles, but we want smaller tiles. Small tiles make db fetches for
+// typical getMapDataWithGeometry calls noticeably faster than z16, as they usually only require a small area.
+private const val SPATIAL_CACHE_TILE_ZOOM = 17
+
+// Three times the maximum number of tiles that can be loaded at once in StyleableOverlayManager (translated from z16 tiles).
+// We don't want to drop tiles from cache already when scrolling the map just a bit, especially
+// considering automatic trim may temporarily reduce cache size to 2/3 of maximum.
+private const val SPATIAL_CACHE_TILES = 192
+
+// In a city this is roughly the number of nodes in ~20-40 z16 tiles
+private const val SPATIAL_CACHE_INITIAL_CAPACITY = 100000

app/src/main/java/de/westnordost/streetcomplete/data/osm/osmquests/OsmQuest.kt

@@ -17,13 +17,13 @@ data class OsmQuest(
     override val geometry: ElementGeometry
 ) : Quest, OsmQuestDaoEntry {
 
-    override val key: OsmQuestKey get() = OsmQuestKey(elementType, elementId, questTypeName)
+    override val key: OsmQuestKey by lazy { OsmQuestKey(elementType, elementId, questTypeName) }
 
     override val questTypeName: String get() = type.name
 
     override val position: LatLon get() = geometry.center
 
-    override val markerLocations: Collection<LatLon> get() {
+    override val markerLocations: Collection<LatLon> by lazy {
         if (geometry is ElementPolylinesGeometry) {
             val polyline = geometry.polylines[0]
             val length = polyline.measuredLength()
@@ -36,13 +36,13 @@ data class OsmQuest(
                 val between = (length - (2 * MARKER_FROM_END_DISTANCE)) / (count - 1)
                 // space markers `between` apart, starting with `MARKER_FROM_END_DISTANCE` (the
                 // final marker will end up at `MARKER_FROM_END_DISTANCE` from the other end)
-                return polyline.pointsOnPolylineFromStart(
+                return@lazy polyline.pointsOnPolylineFromStart(
                     (0 until count).map { MARKER_FROM_END_DISTANCE + (it * between) }
                 )
             }
         }
         // fall through to a single marker in the middle
-        return listOf(position)
+        listOf(position)
     }
 }
 

app/src/main/java/de/westnordost/streetcomplete/data/osmnotes/notequests/OsmNoteQuest.kt

@@ -13,7 +13,7 @@ data class OsmNoteQuest(
     override val position: LatLon
 ) : Quest {
     override val type: QuestType get() = OsmNoteQuestType
-    override val key: OsmNoteQuestKey get() = OsmNoteQuestKey(id)
-    override val markerLocations: Collection<LatLon> get() = listOf(position)
+    override val key: OsmNoteQuestKey by lazy { OsmNoteQuestKey(id) }
+    override val markerLocations: Collection<LatLon> by lazy { listOf(position) }
     override val geometry: ElementGeometry get() = ElementPointGeometry(position)
 }