Use || instead of comma conditions in the subjectless when

typing.8 checked WeatherSettingsData.managedLocation, but that only exists once the
user has explicitly picked "managed location" for the provider, so
weatherProviderSettings stayed empty and the guard never fired: the worker kept
requesting a location and retrying every 30s.

The real signal is the provider's own capability. BreezyWeatherProvider.getWeatherData()
is a hardcoded noop that also manages its own location, so add WeatherProvider.isPushBased
and check that instead.

Also stop treating a managed location as "pull nothing": those providers still have data
to fetch, they just resolve the position themselves, so they now take the
WeatherLocation path instead of the auto-location one.

Bump to 1.40.2-typing.9 (versionCode 2026091202).

app/app/build.gradle.kts

@@ -34,8 +34,8 @@ android {
         applicationId = "de.mm20.launcher2"
         minSdk = libs.versions.minSdk.get().toInt()
         targetSdk = libs.versions.targetSdk.get().toInt()
-        versionCode = System.getenv("VERSION_CODE_OVERRIDE")?.toIntOrNull() ?: 2026091201
+        versionCode = System.getenv("VERSION_CODE_OVERRIDE")?.toIntOrNull() ?: 2026091202
-        versionName = "1.40.2-typing.8"
+        versionName = "1.40.2-typing.9"
         signingConfig = signingConfigs.getByName("debug")
     }
 

data/weather/src/main/java/de/mm20/launcher2/weather/WeatherProvider.kt

@@ -11,6 +11,14 @@ interface WeatherProvider {
         return 1000 * 60 * 60L
     }
 
+    /**
+     * Whether this provider pushes weather updates on its own instead of being polled, and
+     * resolves its location itself. [WeatherUpdateWorker] then has nothing to pull and must not
+     * request a location for it.
+     */
+    val isPushBased: Boolean
+        get() = false
+
     suspend fun getWeatherData(location: WeatherLocation): List<Forecast>?
     suspend fun getWeatherData(lat: Double, lon: Double): List<Forecast>?
     suspend fun findLocation(query: String): List<WeatherLocation>

data/weather/src/main/java/de/mm20/launcher2/weather/WeatherRepository.kt

@@ -79,13 +79,12 @@ internal class WeatherRepositoryImpl(
         }
         scope.launch {
             settings.collectLatest {
-                if (it.managedLocation) {
+                val provider = WeatherProvider.getInstance(it.provider)
-                    // The provider resolves its own location and pushes weather updates, so there
+                if (provider.isPushBased) {
-                    // is nothing to poll for.
+                    // The provider sends its updates itself, so there is nothing to poll for.
                     WorkManager.getInstance(context).cancelUniqueWork("weather")
                     return@collectLatest
                 }
-                val provider =  WeatherProvider.getInstance(it.provider)
                 val weatherRequest =
                     PeriodicWorkRequestBuilder<WeatherUpdateWorker>(Duration.ofMillis(provider.getUpdateInterval()))
                         .build()
@@ -218,20 +217,19 @@ class WeatherUpdateWorker(
     override suspend fun doWork(): Result {
         Log.d("WeatherUpdateWorker", "Requesting weather data")
         val settingsData = settings.first()
+        val provider = WeatherProvider.getInstance(settingsData.provider)
 
-        // A provider with a managed location resolves its position itself and pushes weather
+        // A push-based provider sends its updates on its own and resolves its own location
-        // updates instead of being polled (Breezy Weather does both). There is nothing to pull,
+        // (Breezy Weather does both), so there is nothing to pull here. Its getWeatherData()
-        // and its getWeatherData() always returns null - which used to make this worker request a
+        // always returns null, which used to make this worker request a location - registering
-        // location (holding GPS and network listeners for up to ten minutes at a time) and then
+        // GPS and network listeners and holding them for up to ten minutes - and then return
-        // return Result.retry() forever, without ever setting lastUpdate, so the update interval
+        // Result.retry() forever, without ever setting lastUpdate, so the interval check below
-        // check below could never short-circuit it either.
+        // could never short-circuit it either.
-        if (settingsData.managedLocation) {
+        if (provider.isPushBased) {
-            Log.d("WeatherUpdateWorker", "Provider manages its own location, nothing to pull")
+            Log.d("WeatherUpdateWorker", "Provider pushes updates, nothing to pull")
             return Result.success()
         }
 
-        val provider = WeatherProvider.getInstance(settingsData.provider)
-
         val updateInterval = provider.getUpdateInterval()
         val lastUpdate = settingsData.lastUpdate
 
@@ -240,21 +238,26 @@ class WeatherUpdateWorker(
             return Result.failure()
         }
 
-        val weatherData = if (settingsData.autoLocation) {
+        val weatherData = when {
-            val latLon = getLastKnownLocation() ?: settingsData.lastLocation
+            // A managed location means the provider resolves the position itself, so requesting
-            if (latLon == null) {
+            // one here would be wasted work that holds the location stack open.
-                Log.e("WeatherUpdateWorker", "Could not get location")
+            settingsData.managedLocation || !settingsData.autoLocation -> {
-                return Result.failure()
+                val location = settings.location.first()
+                if (location == null) {
+                    Log.e("WeatherUpdateWorker", "Location not set")
+                    return Result.failure()
+                }
+                provider.getWeatherData(location)
             }
-            settings.setLastLocation(latLon)
+            else -> {
-            provider.getWeatherData(latLon.lat, latLon.lon)
+                val latLon = getLastKnownLocation() ?: settingsData.lastLocation
-        } else {
+                if (latLon == null) {
-            val location = settings.location.first()
+                    Log.e("WeatherUpdateWorker", "Could not get location")
-            if (location == null) {
+                    return Result.failure()
-                Log.e("WeatherUpdateWorker", "Location not set")
+                }
-                return Result.failure()
+                settings.setLastLocation(latLon)
+                provider.getWeatherData(latLon.lat, latLon.lon)
             }
-            provider.getWeatherData(location)
         }
 
         return if (weatherData == null) {

data/weather/src/main/java/de/mm20/launcher2/weather/breezy/BreezyWeatherProvider.kt

@@ -20,6 +20,9 @@ class BreezyWeatherProvider(
 ) : WeatherProvider, KoinComponent {
     private val database: AppDatabase by inject()
 
+    // Breezy sends its weather data to us (see pushWeatherData) and manages its own location.
+    override val isPushBased: Boolean = true
+
     override suspend fun getWeatherData(location: WeatherLocation): List<Forecast>? {
         // Noop implementation, because Breezy weather is handled in a special way
         return null