Add smoothness quest

app/src/main/java/de/westnordost/streetcomplete/quests/QuestModule.kt

@@ -104,6 +104,7 @@ import de.westnordost.streetcomplete.quests.shop_type.CheckShopType
 import de.westnordost.streetcomplete.quests.shop_type.SpecifyShopType
 import de.westnordost.streetcomplete.quests.shoulder.AddShoulder
 import de.westnordost.streetcomplete.quests.sidewalk.AddSidewalk
+import de.westnordost.streetcomplete.quests.smoothness.*
 import de.westnordost.streetcomplete.quests.sport.AddSport
 import de.westnordost.streetcomplete.quests.steps_incline.AddStepsIncline
 import de.westnordost.streetcomplete.quests.steps_ramp.AddStepsRamp
@@ -356,6 +357,8 @@ import javax.inject.Singleton
         AddLanes(), // abstreet, certainly most routing engines - often requires way to be split
         AddStreetParking(),
         AddShoulder(),
+        AddRoadSmoothness(),
+        AddPathSmoothness(),
 
         // footways
         AddPathSurface(), // used by OSM Carto, BRouter, OsmAnd, OSRM, graphhopper...

app/src/main/java/de/westnordost/streetcomplete/quests/smoothness/AddPathSmoothness.kt

@@ -0,0 +1,59 @@
+package de.westnordost.streetcomplete.quests.smoothness
+
+import de.westnordost.streetcomplete.R
+import de.westnordost.streetcomplete.data.meta.updateWithCheckDate
+import de.westnordost.streetcomplete.data.osm.osmquests.OsmFilterQuestType
+import de.westnordost.streetcomplete.data.osm.edits.update_tags.StringMapChangesBuilder
+import de.westnordost.streetcomplete.data.user.achievements.QuestTypeAchievement.WHEELCHAIR
+import de.westnordost.streetcomplete.data.user.achievements.QuestTypeAchievement.BICYCLIST
+import de.westnordost.streetcomplete.ktx.arrayOfNotNull
+
+class AddPathSmoothness : OsmFilterQuestType<SmoothnessAnswer>() {
+
+    override val elementFilter = """
+        ways with
+          highway ~ ${ALL_PATHS_EXCEPT_STEPS.joinToString("|")}
+          and surface ~ ${SURFACES_FOR_SMOOTHNESS.joinToString("|")}
+          and access !~ private|no
+          and segregated != yes
+          and (!conveying or conveying = no)
+          and (!indoor or indoor = no)
+          and !cycleway:surface and !footway:surface
+          and (
+            !smoothness
+            or smoothness older today -4 years
+          )
+    """
+
+    override val commitMessage = "Add path smoothness"
+    override val wikiLink = "Key:smoothness"
+    override val icon = R.drawable.ic_quest_path_surface_detail
+    override val isSplitWayEnabled = true
+    override val questTypeAchievements = listOf(WHEELCHAIR, BICYCLIST)
+
+    override fun getTitle(tags: Map<String, String>): Int {
+        val hasName = tags.containsKey("name")
+        val isSquare = tags["area"] == "yes"
+        return when {
+            hasName ->     R.string.quest_smoothness_name_title
+            isSquare ->    R.string.quest_smoothness_square_title
+            else ->        R.string.quest_smoothness_path_title
+        }
+    }
+
+    override fun getTitleArgs(tags: Map<String, String>, featureName: Lazy<String?>): Array<String> =
+        arrayOfNotNull(tags["name"])
+
+    override fun createForm() = AddSmoothnessForm()
+
+    override fun applyAnswerTo(answer: SmoothnessAnswer, changes: StringMapChangesBuilder) {
+        when (answer) {
+            is SmoothnessValueAnswer -> changes.updateWithCheckDate("smoothness", answer.osmValue)
+            is WrongSurfaceAnswer -> changes.delete("surface")
+        }
+    }
+}
+
+// smoothness is not asked for steps
+// "pedestrian" is in here so the path answers are shown instead of road answers (which focus on cars)
+val ALL_PATHS_EXCEPT_STEPS = listOf("footway", "cycleway", "path", "bridleway", "pedestrian")

app/src/main/java/de/westnordost/streetcomplete/quests/smoothness/AddRoadSmoothness.kt

