feat(wear): implement live/preview companion sync with rotary scrub and release docs

- add watch live-location to phone live-render pipeline with safe sun-only fallback
- add preview route-gated payload publishing and two-way phone/watch scrub sync
- add watch native eclipse renderer with live/preview mode switching and stale fallback handling
- improve wearable Data Layer reliability with node caching, listener service fallback, and sendMessage bridge API
- extend shared wearable preview payload contracts for travel vectors/contact anchors
- add regression tests for wear live compute, preview payloads, scrub payload parsing, and totality glow blending
- update workflows and docs for wear package/activity wiring and Windows disposable emulator workflow
- bump mobile version to 1.1.26 and update changelog

Author: Lalit Sharma

.github/workflows/eas-build.yml

@@ -729,7 +729,7 @@ jobs:
       #   uses: r0adkll/upload-google-play@v1
       #   with:
       #     serviceAccountJsonPlainText: ${{ secrets.GOOGLE_PLAY_SERVICE_ACCOUNT_JSON }}
-      #     packageName: com.lallimaven.eclipsetimer.wear
+      #     packageName: com.lallimaven.eclipsetimer
       #     releaseFiles: artifacts/submission/${{ steps.artifact_names.outputs.wear_aab }}
       #     track: internal
       #     whatsNewDirectory: ${{ steps.store_notes.outputs.play_whatsnew_dir }}
@@ -739,7 +739,7 @@ jobs:
       #   uses: r0adkll/upload-google-play@v1
       #   with:
       #     serviceAccountJsonPlainText: ${{ secrets.GOOGLE_PLAY_SERVICE_ACCOUNT_JSON }}
-      #     packageName: com.lallimaven.eclipsetimer.wear
+      #     packageName: com.lallimaven.eclipsetimer
       #     releaseFiles: artifacts/submission/${{ steps.artifact_names.outputs.wear_aab }}
       #     track: internal
 

.github/workflows/wearos-emulator-screenshots.yml

@@ -62,7 +62,8 @@ jobs:
     permissions:
       contents: write
     env:
-      BUNDLE_ID: com.lallimaven.eclipsetimer.wear
+      BUNDLE_ID: com.lallimaven.eclipsetimer
+      MAIN_ACTIVITY: com.lallimaven.eclipsetimer.wear.MainActivity
       SENTRY_DISABLE_AUTO_UPLOAD: "true"
       SENTRY_ALLOW_FAILURE: "true"
       SENTRY_CLI_EXECUTABLE: "/usr/bin/true"
@@ -441,7 +442,7 @@ jobs:
           mkdir -p "$shots_dir"
           printf "index,url,file\n" > "$shots_dir/manifest.csv"
 
-          adb -s "$emulator_serial" shell am start -W -n "$BUNDLE_ID/.MainActivity" >/dev/null 2>&1 || true
+          adb -s "$emulator_serial" shell am start -W -n "$BUNDLE_ID/$MAIN_ACTIVITY" >/dev/null 2>&1 || true
           if ! wait_for_app_foreground "$BUNDLE_ID"; then
             echo "::warning::App did not enter the foreground after initial launch."
           fi

CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.26] — 2026-02-24
+
+### Added
+- Added end-to-end Wear companion live pipeline: watch GPS payload publishing, phone-side active-eclipse computation, and live render payload sync with sun-only fallback when no active eclipse is found.
+- Added Wear preview mode synchronization with strict phone `Preview` route gating, preview payload publishing, and two-way preview scrub messaging between phone and watch.
+- Added watch native eclipse renderer (`EclipseRenderView`) with sun/moon drawing and totality ring/corona transitions, plus stale-live fallback handling and status messaging.
+- Added a Windows disposable phone+Wear emulator workflow guide for path-length-safe local native testing (`documents/guides/windows-disposable-phone-wear-emulator.md`).
+
+### Changed
+- Extended wearable shared preview payload schema with travel vector and contact progress anchors so phone and watch preview frames stay aligned while scrubbing.
+- Improved Android Data Layer reliability with node-id caching/retry send flow, a listener service fallback handshake, and JS bridge `sendMessage` support.
+- Updated Wear package/config wiring to use `com.lallimaven.eclipsetimer` package naming in watch build/docs/workflows and to require watch location permissions.
+- Updated phone preview visuals to blend totality ring/corona effects and synchronize scrub progress with watch input.
+- Excluded Android build output folders from Metro resolution to avoid duplicate module/path issues.
+- Bumped `apps/mobile` version to `1.1.26`.
+
+### Tests
+- Added regression tests for wear live payload computation, preview payload generation, preview scrub payload parsing, and totality glow blending behavior.
+
 ## [1.1.25] — 2026-02-24
 
 ### Added

