fix comments

Signed-off-by: Pablo <pablo@dhis2.org>

commons/build.gradle.kts

@@ -122,6 +122,7 @@ dependencies {
     api(libs.test.espresso.idlingresource)
     api(libs.test.espresso.idlingconcurrent)
     api(libs.analytics.sentry)
+    api(libs.analytics.sentry.compose)
     implementation(libs.github.treeView)
     api(libs.dhis2.mobile.designsystem) {
         isChanging = true

dhis2_android_maps/src/main/java/org/dhis2/maps/api/NominatimGeocoderApi.kt

@@ -1,12 +1,12 @@
 package org.dhis2.maps.api
 
-import io.ktor.http.headers
 import kotlinx.coroutines.delay
 import org.dhis2.commons.extensions.truncate
 import org.dhis2.commons.resources.LocaleSelector
 import org.dhis2.maps.model.NominatimLocation
 import org.hisp.dhis.android.BuildConfig
 import org.hisp.dhis.android.core.D2
+import org.hisp.dhis.android.core.arch.api.RequestBuilder
 import org.hisp.dhis.mobile.ui.designsystem.component.model.LocationItemModel
 import timber.log.Timber
 import java.util.Locale
@@ -122,17 +122,15 @@ class NominatimGeocoderApi(
         }
     }
 
-    private fun customHeaders() {
-        headers {
-            append(
-                HEADER_REFERER,
-                "${BuildConfig.LIBRARY_PACKAGE_NAME}_${BuildConfig.VERSION_NAME}",
-            )
-            append(
-                HEADER_LANGUAGE,
-                localeSelector.getUserLanguage() ?: Locale.getDefault().language,
-            )
-        }
+    private fun RequestBuilder.customHeaders() {
+        header(
+            HEADER_REFERER,
+            "${BuildConfig.LIBRARY_PACKAGE_NAME}_${BuildConfig.VERSION_NAME}",
+        )
+        header(
+            HEADER_LANGUAGE,
+            localeSelector.getUserLanguage() ?: Locale.getDefault().language,
+        )
     }
 
     private fun List<NominatimLocation>.mapNominatimLocationsToLocationItems() =

dhis2_android_maps/src/main/java/org/dhis2/maps/di/Injector.kt

@@ -23,25 +23,27 @@ object Injector {
         initialCoordinates: String?,
     ) = object : ViewModelProvider.Factory {
         override fun <T : ViewModel> create(modelClass: Class<T>): T {
+            val dispatcherProvider = object : DispatcherProvider {
+                override fun io() = Dispatchers.IO
+
+                override fun computation() = Dispatchers.Unconfined
+
+                override fun ui() = Dispatchers.Main
+            }
             return MapSelectorViewModel(
                 featureType = locationType,
                 initialCoordinates = initialCoordinates,
                 mapStyleConfig = MapStyleConfiguration(D2Manager.getD2()),
                 geocoder = GeocoderSearchImpl(
-                    Geocoder(context),
-                    NominatimGeocoderApi(
+                    geocoder = Geocoder(context),
+                    geocoderApi = NominatimGeocoderApi(
                         D2Manager.getD2(),
                         LocaleSelector(context, D2Manager.getD2()),
                     ),
+                    dispatcherProvider = dispatcherProvider,
                 ),
                 searchLocationManager = SearchLocationManager(D2Manager.getD2()),
-                dispatchers = object : DispatcherProvider {
-                    override fun io() = Dispatchers.IO
-
-                    override fun computation() = Dispatchers.Unconfined
-
-                    override fun ui() = Dispatchers.Main
-                },
+                dispatchers = dispatcherProvider,
             ) as T
         }
     }

dhis2_android_maps/src/main/java/org/dhis2/maps/model/MapSelectorScreenActions.kt

@@ -3,13 +3,18 @@ package org.dhis2.maps.model
 import androidx.compose.runtime.Stable
 import androidx.recyclerview.widget.RecyclerView
 import com.mapbox.mapboxsdk.maps.MapView
+import org.hisp.dhis.mobile.ui.designsystem.component.model.LocationItemModel
 
 @Stable
 data class MapSelectorScreenActions(
     val onBackClicked: () -> Unit,
-    val onMapDataUpdated: (MapData) -> Unit,
-    val onLocationButtonClicked: () -> Unit,
     val loadMap: (MapView) -> Unit,
-    val onDoneClicked: (result: String?) -> Unit,
     val configurePolygonInfoRecycler: (RecyclerView) -> Unit,
+    val onClearLocation: () -> Unit,
+    val onSearchLocation: (String) -> Unit,
+    val onLocationSelected: (LocationItemModel) -> Unit,
+    val onSearchCaptureMode: () -> Unit,
+    val onSearchOnAreaClick: () -> Unit,
+    val onMyLocationButtonClick: () -> Unit,
+    val onDoneButtonClick: () -> Unit,
 )

dhis2_android_maps/src/main/java/org/dhis2/maps/usecases/GeocoderSearch.kt

@@ -7,8 +7,7 @@ interface GeocoderSearch {
     suspend fun getLocationFromName(
         name: String,
         visibleRegion: LatLngBounds?,
-        onLocationFound: (List<LocationItemModel>) -> Unit,
-    )
+    ): List<LocationItemModel>
 
     suspend fun getLocationFromLatLng(
         latitude: Double,

dhis2_android_maps/src/main/java/org/dhis2/maps/usecases/GeocoderSearchImpl.kt

@@ -4,40 +4,37 @@ import android.location.Address
 import android.location.Geocoder
 import android.os.Build
 import com.mapbox.mapboxsdk.geometry.LatLngBounds
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import org.dhis2.commons.viewmodel.DispatcherProvider
 import org.dhis2.maps.api.GeocoderApi
 import org.hisp.dhis.mobile.ui.designsystem.component.model.LocationItemModel
 import timber.log.Timber
+import kotlin.coroutines.resume
 
 class GeocoderSearchImpl(
     private val geocoder: Geocoder,
     private val geocoderApi: GeocoderApi,
     private val maxResults: Int = 10,
+    private val dispatcherProvider: DispatcherProvider,
 ) : GeocoderSearch {
 
     override suspend fun getLocationFromName(
         name: String,
         visibleRegion: LatLngBounds?,
-        onLocationFound: (List<LocationItemModel>) -> Unit,
-    ) {
-        val start = System.currentTimeMillis()
-        Timber.tag("LOCATION_SEARCH").d("SEARCH QUERY: $name")
-        try {
-            val results = geocoderApi.searchFor(
+    ): List<LocationItemModel> {
+        return try {
+            geocoderApi.searchFor(
                 name,
                 visibleRegion?.northWest?.latitude,
                 visibleRegion?.northWest?.longitude,
                 visibleRegion?.southEast?.latitude,
                 visibleRegion?.southEast?.longitude,
                 maxResults,
             )
-            Timber.tag("LOCATION_SEARCH").d("SEARCH RESULTS: ${results.size} for query: $name")
-            Timber.tag("LOCATION_SEARCH")
-                .d("SEARCH RESULTS: ${(System.currentTimeMillis() - start) / 1000L}")
-            onLocationFound(results)
         } catch (e: Exception) {
-            Timber.tag("LOCATION_SEARCH").d("SEARCH ERROR: ${e.printStackTrace()}")
             Timber.e(e)
-            defaultSearchLocationProvider(name, onLocationFound)
+            defaultSearchLocationProvider(name)
         }
     }
 
@@ -49,21 +46,20 @@ class GeocoderSearchImpl(
     }
 
     @Suppress("DEPRECATION")
-    private fun defaultSearchLocationProvider(
-        name: String,
-        onLocationFound: (List<LocationItemModel>) -> Unit,
-    ) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            geocoder.getFromLocationName(name, maxResults) { addresses ->
-                onLocationFound(
-                    addresses.mapToLocationItems(),
-                )
+    private suspend fun defaultSearchLocationProvider(name: String): List<LocationItemModel> {
+        return withContext(dispatcherProvider.io()) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                suspendCancellableCoroutine { continuation ->
+                    geocoder.getFromLocationName(name, maxResults) { addresses ->
+                        continuation.resume(addresses.mapToLocationItems())
+                    }
+                    continuation.invokeOnCancellation {
+                        // Optionally cancel Geocoder operation here, if possible
+                    }
+                }
+            } else {
+                geocoder.getFromLocationName(name, maxResults)?.mapToLocationItems() ?: emptyList()
             }
-        } else {
-            val results = geocoder.getFromLocationName(name, maxResults) ?: emptyList()
-            onLocationFound(
-                results.mapToLocationItems(),
-            )
         }
     }
 

dhis2_android_maps/src/main/java/org/dhis2/maps/utils/CoordinateUtils.kt

@@ -1,12 +1,16 @@
 package org.dhis2.maps.utils
 
+import com.google.gson.Gson
 import com.mapbox.geojson.Geometry
 import com.mapbox.geojson.Point
 import com.mapbox.geojson.Polygon
+import org.dhis2.commons.extensions.truncate
 import org.dhis2.maps.extensions.toLatLng
 import org.hisp.dhis.android.core.arch.helpers.GeometryHelper
 import org.hisp.dhis.android.core.common.FeatureType
 
+typealias GeometryCoordinate = String
+
 object CoordinateUtils {
     fun geometryFromStringCoordinates(featureType: FeatureType, coordinates: String?): Geometry? {
         return coordinates?.let {
@@ -23,6 +27,27 @@ object CoordinateUtils {
         }
     }
 
+    fun geometryCoordinates(geometry: Geometry?): GeometryCoordinate? {
+        return when (geometry) {
+            is Point -> {
+                Gson().toJson(
+                    geometry.coordinates().map { coordinate -> coordinate.truncate() },
+                )
+            }
+
+            is Polygon -> {
+                val value = geometry.coordinates().map { polygon ->
+                    polygon.map { point ->
+                        point.coordinates().map { coordinate -> coordinate.truncate() }
+                    }
+                }
+                Gson().toJson(value)
+            }
+
+            else -> null
+        }
+    }
+
     private fun buildPointGeometry(geometry: org.hisp.dhis.android.core.common.Geometry): Geometry {
         return with(GeometryHelper.getPoint(geometry).toLatLng()) {
             Point.fromLngLat(longitude, latitude)

dhis2_android_maps/src/main/java/org/dhis2/maps/utils/MapListeners.kt

@@ -0,0 +1,37 @@
+package org.dhis2.maps.utils
+
+import com.mapbox.android.gestures.MoveGestureDetector
+import com.mapbox.android.gestures.StandardScaleGestureDetector
+import com.mapbox.mapboxsdk.geometry.LatLngBounds
+import com.mapbox.mapboxsdk.maps.MapboxMap
+
+abstract class OnMoveListener : MapboxMap.OnMoveListener {
+    override fun onMoveBegin(detector: MoveGestureDetector) = Unit
+    override fun onMove(detector: MoveGestureDetector) = Unit
+}
+
+abstract class OnScaleListener : MapboxMap.OnScaleListener {
+    override fun onScaleBegin(detector: StandardScaleGestureDetector) = Unit
+    override fun onScale(detector: StandardScaleGestureDetector) = Unit
+}
+
+fun MapboxMap.addMoveListeners(
+    onIdle: (LatLngBounds) -> Unit,
+) {
+    this.addOnCameraIdleListener {
+        onIdle(this.latLngBounds())
+    }
+    this.addOnMoveListener(object : OnMoveListener() {
+        override fun onMoveEnd(detector: MoveGestureDetector) {
+            onIdle(this@addMoveListeners.latLngBounds())
+        }
+    })
+    this.addOnScaleListener(object : OnScaleListener() {
+        override fun onScaleEnd(detector: StandardScaleGestureDetector) {
+            onIdle(this@addMoveListeners.latLngBounds())
+        }
+    })
+    onIdle(this.latLngBounds())
+}
+
+fun MapboxMap.latLngBounds() = projection.visibleRegion.latLngBounds