Check if watch is connected before refreshing

app/src/generic/java/org/tasks/injection/FlavorModule.kt

@@ -4,7 +4,13 @@ import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
-import org.tasks.location.*
+import org.tasks.location.Geocoder
+import org.tasks.location.GeocoderNominatim
+import org.tasks.location.LocationService
+import org.tasks.location.LocationServiceAndroid
+import org.tasks.location.MapFragment
+import org.tasks.location.OsmMapFragment
+import org.tasks.wear.WearRefresher
 
 @Module
 @InstallIn(SingletonComponent::class)
@@ -17,4 +23,9 @@ class FlavorModule {
 
     @Provides
     fun getGeocoder(nominatim: GeocoderNominatim): Geocoder = nominatim
+
+    @Provides
+    fun getWearRefresher(): WearRefresher = object : WearRefresher {
+        override suspend fun refresh() = Unit
+    }
 }

app/src/googleplay/java/org/tasks/injection/FlavorModule.kt

@@ -1,10 +1,16 @@
 package org.tasks.injection
 
+import android.content.Context
+import com.google.android.horologist.annotations.ExperimentalHorologistApi
+import com.google.android.horologist.data.WearDataLayerRegistry
+import com.google.android.horologist.datalayer.phone.PhoneDataLayerAppHelper
 import dagger.Lazy
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineScope
 import org.tasks.location.Geocoder
 import org.tasks.location.GeocoderMapbox
 import org.tasks.location.GoogleMapFragment
@@ -14,6 +20,9 @@ import org.tasks.location.LocationServiceGooglePlay
 import org.tasks.location.MapFragment
 import org.tasks.location.OsmMapFragment
 import org.tasks.play.PlayServices
+import org.tasks.wear.LastUpdateSerializer
+import org.tasks.wear.WearRefresher
+import org.tasks.wear.WearRefresherImpl
 
 @Module
 @InstallIn(SingletonComponent::class)
@@ -34,4 +43,34 @@ class FlavorModule {
 
     @Provides
     fun getGeocoder(mapbox: GeocoderMapbox): Geocoder = mapbox
+
+    @OptIn(ExperimentalHorologistApi::class)
+    @Provides
+    fun wearDataLayerRegistry(
+        @ApplicationContext applicationContext: Context,
+        @ApplicationScope coroutineScope: CoroutineScope,
+    ): WearDataLayerRegistry = WearDataLayerRegistry.fromContext(
+        application = applicationContext,
+        coroutineScope = coroutineScope,
+    ).apply {
+        registerSerializer(LastUpdateSerializer)
+    }
+
+    @OptIn(ExperimentalHorologistApi::class)
+    @Provides
+    fun phoneDataLayerAppHelper(
+        @ApplicationContext applicationContext: Context,
+        wearDataLayerRegistry: WearDataLayerRegistry,
+    ) = PhoneDataLayerAppHelper(
+        context = applicationContext,
+        registry = wearDataLayerRegistry,
+    )
+
+    @OptIn(ExperimentalHorologistApi::class)
+    @Provides
+    fun getWearRefresher(
+        phoneDataLayerAppHelper: PhoneDataLayerAppHelper,
+        wearDataLayerRegistry: WearDataLayerRegistry,
+        @ApplicationScope scope: CoroutineScope,
+    ): WearRefresher = WearRefresherImpl(phoneDataLayerAppHelper, wearDataLayerRegistry, scope)
 }

app/src/googleplay/java/org/tasks/wear/WearDataService.kt

@@ -1,16 +1,12 @@
 package org.tasks.wear
 
-import androidx.datastore.core.DataStore
 import androidx.lifecycle.lifecycleScope
 import com.google.android.horologist.annotations.ExperimentalHorologistApi
-import com.google.android.horologist.data.ProtoDataStoreHelper.protoDataStore
 import com.google.android.horologist.data.WearDataLayerRegistry
 import com.google.android.horologist.datalayer.grpc.server.BaseGrpcDataService
 import com.todoroo.astrid.dao.TaskDao
 import com.todoroo.astrid.service.TaskCompleter
 import dagger.hilt.android.AndroidEntryPoint
-import org.tasks.GrpcProto.LastUpdate
-import org.tasks.LocalBroadcastManager
 import org.tasks.WearServiceGrpcKt
 import org.tasks.preferences.Preferences
 import javax.inject.Inject
@@ -22,11 +18,6 @@ class WearDataService : BaseGrpcDataService<WearServiceGrpcKt.WearServiceCorouti
     @Inject lateinit var taskDao: TaskDao
     @Inject lateinit var preferences: Preferences
     @Inject lateinit var taskCompleter: TaskCompleter
-    @Inject lateinit var localBroadcastManager: LocalBroadcastManager
-
-    private val lastUpdate: DataStore<LastUpdate> by lazy {
-        registry.protoDataStore<LastUpdate>(lifecycleScope)
-    }
 
     override val registry: WearDataLayerRegistry by lazy {
         WearDataLayerRegistry.fromContext(
@@ -42,8 +33,6 @@ class WearDataService : BaseGrpcDataService<WearServiceGrpcKt.WearServiceCorouti
             taskDao = taskDao,
             preferences = preferences,
             taskCompleter = taskCompleter,
-            lastUpdate = lastUpdate,
-            localBroadcastManager = localBroadcastManager,
         )
     }
 }