@@ -0,0 +1,66 @@
+package de.westnordost.streetcomplete.quests.smoothness
+
+import de.westnordost.streetcomplete.R
+import de.westnordost.streetcomplete.data.meta.updateWithCheckDate
+import de.westnordost.streetcomplete.data.osm.osmquests.OsmFilterQuestType
+import de.westnordost.streetcomplete.data.osm.edits.update_tags.StringMapChangesBuilder
+import de.westnordost.streetcomplete.data.user.achievements.QuestTypeAchievement.CAR
+import de.westnordost.streetcomplete.data.user.achievements.QuestTypeAchievement.BICYCLIST
+import de.westnordost.streetcomplete.ktx.arrayOfNotNull
+
+class AddRoadSmoothness : OsmFilterQuestType<SmoothnessAnswer>() {
+
+    override val elementFilter = """
+        ways with (
+            highway ~ ${ROADS_TO_ASK_SMOOTHNESS_FOR.joinToString("|")}
+            or highway = service and service !~ driveway|slipway
+          )
+          and surface ~ ${SURFACES_FOR_SMOOTHNESS.joinToString("|")}
+          and (access !~ private|no or (foot and foot !~ private|no))
+          and (
+            !smoothness
+            or smoothness older today -4 years
+          )
+    """
+
+    override val commitMessage = "Add road smoothness"
+    override val wikiLink = "Key:smoothness"
+    override val icon = R.drawable.ic_quest_street_surface_detail
+    override val isSplitWayEnabled = true
+    override val questTypeAchievements = listOf(CAR, BICYCLIST)
+
+    override fun getTitle(tags: Map<String, String>): Int {
+        val hasName = tags.containsKey("name")
+        val isSquare = tags["area"] == "yes"
+        return when {
+            hasName ->     R.string.quest_smoothness_name_title
+            isSquare ->    R.string.quest_smoothness_square_title
+            else ->        R.string.quest_smoothness_road_title
+        }
+    }
+
+    override fun getTitleArgs(tags: Map<String, String>, featureName: Lazy<String?>): Array<String> =
+        arrayOfNotNull(tags["name"])
+
+    override fun createForm() = AddSmoothnessForm()
+
+    override fun applyAnswerTo(answer: SmoothnessAnswer, changes: StringMapChangesBuilder) {
+        when (answer) {
+            is SmoothnessValueAnswer -> changes.updateWithCheckDate("smoothness", answer.osmValue)
+            is WrongSurfaceAnswer -> changes.delete("surface")
+        }
+    }
+}
+
+// surfaces that are actually used in AddSmoothnessForm
+// should only contain values that are in the Surface class
+val SURFACES_FOR_SMOOTHNESS = listOf(
+    "asphalt", "sett", "paving_stones", "compacted", "gravel"
+)
+
+private val ROADS_TO_ASK_SMOOTHNESS_FOR = arrayOf(
+    // "trunk","trunk_link","motorway","motorway_link", // too much, motorways are almost by definition smooth asphalt (or concrete)
+    "primary", "primary_link", "secondary", "secondary_link", "tertiary", "tertiary_link",
+    "unclassified", "residential", "living_street", "pedestrian", "track",
+    // "service", // this is too much, and the information value is very low
+)

app/src/main/java/de/westnordost/streetcomplete/quests/smoothness/AddSmoothnessForm.kt

@@ -0,0 +1,66 @@
+package de.westnordost.streetcomplete.quests.smoothness
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import androidx.appcompat.app.AlertDialog
+import de.westnordost.streetcomplete.R
+import de.westnordost.streetcomplete.quests.AImageListQuestAnswerFragment
+import de.westnordost.streetcomplete.quests.AnswerItem
+import de.westnordost.streetcomplete.quests.surface.Surface
+import de.westnordost.streetcomplete.quests.surface.asItem
+import de.westnordost.streetcomplete.view.image_select.ItemViewHolder
+
+class AddSmoothnessForm : AImageListQuestAnswerFragment<Smoothness, SmoothnessAnswer>() {
+
+    override val descriptionResId = R.string.quest_smoothness_hint
+
+    override val otherAnswers = listOf(
+        AnswerItem(R.string.quest_smoothness_wrong_surface) { surfaceWrong() },
+        AnswerItem(R.string.quest_smoothness_obstacle) { showObstacleHint() }
+    )
+
+    private val surfaceTag get() = osmElement!!.tags["surface"]
+
+    private val highwayTag get() = osmElement!!.tags["highway"]
+
+    override val items get() = Smoothness.values().toItems(requireContext(), surfaceTag!!, highwayTag!!)
+
+    override val itemsPerRow = 1
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        imageSelector.cellLayoutId = R.layout.cell_labeled_icon_select_smoothness
+    }
+
+    override val moveFavoritesToFront = false
+
+    override fun onClickOk(selectedItems: List<Smoothness>) {
+        applyAnswer(SmoothnessValueAnswer(selectedItems.single().osmValue))
+    }
+
+    private fun showObstacleHint() {
+        activity?.let { AlertDialog.Builder(it)
+            .setMessage(R.string.quest_smoothness_obstacle_hint)
+            .setPositiveButton(android.R.string.ok, null)
+            .show()
+        }
+    }
+
+    private fun surfaceWrong() {
+        val surfaceType = Surface.values().find { it.osmValue == surfaceTag }!!
+        showWrongSurfaceDialog(surfaceType)
+    }
+
+    private fun showWrongSurfaceDialog(surface: Surface) {
+        val inflater = LayoutInflater.from(requireContext())
+        val inner = inflater.inflate(R.layout.dialog_quest_smoothness_wrong_surface, null, false)
+        ItemViewHolder(inner.findViewById(R.id.item_view)).bind(surface.asItem())
+
+        AlertDialog.Builder(requireContext())
+            .setView(inner)
+            .setPositiveButton(R.string.quest_generic_hasFeature_yes_leave_note) { _, _ -> composeNote() }
+            .setNegativeButton(R.string.quest_generic_hasFeature_no) { _, _ -> applyAnswer(WrongSurfaceAnswer) }
+            .show()
+    }
+
+}

