Add OSM attribution

afarber · afarber · commit 1d0d40b6cdd0 · 2025-10-25T22:47:23.000+02:00
diff --git a/docs/TESTING_UNIT.md b/docs/TESTING_UNIT.md
@@ -50,16 +50,18 @@ The `--continue` flag ensures all tests run even if some fail, useful for gettin
 
 ## Test Structure
 
-### Current Test Coverage (72 tests)
+### Current Test Coverage (76 tests)
 
 | Test Class | Tests | Description |
 |------------|-------|-------------|
+| **AttributionOverlayTest** | 4 | Attribution rendering and touch detection |
 | **BitmapDescriptorFactoryTest** | 7 | Marker icon generation with colors |
+| **DiskTileCacheTest** | - | Persistent disk cache with DiskLruCache |
+| **MapControllerTest** | 28 | Zoom, pan, marker management, touch detection |
 | **MarkerTest** | 8 | Marker creation, equality, and properties |
 | **ProjectionTest** | 12 | Web Mercator projection calculations |
-| **TileCacheTest** | 6 | LRU bitmap caching |
+| **TileCacheTest** | 6 | Memory LRU cache behavior |
 | **TileDownloaderTest** | 2 | HTTP tile downloading with mocked Ktor client |
-| **MapControllerTest** | 28 | Zoom, pan, marker management, touch detection |
 | **ViewportCalculatorTest** | 10 | Visible tile calculation |
 
 ### Example Test
@@ -373,20 +375,22 @@ Current coverage includes:
 - Core projection math (Web Mercator)
 - Tile coordinate calculations
 - Marker API and bitmap generation
-- Tile caching logic
+- Memory cache (LRU) behavior
+- Disk cache (persistent storage)
 - Viewport calculation
 - MapController rendering logic
-- Touch gesture handling (marker hit detection)
+- Touch gesture handling (marker and attribution hit detection)
 - Zoom level validation and bounds
 - Network tile downloading (with mocking)
 - Pan offset calculations
+- Attribution overlay rendering and interaction
 
 Future coverage should include:
-- Disk cache implementation tests
 - Tile pre-fetching tests
 - Performance benchmarks
 - Memory usage tests
 - Error recovery scenarios
+- Cache promotion tests (disk to memory)
 
 ## References
 
diff --git a/examples/Example01Pan/src/main/kotlin/de/afarber/openmapview/example01pan/MainActivity.kt b/examples/Example01Pan/src/main/kotlin/de/afarber/openmapview/example01pan/MainActivity.kt
@@ -7,6 +7,8 @@
 
 package de.afarber.openmapview.example01pan
 
+import android.content.Intent
+import android.net.Uri
 import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
@@ -15,6 +17,7 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.viewinterop.AndroidView
 import de.afarber.openmapview.LatLng
 import de.afarber.openmapview.OpenMapView