app/src/googleplay/java/org/tasks/wear/WearRefresherImpl.kt

@@ -0,0 +1,47 @@
+package org.tasks.wear
+
+import androidx.datastore.core.DataStore
+import com.google.android.horologist.annotations.ExperimentalHorologistApi
+import com.google.android.horologist.data.ProtoDataStoreHelper.protoDataStore
+import com.google.android.horologist.data.WearDataLayerRegistry
+import com.google.android.horologist.datalayer.phone.PhoneDataLayerAppHelper
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import org.tasks.GrpcProto.LastUpdate
+import org.tasks.copy
+import timber.log.Timber
+
+@OptIn(ExperimentalHorologistApi::class)
+class WearRefresherImpl(
+    phoneDataLayerAppHelper: PhoneDataLayerAppHelper,
+    private val registry: WearDataLayerRegistry,
+    private val scope: CoroutineScope,
+) : WearRefresher {
+
+    private var watchConnected = false
+
+    init {
+        phoneDataLayerAppHelper
+            .connectedAndInstalledNodes
+            .onEach { nodes ->
+                Timber.d("Connected nodes: ${nodes.joinToString()}")
+                watchConnected = nodes.isNotEmpty()
+            }
+            .launchIn(scope)
+    }
+
+    private val lastUpdate: DataStore<LastUpdate> by lazy {
+        registry.protoDataStore<LastUpdate>(scope)
+    }
+
+    override suspend fun refresh() {
+        if (watchConnected) {
+            lastUpdate.updateData {
+                it.copy {
+                    now = System.currentTimeMillis()
+                }
+            }
+        }
+    }
+}

app/src/googleplay/java/org/tasks/wear/WearService.kt

@@ -1,22 +1,15 @@
 package org.tasks.wear
 
-import android.content.Intent
-import androidx.datastore.core.DataStore
 import com.todoroo.astrid.dao.TaskDao
 import com.todoroo.astrid.service.TaskCompleter
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import org.tasks.GrpcProto
 import org.tasks.GrpcProto.CompleteTaskRequest
 import org.tasks.GrpcProto.CompleteTaskResponse
 import org.tasks.GrpcProto.GetTasksRequest
 import org.tasks.GrpcProto.Task
 import org.tasks.GrpcProto.Tasks
-import org.tasks.LocalBroadcastManager
 import org.tasks.WearServiceGrpcKt
-import org.tasks.copy
 import org.tasks.filters.MyTasksFilter
 import org.tasks.preferences.Preferences
 
@@ -24,28 +17,8 @@ class WearService(
     private val taskDao: TaskDao,
     private val preferences: Preferences,
     private val taskCompleter: TaskCompleter,
-    private val lastUpdate: DataStore<GrpcProto.LastUpdate>,
-    localBroadcastManager: LocalBroadcastManager,
 ) : WearServiceGrpcKt.WearServiceCoroutineImplBase() {
 
-    private val scope = CoroutineScope(Dispatchers.IO)
-
-    init {
-        localBroadcastManager.registerRefreshReceiver(
-            object : android.content.BroadcastReceiver() {
-                override fun onReceive(context: android.content.Context?, intent: Intent?) {
-                    scope.launch {
-                        lastUpdate.updateData {
-                            it.copy {
-                                now = System.currentTimeMillis()
-                            }
-                        }
-                    }
-                }
-            }
-        )
-    }
-
     override suspend fun getTasks(request: GetTasksRequest): Tasks {
         return Tasks.newBuilder()
             .addAllTasks(getTasks())

app/src/main/java/org/tasks/receivers/RefreshReceiver.kt

@@ -6,12 +6,13 @@ import com.todoroo.astrid.provider.Astrid2TaskProvider
 import dagger.hilt.android.AndroidEntryPoint
 import dagger.hilt.android.qualifiers.ApplicationContext
 import org.tasks.R
-import org.tasks.data.dao.TaskDao
 import org.tasks.data.count
+import org.tasks.data.dao.TaskDao
 import org.tasks.injection.InjectingJobIntentService
 import org.tasks.preferences.DefaultFilterProvider
 import org.tasks.preferences.Preferences
 import org.tasks.provider.TasksContentProvider
+import org.tasks.wear.WearRefresher
 import timber.log.Timber
 import javax.inject.Inject
 
@@ -21,6 +22,7 @@ class RefreshReceiver : InjectingJobIntentService() {
     @Inject lateinit var defaultFilterProvider: DefaultFilterProvider
     @Inject lateinit var taskDao: TaskDao
     @Inject lateinit var preferences: Preferences
+    @Inject lateinit var wearRefresher: WearRefresher
 
     override suspend fun doWork(intent: Intent) {
         if (preferences.getBoolean(R.string.p_badges_enabled, true)) {
@@ -34,5 +36,6 @@ class RefreshReceiver : InjectingJobIntentService() {
         } catch (e: Exception) {
             Timber.e(e)
         }
+        wearRefresher.refresh()
     }
 }

app/src/main/java/org/tasks/wear/WearRefresher.kt

@@ -0,0 +1,5 @@
+package org.tasks.wear
+
+interface WearRefresher {
+    suspend fun refresh()
+}