app/src/main/java/de/westnordost/streetcomplete/quests/smoothness/Smoothness.kt

@@ -0,0 +1,12 @@
+package de.westnordost.streetcomplete.quests.smoothness
+
+enum class Smoothness(val osmValue: String) {
+    EXCELLENT("excellent"),
+    GOOD("good"),
+    INTERMEDIATE("intermediate"),
+    BAD("bad"),
+    VERY_BAD("very_bad"),
+    HORRIBLE("horrible"),
+    VERY_HORRIBLE("very_horrible"),
+    IMPASSABLE("impassable"),
+}

app/src/main/java/de/westnordost/streetcomplete/quests/smoothness/SmoothnessAnswer.kt

@@ -0,0 +1,7 @@
+package de.westnordost.streetcomplete.quests.smoothness
+
+sealed class SmoothnessAnswer
+
+data class SmoothnessValueAnswer(val osmValue: String): SmoothnessAnswer()
+
+object WrongSurfaceAnswer: SmoothnessAnswer()

app/src/main/java/de/westnordost/streetcomplete/quests/smoothness/SmoothnessItem.kt

@@ -0,0 +1,149 @@
+package de.westnordost.streetcomplete.quests.smoothness
+
+import android.content.Context
+import de.westnordost.streetcomplete.R
+import de.westnordost.streetcomplete.quests.smoothness.Smoothness.*
+import de.westnordost.streetcomplete.view.CharSequenceText
+import de.westnordost.streetcomplete.view.ResImage
+import de.westnordost.streetcomplete.view.ResText
+import de.westnordost.streetcomplete.view.image_select.DisplayItem
+import de.westnordost.streetcomplete.view.image_select.Item2
+
+fun Array<Smoothness>.toItems(context: Context, surface: String, highway: String) =
+    mapNotNull { it.asItem(context, surface, highway) }
+
+// return null if not a valid combination
+fun Smoothness.asItem(context: Context, surface: String, highway: String): DisplayItem<Smoothness>? {
+    val imageResId = getImageResId(surface) ?: return null
+    val descriptionResId = getDescriptionResId(surface, highway) ?: return null
+    return Item2(
+        this,
+        ResImage(imageResId),
+        CharSequenceText(context.getString(titleResId) + " " + emoji),
+        ResText(descriptionResId)
+    )
+}
+
+/** return fitting vehicle type emoji that corresponds to the "usable by" column in the wiki */
+val Smoothness.emoji get() = when(this) {
+    EXCELLENT ->     """🛹""" // or 🛼 but it is only available since Android 11
+    GOOD ->          """🛴""" // no emoji for racing bike, would be difficult to tell apart from 🚲
+    INTERMEDIATE ->  """🚲""" // or 🛵 but users are more likely to own a bike than a scooter
+    BAD ->           """🚗""" // or 🛺 but tuk-tuks have actually similar requirements as scooters
+    VERY_BAD ->      """🚙""" // this is a SUV
+    HORRIBLE ->      """🛻""" // no emoji for off-road vehicles but there is one for pick-ups (Android 11)
+    VERY_HORRIBLE -> """🚜"""
+    IMPASSABLE ->    """🚶"""
+}
+
+val Smoothness.titleResId get() = when (this) {
+    EXCELLENT -> R.string.quest_smoothness_title_excellent
+    GOOD -> R.string.quest_smoothness_title_good
+    INTERMEDIATE -> R.string.quest_smoothness_title_intermediate
+    BAD -> R.string.quest_smoothness_title_bad
+    VERY_BAD -> R.string.quest_smoothness_title_very_bad
+    HORRIBLE -> R.string.quest_smoothness_title_horrible
+    VERY_HORRIBLE -> R.string.quest_smoothness_title_very_horrible
+    IMPASSABLE -> R.string.quest_smoothness_title_impassable
+}
+
+fun Smoothness.getDescriptionResId(surface: String, highway: String) = when (this) {
+    EXCELLENT -> when (surface) {
+        // no "excellent" for roads with paving stones
+        "paving_stones" -> R.string.quest_smoothness_description_excellent_paving_stones
+        "asphalt" -> R.string.quest_smoothness_description_excellent
+        else -> null
+    }
+    GOOD -> when (surface) {
+        "paving_stones" -> R.string.quest_smoothness_description_good_paving_stones
+        "sett" -> R.string.quest_smoothness_description_good_sett
+        "asphalt" -> R.string.quest_smoothness_description_good
+        else -> null
+    }
+    INTERMEDIATE -> when (surface) {
+        "paving_stones" -> R.string.quest_smoothness_description_intermediate_paving_stones
+        "sett" -> R.string.quest_smoothness_description_intermediate_sett
+        "compacted", "gravel" -> R.string.quest_smoothness_description_intermediate_compacted_gravel
+        "asphalt" -> when (highway) {
+            in ALL_PATHS_EXCEPT_STEPS -> R.string.quest_smoothness_description_intermediate_path
+            else -> R.string.quest_smoothness_description_intermediate_road
+        }
+        else -> null
+    }
+    BAD -> when (surface) {
+        "sett" -> R.string.quest_smoothness_description_bad_sett
+        "paving_stones" -> R.string.quest_smoothness_description_bad_paving_stones
+        "asphalt", "compacted", "gravel" -> when (highway) {
+            in ALL_PATHS_EXCEPT_STEPS -> R.string.quest_smoothness_description_bad_path
+            else -> R.string.quest_smoothness_description_bad_road
+        }
+        else -> null
+    }
+    VERY_BAD -> when (surface) {
+        "sett" -> R.string.quest_smoothness_description_very_bad_sett
+        "paving_stones" -> R.string.quest_smoothness_description_very_bad_paving_stones
+        else -> when (highway) {
+            in ALL_PATHS_EXCEPT_STEPS -> R.string.quest_smoothness_description_very_bad_path
+            else -> R.string.quest_smoothness_description_very_bad_road
+        }
+    }
+    // split up?
+    HORRIBLE -> R.string.quest_smoothness_description_horrible
+    VERY_HORRIBLE -> R.string.quest_smoothness_description_very_horrible
+    IMPASSABLE -> R.string.quest_smoothness_description_impassable
+}
+
+fun Smoothness.getImageResId(surface: String): Int? = when(surface) {
+    "asphalt" -> asphaltImageResId
+    "sett" -> settImageResId
+    "paving_stones" -> pavingStonesImageResId
+    "compacted" -> compactedImageResId
+    "gravel" -> gravelImageResId
+    else -> null
+}
+
+private val Smoothness.asphaltImageResId get() = when (this) {
+    EXCELLENT -> R.drawable.surface_asphalt_excellent
+    GOOD -> R.drawable.surface_asphalt_good
+    INTERMEDIATE -> R.drawable.surface_asphalt_intermediate
+    BAD -> R.drawable.surface_asphalt_bad
+    VERY_BAD -> R.drawable.surface_asphalt_very_bad
+    else -> null
+}
+
+private val Smoothness.settImageResId get() = when (this) {
+    GOOD -> R.drawable.surface_sett_good
+    INTERMEDIATE -> R.drawable.surface_sett_intermediate
+    BAD -> R.drawable.surface_sett_bad
+    VERY_BAD -> R.drawable.surface_sett_very_bad
+    else -> null
+}
+
+private val Smoothness.pavingStonesImageResId get() = when (this) {
+    EXCELLENT -> R.drawable.surface_paving_stones_excellent
+    GOOD -> R.drawable.surface_paving_stones_good
+    INTERMEDIATE -> R.drawable.surface_paving_stones_intermediate
+    BAD -> R.drawable.surface_paving_stones_bad
+    VERY_BAD -> R.drawable.surface_paving_stones_very_bad
+    else -> null
+}
+
+private val Smoothness.compactedImageResId get() = when (this) {
+    INTERMEDIATE -> R.drawable.surface_compacted_intermediate
+    BAD -> R.drawable.surface_compacted_bad
+    VERY_BAD -> R.drawable.surface_compacted_very_bad
+    HORRIBLE -> R.drawable.surface_unpaved_horrible
+    VERY_HORRIBLE -> R.drawable.surface_unpaved_very_horrible
+    IMPASSABLE -> R.drawable.surface_unpaved_impassable
+    else -> null
+}
+
+private val Smoothness.gravelImageResId get() = when (this) {
+    INTERMEDIATE -> R.drawable.surface_gravel_intermediate
+    BAD -> R.drawable.surface_gravel_bad
+    VERY_BAD -> R.drawable.surface_gravel_very_bad
+    HORRIBLE -> R.drawable.surface_unpaved_horrible
+    VERY_HORRIBLE -> R.drawable.surface_unpaved_very_horrible
+    IMPASSABLE -> R.drawable.surface_unpaved_impassable
+    else -> null
+}