@@ -37,16 +40,23 @@ class MainActivity : ComponentActivity() {
 
 @Composable
 fun MapViewScreen() {
+    val context = LocalContext.current
     val lifecycleOwner = androidx.lifecycle.compose.LocalLifecycleOwner.current
 
     AndroidView(
-        factory = { context ->
-            OpenMapView(context).apply {
+        factory = { ctx ->
+            OpenMapView(ctx).apply {
                 // Register lifecycle observer for proper cleanup
                 lifecycleOwner.lifecycle.addObserver(this)
 
                 setCenter(LatLng(51.4661, 7.2491)) // Bochum, Germany
                 setZoom(14.0)
+
+                // Set attribution click listener to open OSM copyright page
+                setOnAttributionClickListener {
+                    val intent = Intent(Intent.ACTION_VIEW, Uri.parse("https://www.openstreetmap.org/copyright"))
+                    context.startActivity(intent)
+                }
             }
         },
         modifier = Modifier.fillMaxSize(),
diff --git a/examples/Example02Zoom/src/main/kotlin/de/afarber/openmapview/example02zoom/MainActivity.kt b/examples/Example02Zoom/src/main/kotlin/de/afarber/openmapview/example02zoom/MainActivity.kt
@@ -7,6 +7,8 @@
 
 package de.afarber.openmapview.example02zoom
 
+import android.content.Intent
+import android.net.Uri
 import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
@@ -27,6 +29,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.viewinterop.AndroidView
 import de.afarber.openmapview.LatLng
@@ -51,20 +54,27 @@ class MainActivity : ComponentActivity() {
 
 @Composable
 fun MapViewScreen() {
+    val context = LocalContext.current
     val lifecycleOwner = androidx.lifecycle.compose.LocalLifecycleOwner.current
     var zoomLevel by remember { mutableStateOf(14.0) }
     var mapView: OpenMapView? by remember { mutableStateOf(null) }
 
     Box(modifier = Modifier.fillMaxSize()) {
         AndroidView(
-            factory = { context ->
-                OpenMapView(context).apply {
+            factory = { ctx ->
+                OpenMapView(ctx).apply {
                     // Register lifecycle observer for proper cleanup
                     lifecycleOwner.lifecycle.addObserver(this)
 
                     setCenter(LatLng(51.4661, 7.2491)) // Bochum, Germany
                     setZoom(14.0)
                     mapView = this
+
+                    // Set attribution click listener to open OSM copyright page
+                    setOnAttributionClickListener {
+                        val intent = Intent(Intent.ACTION_VIEW, Uri.parse("https://www.openstreetmap.org/copyright"))
+                        context.startActivity(intent)
+                    }
                 }
             },
             modifier = Modifier.fillMaxSize(),
diff --git a/examples/Example03Markers/src/main/kotlin/de/afarber/openmapview/example03markers/MainActivity.kt b/examples/Example03Markers/src/main/kotlin/de/afarber/openmapview/example03markers/MainActivity.kt
@@ -7,6 +7,8 @@
 
 package de.afarber.openmapview.example03markers
 
+import android.content.Intent
+import android.net.Uri
 import android.os.Bundle
 import android.widget.Toast
 import androidx.activity.ComponentActivity
@@ -112,6 +114,12 @@ fun MapViewScreen() {
                     Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
                     true // Consume the click event
                 }
+
+                // Set attribution click listener to open OSM copyright page
+                setOnAttributionClickListener {
+                    val intent = Intent(Intent.ACTION_VIEW, Uri.parse("https://www.openstreetmap.org/copyright"))
+                    context.startActivity(intent)
+                }
             }
         },
         modifier = Modifier.fillMaxSize(),
diff --git a/openmapview/src/main/kotlin/de/afarber/openmapview/AttributionOverlay.kt b/openmapview/src/main/kotlin/de/afarber/openmapview/AttributionOverlay.kt
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2025 Alexander Farber
+ * SPDX-License-Identifier: MIT
+ *
+ * This file is part of the OpenMapView project (https://github.com/afarber/OpenMapView)
+ */
+
+package de.afarber.openmapview
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.Rect
+import android.text.TextPaint
+
+/**
+ * Attribution overlay displaying OpenStreetMap copyright notice.
+ *
+ * Required by OSM tile usage policy to show attribution on all maps using OSM data.
+ * Renders a semi-transparent background with clickable attribution text in the bottom-right corner.
+ */
+class AttributionOverlay(
+    context: Context,
+) {
+    private val attributionText = "© OpenStreetMap contributors"
+
+    private val textPaint =
+        TextPaint().apply {
+            color = Color.BLACK
+            textSize = 12f * context.resources.displayMetrics.density
+            isAntiAlias = true
+        }
+
+    private val backgroundPaint =
+        Paint().apply {
+            color = Color.argb(180, 255, 255, 255)
+            style = Paint.Style.FILL
+        }
+
+    private val textBounds = Rect()
+    private val padding = (4 * context.resources.displayMetrics.density).toInt()
+
+    var onAttributionClickListener: (() -> Unit)? = null
+
+    init {
+        textPaint.getTextBounds(attributionText, 0, attributionText.length, textBounds)
+    }
+
+    fun draw(
+        canvas: Canvas,
+        viewWidth: Int,
+        viewHeight: Int,
+    ) {
+        val textWidth = textBounds.width()
+        val textHeight = textBounds.height()
+
+        val bgLeft = viewWidth - textWidth - padding * 2
+        val bgTop = viewHeight - textHeight - padding * 2
+        val bgRight = viewWidth
+        val bgBottom = viewHeight
+
+        canvas.drawRect(bgLeft.toFloat(), bgTop.toFloat(), bgRight.toFloat(), bgBottom.toFloat(), backgroundPaint)
+
+        val textX = viewWidth - textWidth - padding
+        val textY = viewHeight - padding
+
+        canvas.drawText(attributionText, textX.toFloat(), textY.toFloat(), textPaint)
+    }
+
+    fun handleTouch(
+        x: Float,
+        y: Float,
+        viewWidth: Int,
+        viewHeight: Int,
+    ): Boolean {
+        val textWidth = textBounds.width()
+        val textHeight = textBounds.height()
+
+        val bgLeft = viewWidth - textWidth - padding * 2
+        val bgTop = viewHeight - textHeight - padding * 2
+        val bgRight = viewWidth
+        val bgBottom = viewHeight
+
+        if (x >= bgLeft && x <= bgRight && y >= bgTop && y <= bgBottom) {
+            onAttributionClickListener?.invoke()
+            return true
+        }
+        return false
+    }
+}
diff --git a/openmapview/src/main/kotlin/de/afarber/openmapview/OpenMapView.kt b/openmapview/src/main/kotlin/de/afarber/openmapview/OpenMapView.kt
@@ -25,6 +25,7 @@ class OpenMapView
     ) : FrameLayout(context, attrs, defStyleAttr),
         DefaultLifecycleObserver {
         private val controller = MapController(context)
+        private val attributionOverlay = AttributionOverlay(context)
         private var lastTouchX = 0f
         private var lastTouchY = 0f
 
@@ -53,6 +54,7 @@ class OpenMapView
         override fun dispatchDraw(canvas: Canvas) {
             super.dispatchDraw(canvas)
             controller.draw(canvas)
+            attributionOverlay.draw(canvas, width, height)
         }
 
         override fun onSizeChanged(
@@ -94,7 +96,14 @@ class OpenMapView
                         val movementDistance = kotlin.math.sqrt((dx * dx + dy * dy).toDouble())
 
                         if (movementDistance < 10) {
-                            // Minimal movement, check for marker touch
+                            // Check attribution overlay first
+                            if (attributionOverlay.handleTouch(event.x, event.y, width, height)) {
+                                controller.commitPan()
+                                invalidate()
+                                return true
+                            }
+
+                            // Check for marker touch
                             val touchedMarker = controller.handleMarkerTouch(event.x, event.y)
                             if (touchedMarker != null) {
                                 val consumed = controller.onMarkerClickListener?.invoke(touchedMarker) ?: false
@@ -150,6 +159,10 @@ class OpenMapView
             controller.onMarkerClickListener = listener
         }
 
+        fun setOnAttributionClickListener(listener: () -> Unit) {
+            attributionOverlay.onAttributionClickListener = listener
+        }
+
         override fun onResume(owner: LifecycleOwner) {
             controller.onResume()
         }
diff --git a/openmapview/src/test/kotlin/de/afarber/openmapview/AttributionOverlayTest.kt b/openmapview/src/test/kotlin/de/afarber/openmapview/AttributionOverlayTest.kt
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2025 Alexander Farber
+ * SPDX-License-Identifier: MIT
+ *
+ * This file is part of the OpenMapView project (https://github.com/afarber/OpenMapView)
+ */
+
+package de.afarber.openmapview
+
+import android.content.Context
+import android.graphics.Canvas
+import androidx.test.core.app.ApplicationProvider
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+@RunWith(RobolectricTestRunner::class)
+class AttributionOverlayTest {
+    private lateinit var context: Context
+    private lateinit var overlay: AttributionOverlay
+
+    @Before
+    fun setup() {
+        context = ApplicationProvider.getApplicationContext()
+        overlay = AttributionOverlay(context)
+    }
+
+    @Test
+    fun `draw renders without crashing`() {
+        val canvas = Canvas()
+        overlay.draw(canvas, 800, 600)
+    }
+
+    @Test
+    fun `handleTouch detects click in bottom right corner`() {
+        val viewWidth = 800
+        val viewHeight = 600
+
+        var clicked = false
+        overlay.onAttributionClickListener = {
+            clicked = true
+        }
+
+        val result = overlay.handleTouch(750f, 580f, viewWidth, viewHeight)
+
+        assertTrue(result, "Touch in attribution area should return true")
+        assertTrue(clicked, "Attribution click listener should be invoked")
+    }
+
+    @Test
+    fun `handleTouch ignores click outside attribution area`() {
+        val viewWidth = 800
+        val viewHeight = 600
+
+        var clicked = false
+        overlay.onAttributionClickListener = {
+            clicked = true
+        }
+
+        val result = overlay.handleTouch(100f, 100f, viewWidth, viewHeight)
+
+        assertFalse(result, "Touch outside attribution area should return false")
+        assertFalse(clicked, "Attribution click listener should not be invoked")
+    }
+
+    @Test
+    fun `handleTouch works without listener set`() {
+        val viewWidth = 800
+        val viewHeight = 600
+
+        val result = overlay.handleTouch(750f, 580f, viewWidth, viewHeight)
+
+        assertTrue(result, "Touch in attribution area should return true even without listener")
+    }
+}