README.md

@@ -341,6 +341,7 @@ The Wear OS companion app is a separate native module (`apps/mobile/android/wear
 
 Use the local simulator build/install/run guide in:
 - [documents/guides/setup-and-development.md#wear-os-companion-on-local-emulator](documents/guides/setup-and-development.md#wear-os-companion-on-local-emulator)
+- [documents/guides/windows-disposable-phone-wear-emulator.md](documents/guides/windows-disposable-phone-wear-emulator.md) for a disposable Windows workflow (`C:\e`) that runs phone and watch emulators together and deletes the copy afterward.
 
 ## Running Tests and Quality Checks
 

apps/mobile/android/app/src/main/AndroidManifest.xml

@@ -32,6 +32,11 @@
         <data android:scheme="eclipsetimer"/>
       </intent-filter>
     </activity>
+    <service android:name=".wearable.WearDataLayerListenerService" android:exported="true">
+      <intent-filter>
+        <action android:name="com.google.android.gms.wearable.BIND_LISTENER"/>
+      </intent-filter>
+    </service>
     <uses-library android:name="org.apache.http.legacy" android:required="false"/>
   </application>
-</manifest>
+</manifest>

apps/mobile/android/app/src/main/java/com/lallimaven/eclipsetimer/wearable/WearDataLayerBridge.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import android.util.Log
 import com.google.android.gms.wearable.MessageClient
 import com.google.android.gms.wearable.MessageEvent
+import com.google.android.gms.wearable.NodeClient
 import com.google.android.gms.wearable.Wearable
 
 object WearDataLayerBridge : MessageClient.OnMessageReceivedListener {
@@ -25,6 +26,10 @@ object WearDataLayerBridge : MessageClient.OnMessageReceivedListener {
 
   private lateinit var appContext: Context
   private lateinit var messageClient: MessageClient
+  private lateinit var nodeClient: NodeClient
+
+  @Volatile
+  private var cachedWatchNodeId: String? = null
 
   @Synchronized
   fun initialize(context: Context) {
@@ -34,6 +39,7 @@ object WearDataLayerBridge : MessageClient.OnMessageReceivedListener {
 
     appContext = context.applicationContext
     messageClient = Wearable.getMessageClient(appContext)
+    nodeClient = Wearable.getNodeClient(appContext)
     isInitialized = true
     startListening()
     Log.i(TAG, "Wear Data Layer bridge initialized.")
@@ -59,6 +65,8 @@ object WearDataLayerBridge : MessageClient.OnMessageReceivedListener {
     isListening = false
   }
 
+  fun isListeningInProcess(): Boolean = isInitialized && isListening
+
   fun setIncomingMessageListener(listener: IncomingMessageListener?) {
     incomingMessageListener = listener
   }
@@ -74,28 +82,116 @@ object WearDataLayerBridge : MessageClient.OnMessageReceivedListener {
       return
     }
 
-    Wearable.getNodeClient(appContext).connectedNodes
+    val knownWatchNodeId = cachedWatchNodeId
+    if (!knownWatchNodeId.isNullOrBlank()) {
+      if (shouldLogPayloadActivity(path)) {
+        Log.i(
+          TAG,
+          "event=payload_send_attempt path=$path nodeId=$knownWatchNodeId strategy=cached_node_id",
+        )
+      }
+      sendMessageToNode(
+        nodeId = knownWatchNodeId,
+        path = path,
+        payload = payload,
+        onSuccess = {
+          if (shouldLogPayloadActivity(path)) {
+            Log.i(TAG, "event=payload_send_success path=$path nodeId=$knownWatchNodeId")
+          }
+          onSuccess()
+        },
+        onFailure = {
+          Log.w(
+            TAG,
+            "event=payload_send_failed path=$path nodeId=$knownWatchNodeId strategy=cached_node_id",
+            it,
+          )
+          cachedWatchNodeId = null
+          resolveNodeAndSend(path, payload, onSuccess, onError)
+        },
+      )
+      return
+    }
+
+    resolveNodeAndSend(path, payload, onSuccess, onError)
+  }
+
+  private fun resolveNodeAndSend(
+    path: String,
+    payload: ByteArray,
+    onSuccess: () -> Unit,
+    onError: (String) -> Unit,
+  ) {
+    nodeClient.connectedNodes
       .addOnSuccessListener { nodes ->
         val targetNode = nodes.firstOrNull()
         if (targetNode == null) {
+          cachedWatchNodeId = null
+          Log.w(TAG, "event=connectivity_no_watch_node path=$path")
           onError("No connected Wear OS nodes.")
           return@addOnSuccessListener
         }
 
-        messageClient.sendMessage(targetNode.id, path, payload)
-          .addOnSuccessListener { onSuccess() }
-          .addOnFailureListener { error ->
+        cachedWatchNodeId = targetNode.id
+        Log.i(TAG, "event=connectivity_node_resolved path=$path nodeId=${targetNode.id}")
+        if (shouldLogPayloadActivity(path)) {
+          Log.i(
+            TAG,
+            "event=payload_send_attempt path=$path nodeId=${targetNode.id} strategy=resolved_node",
+          )
+        }
+        sendMessageToNode(
+          nodeId = targetNode.id,
+          path = path,
+          payload = payload,
+          onSuccess = {
+            if (shouldLogPayloadActivity(path)) {
+              Log.i(TAG, "event=payload_send_success path=$path nodeId=${targetNode.id}")
+            }
+            onSuccess()
+          },
+          onFailure = { error ->
+            cachedWatchNodeId = null
+            Log.w(TAG, "event=payload_send_failed path=$path nodeId=${targetNode.id}", error)
             onError(error.message ?: "Failed to send Data Layer message.")
-          }
+          },
+        )
       }
       .addOnFailureListener { error ->
+        cachedWatchNodeId = null
+        Log.w(TAG, "event=connectivity_node_resolve_failed path=$path", error)
         onError(error.message ?: "Failed to query connected Wear OS nodes.")
       }
   }
 
+  private fun shouldLogPayloadActivity(path: String): Boolean = path != WearPaths.PREVIEW_SCRUB
+
+  private fun sendMessageToNode(
+    nodeId: String,
+    path: String,
+    payload: ByteArray,
+    onSuccess: () -> Unit,
+    onFailure: (Exception) -> Unit,
+  ) {
+    messageClient.sendMessage(nodeId, path, payload)
+      .addOnSuccessListener { onSuccess() }
+      .addOnFailureListener { error ->
+        onFailure(error)
+      }
+  }
+
   override fun onMessageReceived(messageEvent: MessageEvent) {
+    if (messageEvent.sourceNodeId.isNotBlank()) {
+      cachedWatchNodeId = messageEvent.sourceNodeId
+    }
+
     val payload = messageEvent.data.toString(Charsets.UTF_8)
-    Log.d(TAG, "Message received on ${messageEvent.path}: $payload")
+    if (shouldLogPayloadActivity(messageEvent.path)) {
+      Log.d(
+        TAG,
+        "event=payload_received path=${messageEvent.path} sourceNodeId=${messageEvent.sourceNodeId} payload=$payload",
+      )
+    }
     incomingMessageListener?.onIncomingMessage(messageEvent.path, payload, messageEvent.sourceNodeId)
 
     if (messageEvent.path == WearPaths.LIVE_LOCATION) {
@@ -104,7 +200,11 @@ object WearDataLayerBridge : MessageClient.OnMessageReceivedListener {
         WearPaths.LIVE_RENDER,
         ACK_PAYLOAD.toByteArray(Charsets.UTF_8),
       ).addOnFailureListener { error ->
-        Log.w(TAG, "Failed to send phase-0 ack to watch.", error)
+        Log.w(
+          TAG,
+          "event=ack_send_failed path=${WearPaths.LIVE_RENDER} sourceNodeId=${messageEvent.sourceNodeId}",
+          error,
+        )
       }
     }
   }

apps/mobile/android/app/src/main/java/com/lallimaven/eclipsetimer/wearable/WearDataLayerListenerService.kt

@@ -0,0 +1,33 @@
+package com.lallimaven.eclipsetimer.wearable
+
+import android.util.Log
+import com.google.android.gms.wearable.MessageEvent
+import com.google.android.gms.wearable.Wearable
+import com.google.android.gms.wearable.WearableListenerService
+
+class WearDataLayerListenerService : WearableListenerService() {
+  override fun onMessageReceived(messageEvent: MessageEvent) {
+    if (messageEvent.path != WearPaths.LIVE_LOCATION) {
+      super.onMessageReceived(messageEvent)
+      return
+    }
+
+    // When the React Native bridge listener is alive, let it own the handshake path.
+    if (WearDataLayerBridge.isListeningInProcess()) {
+      return
+    }
+
+    Wearable.getMessageClient(applicationContext).sendMessage(
+      messageEvent.sourceNodeId,
+      WearPaths.LIVE_RENDER,
+      PHASE0_ACK_PAYLOAD.toByteArray(Charsets.UTF_8),
+    ).addOnFailureListener { error ->
+      Log.w(TAG, "Failed to send phase-0 ack from listener service.", error)
+    }
+  }
+
+  companion object {
+    private const val TAG = "WearDataLayerService"
+    private const val PHASE0_ACK_PAYLOAD = """{"type":"phase0-ack","source":"phone"}"""
+  }
+}

apps/mobile/android/app/src/main/java/com/lallimaven/eclipsetimer/wearable/WearDataLayerModule.kt

@@ -43,6 +43,22 @@ class WearDataLayerModule(private val reactContext: ReactApplicationContext) :
     )
   }
 
+  @ReactMethod
+  fun sendMessage(path: String, payload: String, promise: Promise) {
+    val normalizedPath = path.trim()
+    if (normalizedPath.isEmpty()) {
+      promise.reject("E_WEAR_SEND_PATH", "Data Layer path cannot be empty.")
+      return
+    }
+
+    WearDataLayerBridge.sendMessageToWatch(
+      path = normalizedPath,
+      payload = payload.toByteArray(Charsets.UTF_8),
+      onSuccess = { promise.resolve(true) },
+      onError = { error -> promise.reject("E_WEAR_SEND", error) },
+    )
+  }
+
   override fun onIncomingMessage(path: String, payload: String, sourceNodeId: String) {
     if (!reactContext.hasActiveReactInstance()) {
       return

apps/mobile/android/wear/build.gradle

@@ -84,7 +84,7 @@ android {
     compileSdk rootProject.ext.compileSdkVersion
 
     defaultConfig {
-        applicationId "com.lallimaven.eclipsetimer.wear"
+        applicationId "com.lallimaven.eclipsetimer"
         minSdkVersion 26
         targetSdkVersion rootProject.ext.targetSdkVersion
         versionCode wearVersionCode
@@ -131,5 +131,6 @@ android {
 dependencies {
     implementation "androidx.core:core-ktx:1.15.0"
     implementation "androidx.activity:activity-ktx:1.10.1"
+    implementation "com.google.android.gms:play-services-location:21.3.0"
     implementation "com.google.android.gms:play-services-wearable:19.0.0"
 }

apps/mobile/android/wear/src/main/AndroidManifest.xml

@@ -1,5 +1,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
   <uses-feature android:name="android.hardware.type.watch" />
+  <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
   <application
     android:allowBackup="true"
     android:icon="@drawable/ic_watch_launcher"