Merge pull request #137 from garanj/main

Adds check for Wearable API

Author: garanj

watchface/src/main/java/com/android/developers/androidify/watchface/creator/Signer.kt

@@ -39,7 +39,7 @@ import java.security.cert.X509Certificate
 import java.util.Calendar
 import java.util.Date
 
-private val keyAlias : String
+private val keyAlias: String
     get() = "com.android.developers.androidify.ApkSigningKey-" + BuildConfig.BUILD_TYPE
 private val certAlias: String
     get() = "com.android.developers.androidify.Cert-" + BuildConfig.BUILD_TYPE

watchface/src/main/java/com/android/developers/androidify/watchface/transfer/WearAssetTransmitter.kt

@@ -82,20 +82,30 @@ class WearAssetTransmitterImpl @Inject constructor(
      */
     override val watchFaceInstallationUpdates = callbackFlow {
         trySend(WatchFaceInstallationStatus.NotStarted)
-        val listener = MessageClient.OnMessageReceivedListener { event ->
-            if (event.path.contains(transferId)) {
-                val response =
-                    ProtoBuf.decodeFromByteArray<WatchFaceInstallationStatus.Complete>(event.data)
-                if (response.transferId == transferId) {
-                    trySend(response)
+
+        var listener: MessageClient.OnMessageReceivedListener? = null
+
+        /**
+         * Some devices don't have access to Wearable API via Play Services, so it is necessary to
+         * check for this scenario first before trying to use the API.
+         */
+        val apiAvailable = WearableApiAvailability.isAvailable(messageClient)
+        if (apiAvailable) {
+            listener = MessageClient.OnMessageReceivedListener { event ->
+                if (event.path.contains(transferId)) {
+                    val response =
+                        ProtoBuf.decodeFromByteArray<WatchFaceInstallationStatus.Complete>(event.data)
+                    if (response.transferId == transferId) {
+                        trySend(response)
+                    }
                 }
             }
+            messageClient.addListener(listener).await()
         }
-
-        messageClient.addListener(listener).await()
-
         awaitClose {
-            messageClient.removeListener(listener).addOnSuccessListener { }
+            listener?.let {
+                messageClient.removeListener(it).addOnSuccessListener { }
+            }
         }
     }
 

watchface/src/main/java/com/android/developers/androidify/watchface/transfer/WearDeviceRepository.kt

@@ -45,23 +45,39 @@ class WearDeviceRepositoryImpl @Inject constructor(
     private val capabilityClient: CapabilityClient by lazy { Wearable.getCapabilityClient(context) }
 
     override val connectedWatch = callbackFlow {
-        val allDevices = nodeClient.connectedNodes.await().toSet()
-        val reachableCapability =
-            capabilityClient.getCapability(ANDROIDIFY_INSTALLED, CapabilityClient.FILTER_REACHABLE)
-                .await()
+        var capabilityListener: CapabilityClient.OnCapabilityChangedListener? = null
 
-        val installedDevices = reachableCapability.nodes.toSet()
+        /**
+         * Some devices don't have access to Wearable API via Play Services, so it is necessary to
+         * check for this scenario first before trying to use the API.
+         */
+        val apiAvailable = WearableApiAvailability.isAvailable(nodeClient)
+        if (apiAvailable) {
+            val allDevices = nodeClient.connectedNodes.await().toSet()
+            val reachableCapability =
+                capabilityClient.getCapability(
+                    ANDROIDIFY_INSTALLED,
+                    CapabilityClient.FILTER_REACHABLE,
+                )
+                    .await()
 
-        trySend(selectConnectedDevice(installedDevices, allDevices))
+            val installedDevices = reachableCapability.nodes.toSet()
+            trySend(selectConnectedDevice(installedDevices, allDevices))
 
-        val capabilityListener = CapabilityClient.OnCapabilityChangedListener { capabilityInfo ->
-            val installedDevicesUpdated = capabilityInfo.nodes.toSet()
+            capabilityListener =
+                CapabilityClient.OnCapabilityChangedListener { capabilityInfo ->
+                    val installedDevicesUpdated = capabilityInfo.nodes.toSet()
 
-            trySend(selectConnectedDevice(installedDevicesUpdated, allDevices))
+                    trySend(selectConnectedDevice(installedDevicesUpdated, allDevices))
+                }
+            capabilityClient.addListener(capabilityListener, ANDROIDIFY_INSTALLED)
+        } else {
+            trySend(null)
         }
-        capabilityClient.addListener(capabilityListener, ANDROIDIFY_INSTALLED)
         awaitClose {
-            capabilityClient.removeListener(capabilityListener)
+            capabilityListener?.let {
+                capabilityClient.removeListener(it)
+            }
         }
     }
 

watchface/src/main/java/com/android/developers/androidify/watchface/transfer/WearableApiAvailability.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.developers.androidify.watchface.transfer
+
+import android.util.Log
+import com.google.android.gms.common.GoogleApiAvailability
+import com.google.android.gms.common.api.AvailabilityException
+import com.google.android.gms.common.api.GoogleApi
+import kotlinx.coroutines.tasks.await
+
+/**
+ * Checks whether a given Wearable Data Layer API is available on this device.
+ */
+object WearableApiAvailability {
+    suspend fun isAvailable(api: GoogleApi<*>) = try {
+        GoogleApiAvailability.getInstance()
+            .checkApiAvailability(api)
+            .await()
+
+        true
+    } catch (e: AvailabilityException) {
+        Log.d(
+            TAG,
+            "${api.javaClass.simpleName} API is not available in this device.",
+        )
+        false
+    }
+}
+
+private const val TAG = "WearableApiAvailability"