feat(watch): Wear OS companion app - UX surfaces + bridge client (#91-E, #91-F)

watch_app/.gitignore

@@ -0,0 +1,15 @@
+.dart_tool/
+.flutter-plugins
+.flutter-plugins-dependencies
+build/
+**/GeneratedPluginRegistrant.java
+**/generated_plugin_registrant.*
+android/local.properties
+android/.gradle/
+android/captures/
+android/app/debug/
+android/app/profile/
+android/app/release/
+*.iml
+.idea/
+.DS_Store

watch_app/analysis_options.yaml

@@ -0,0 +1 @@
+include: ../analysis_options.yaml

watch_app/android/app/build.gradle.kts

@@ -0,0 +1,38 @@
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+    id("dev.flutter.flutter-gradle-plugin")
+}
+
+android {
+    namespace = "com.gametime.watch"
+    compileSdk = flutter.compileSdkVersion
+    ndkVersion = flutter.ndkVersion
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    defaultConfig {
+        applicationId = "com.gametime.watch"
+        minSdk = 26
+        targetSdk = flutter.targetSdkVersion
+        versionCode = flutter.versionCode
+        versionName = flutter.versionName
+    }
+
+    buildTypes {
+        release {
+            signingConfig = signingConfigs.getByName("debug")
+        }
+    }
+}
+
+flutter {
+    source = "../.."
+}
+
+dependencies {
+    implementation("com.google.android.gms:play-services-wearable:19.0.0")
+}

watch_app/android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,54 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-feature
+        android:name="android.hardware.type.watch"
+        android:required="true" />
+
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+    <application
+        android:label="GameTime"
+        android:name="${applicationName}"
+        android:icon="@drawable/ic_launcher"
+        android:theme="@style/LaunchTheme"
+        android:usesCleartextTraffic="false">
+        <uses-library
+            android:name="com.google.android.wearable"
+            android:required="true" />
+        <meta-data
+            android:name="com.google.android.wearable.standalone"
+            android:value="false" />
+        <activity
+            android:name=".MainActivity"
+            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
+            android:exported="true"
+            android:hardwareAccelerated="true"
+            android:launchMode="singleTop"
+            android:taskAffinity=""
+            android:theme="@style/LaunchTheme"
+            android:windowSoftInputMode="adjustResize">
+            <meta-data
+                android:name="io.flutter.embedding.android.NormalTheme"
+                android:resource="@style/NormalTheme" />
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+        <meta-data
+            android:name="flutterEmbedding"
+            android:value="2" />
+        <service
+            android:name=".bridge.WatchBridgeListenerService"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="com.google.android.gms.wearable.DATA_CHANGED" />
+                <action android:name="com.google.android.gms.wearable.MESSAGE_RECEIVED" />
+                <action android:name="com.google.android.gms.wearable.CAPABILITY_CHANGED" />
+                <data
+                    android:host="*"
+                    android:pathPrefix="/gametime"
+                    android:scheme="wear" />
+            </intent-filter>
+        </service>
+    </application>
+</manifest>

watch_app/android/app/src/main/kotlin/com/gametime/watch/MainActivity.kt

@@ -0,0 +1,12 @@
+package com.gametime.watch
+
+import com.gametime.watch.bridge.WatchBridgePlugin
+import io.flutter.embedding.android.FlutterActivity
+import io.flutter.embedding.engine.FlutterEngine
+
+class MainActivity : FlutterActivity() {
+    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
+        super.configureFlutterEngine(flutterEngine)
+        WatchBridgePlugin.register(flutterEngine, applicationContext)
+    }
+}

watch_app/android/app/src/main/kotlin/com/gametime/watch/bridge/WatchBridgeListenerService.kt

@@ -0,0 +1,58 @@
+package com.gametime.watch.bridge
+
+import com.google.android.gms.wearable.CapabilityInfo
+import com.google.android.gms.wearable.DataEventBuffer
+import com.google.android.gms.wearable.MessageEvent
+import com.google.android.gms.wearable.WearableListenerService
+import org.json.JSONObject
+import java.nio.charset.StandardCharsets
+
+class WatchBridgeListenerService : WearableListenerService() {
+    override fun onDataChanged(dataEvents: DataEventBuffer) {
+        try {
+            for (event in dataEvents) {
+                WatchBridgePlugin.handleDataEvent(event)
+            }
+        } finally {
+            dataEvents.release()
+        }
+    }
+
+    override fun onMessageReceived(messageEvent: MessageEvent) {
+        if (messageEvent.path != WatchBridgePlugin.ACK_PATH) {
+            return
+        }
+        val payload = JSONObject(String(messageEvent.data, StandardCharsets.UTF_8))
+        WatchBridgePlugin.emitAck(payload.toMap())
+    }
+
+    override fun onCapabilityChanged(capabilityInfo: CapabilityInfo) {
+        if (capabilityInfo.name != WatchBridgePlugin.PHONE_CAPABILITY) {
+            return
+        }
+        WatchBridgePlugin.emitConnection(
+            isReachable = capabilityInfo.nodes.isNotEmpty(),
+            requestsResync = capabilityInfo.nodes.isNotEmpty(),
+        )
+        if (capabilityInfo.nodes.isNotEmpty()) {
+            WatchBridgePlugin.requestLatestProjection(applicationContext)
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        WatchBridgePlugin.requestCapabilityRefresh(applicationContext)
+        WatchBridgePlugin.requestLatestProjection(applicationContext)
+    }
+}
+
+private fun JSONObject.toMap(): Map<String, Any?> {
+    val output = linkedMapOf<String, Any?>()
+    val keys = keys()
+    while (keys.hasNext()) {
+        val key = keys.next()
+        val value = get(key)
+        output[key] = if (value == JSONObject.NULL) null else value
+    }
+    return output
+}

watch_app/android/app/src/main/kotlin/com/gametime/watch/bridge/WatchBridgePlugin.kt

@@ -0,0 +1,242 @@
+package com.gametime.watch.bridge
+
+import android.content.Context
+import android.net.Uri
+import com.google.android.gms.wearable.CapabilityClient
+import com.google.android.gms.wearable.DataEvent
+import com.google.android.gms.wearable.DataMapItem
+import com.google.android.gms.wearable.Wearable
+import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.plugin.common.EventChannel
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugin.common.MethodChannel
+import org.json.JSONArray
+import org.json.JSONObject
+import java.nio.charset.StandardCharsets
+
+object WatchBridgePlugin {
+    private const val METHOD_CHANNEL = "gametime.watch_bridge/methods"
+    private const val PROJECTION_CHANNEL = "gametime.watch_bridge/projections"
+    private const val ACK_CHANNEL = "gametime.watch_bridge/acks"
+    private const val CONNECTION_CHANNEL = "gametime.watch_bridge/connection"
+
+    const val COMMAND_PATH = "/gametime/watch/command"
+    const val ACK_PATH = "/gametime/phone/ack"
+    const val STATE_PATH = "/gametime/phone/projection"
+    const val PHONE_CAPABILITY = "gametime_phone_companion"
+
+    private var appContext: Context? = null
+    private var projectionSink: EventChannel.EventSink? = null
+    private var ackSink: EventChannel.EventSink? = null
+    private var connectionSink: EventChannel.EventSink? = null
+
+    fun register(flutterEngine: FlutterEngine, context: Context) {
+        appContext = context.applicationContext
+        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, METHOD_CHANNEL)
+            .setMethodCallHandler(::handleMethodCall)
+        EventChannel(flutterEngine.dartExecutor.binaryMessenger, PROJECTION_CHANNEL)
+            .setStreamHandler(
+                object : EventChannel.StreamHandler {
+                    override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
+                        projectionSink = events
+                        requestLatestProjection(context.applicationContext)
+                    }
+
+                    override fun onCancel(arguments: Any?) {
+                        projectionSink = null
+                    }
+                },
+            )
+        EventChannel(flutterEngine.dartExecutor.binaryMessenger, ACK_CHANNEL)
+            .setStreamHandler(
+                object : EventChannel.StreamHandler {
+                    override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
+                        ackSink = events
+                    }
+
+                    override fun onCancel(arguments: Any?) {
+                        ackSink = null
+                    }
+                },
+            )
+        EventChannel(flutterEngine.dartExecutor.binaryMessenger, CONNECTION_CHANNEL)
+            .setStreamHandler(
+                object : EventChannel.StreamHandler {
+                    override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
+                        connectionSink = events
+                        requestCapabilityRefresh(context.applicationContext)
+                    }
+
+                    override fun onCancel(arguments: Any?) {
+                        connectionSink = null
+                    }
+                },
+            )
+    }
+
+    fun emitProjection(payload: Map<String, Any?>): Boolean {
+        val sink = projectionSink ?: return false
+        sink.success(payload)
+        return true
+    }
+
+    fun emitAck(payload: Map<String, Any?>): Boolean {
+        val sink = ackSink ?: return false
+        sink.success(payload)
+        return true
+    }
+
+    fun emitConnection(isReachable: Boolean, requestsResync: Boolean) {
+        connectionSink?.success(
+            mapOf(
+                "isReachable" to isReachable,
+                "requestsResync" to requestsResync,
+            ),
+        )
+    }
+
+    fun handleDataEvent(event: DataEvent) {
+        if (event.type != DataEvent.TYPE_CHANGED ||
+            event.dataItem.uri.path != STATE_PATH
+        ) {
+            return
+        }
+        val projectionJson = DataMapItem.fromDataItem(event.dataItem)
+            .dataMap
+            .getString("projectionJson")
+            ?: return
+        emitProjection(JSONObject(projectionJson).toMap())
+    }
+
+    private fun handleMethodCall(call: MethodCall, result: MethodChannel.Result) {
+        val context = appContext
+        if (context == null) {
+            result.error("watch_bridge_unavailable", "Application context unavailable.", null)
+            return
+        }
+        when (call.method) {
+            "sendCommand" -> sendCommand(context, call.arguments, result)
+            "requestCapabilityRefresh" -> {
+                requestCapabilityRefresh(context)
+                result.success(null)
+            }
+            "requestResync" -> {
+                requestLatestProjection(context)
+                requestCapabilityRefresh(context)
+                result.success(null)
+            }
+            else -> result.notImplemented()
+        }
+    }
+
+    private fun sendCommand(
+        context: Context,
+        arguments: Any?,
+        result: MethodChannel.Result,
+    ) {
+        val map = arguments as? Map<*, *>
+        if (map == null) {
+            result.error("invalid_command", "Command payload must be a map.", null)
+            return
+        }
+        val payload = JSONObject(map).toString().toByteArray(StandardCharsets.UTF_8)
+        Wearable.getCapabilityClient(context)
+            .getCapability(PHONE_CAPABILITY, CapabilityClient.FILTER_REACHABLE)
+            .addOnSuccessListener { capability ->
+                val nodes = capability.nodes.toList()
+                if (nodes.isEmpty()) {
+                    emitConnection(isReachable = false, requestsResync = false)
+                    result.error("phone_unreachable", "No reachable phone companion.", null)
+                    return@addOnSuccessListener
+                }
+                var remaining = nodes.size
+                var failed = false
+                for (node in nodes) {
+                    Wearable.getMessageClient(context)
+                        .sendMessage(node.id, COMMAND_PATH, payload)
+                        .addOnSuccessListener {
+                            remaining -= 1
+                            if (remaining == 0 && !failed) {
+                                emitConnection(isReachable = true, requestsResync = false)
+                                result.success(null)
+                            }
+                        }
+                        .addOnFailureListener { error ->
+                            if (failed) {
+                                return@addOnFailureListener
+                            }
+                            failed = true
+                            emitConnection(isReachable = false, requestsResync = false)
+                            result.error("send_command_failed", error.message, null)
+                        }
+                }
+            }
+            .addOnFailureListener { error ->
+                emitConnection(isReachable = false, requestsResync = false)
+                result.error("capability_lookup_failed", error.message, null)
+            }
+    }
+
+    fun requestCapabilityRefresh(context: Context) {
+        Wearable.getCapabilityClient(context)
+            .getCapability(PHONE_CAPABILITY, CapabilityClient.FILTER_REACHABLE)
+            .addOnSuccessListener { capability ->
+                emitConnection(
+                    isReachable = capability.nodes.isNotEmpty(),
+                    requestsResync = capability.nodes.isNotEmpty(),
+                )
+            }
+            .addOnFailureListener {
+                emitConnection(isReachable = false, requestsResync = false)
+            }
+    }
+
+    fun requestLatestProjection(context: Context) {
+        val uri = Uri.Builder()
+            .scheme("wear")
+            .path(STATE_PATH)
+            .build()
+        Wearable.getDataClient(context)
+            .getDataItems(uri)
+            .addOnSuccessListener { buffer ->
+                try {
+                    for (item in buffer) {
+                        val projectionJson = DataMapItem.fromDataItem(item)
+                            .dataMap
+                            .getString("projectionJson")
+                            ?: continue
+                        emitProjection(JSONObject(projectionJson).toMap())
+                    }
+                } finally {
+                    buffer.release()
+                }
+            }
+    }
+}
+
+private fun JSONObject.toMap(): Map<String, Any?> {
+    val output = linkedMapOf<String, Any?>()
+    val keys = keys()
+    while (keys.hasNext()) {
+        val key = keys.next()
+        output[key] = unwrapJsonValue(get(key))
+    }
+    return output
+}
+
+private fun JSONArray.toList(): List<Any?> {
+    val output = mutableListOf<Any?>()
+    for (index in 0 until length()) {
+        output.add(unwrapJsonValue(get(index)))
+    }
+    return output
+}
+
+private fun unwrapJsonValue(value: Any?): Any? {
+    return when (value) {
+        JSONObject.NULL -> null
+        is JSONObject -> value.toMap()
+        is JSONArray -> value.toList()
+        else -> value
+    }
+}

watch_app/android/app/src/main/res/drawable/ic_launcher.xml

@@ -0,0 +1,12 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="48dp"
+    android:height="48dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48">
+    <path
+        android:fillColor="#080A12"
+        android:pathData="M24,2a22,22 0,1 0,0.1 0z" />
+    <path
+        android:fillColor="#D72638"
+        android:pathData="M13,12h22v6H22v5h11v6H22v7h-9z" />
+</vector>

watch_app/android/app/src/main/res/drawable/launch_background.xml

@@ -0,0 +1,3 @@
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="@android:color/black" />
+</layer-list>

watch_app/android/app/src/main/res/values-round/styles.xml

@@ -0,0 +1,11 @@
+<resources>
+    <style name="LaunchTheme" parent="@android:style/Theme.DeviceDefault.NoActionBar">
+        <item name="android:windowBackground">@drawable/launch_background</item>
+        <item name="android:windowIsTranslucent">false</item>
+    </style>
+
+    <style name="NormalTheme" parent="@android:style/Theme.DeviceDefault.NoActionBar">
+        <item name="android:windowBackground">#080A12</item>
+        <item name="android:windowIsTranslucent">false</item>
+    </style>
+</resources>

watch_app/android/app/src/main/res/values/styles.xml

@@ -0,0 +1,9 @@
+<resources>
+    <style name="LaunchTheme" parent="@android:style/Theme.DeviceDefault.NoActionBar">
+        <item name="android:windowBackground">@drawable/launch_background</item>
+    </style>
+
+    <style name="NormalTheme" parent="@android:style/Theme.DeviceDefault.NoActionBar">
+        <item name="android:windowBackground">#080A12</item>
+    </style>
+</resources>

watch_app/android/app/src/main/res/values/wear.xml

@@ -0,0 +1,5 @@
+<resources>
+    <string-array name="android_wear_capabilities">
+        <item>gametime_watch_companion</item>
+    </string-array>
+</resources>

watch_app/android/build.gradle.kts

@@ -0,0 +1,25 @@
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+val newBuildDir: Directory =
+    rootProject.layout.buildDirectory
+        .dir("../../build/watch_app")
+        .get()
+rootProject.layout.buildDirectory.value(newBuildDir)
+
+subprojects {
+    val newSubprojectBuildDir: Directory = newBuildDir.dir(project.name)
+    project.layout.buildDirectory.value(newSubprojectBuildDir)
+}
+
+subprojects {
+    project.evaluationDependsOn(":app")
+}
+
+tasks.register<Delete>("clean") {
+    delete(rootProject.layout.buildDirectory)
+}

watch_app/android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.1.0-all.zip

watch_app/android/gradlew

@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

watch_app/android/gradlew.bat

@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

watch_app/android/settings.gradle.kts

@@ -0,0 +1,26 @@
+pluginManagement {
+    val flutterSdkPath =
+        run {
+            val properties = java.util.Properties()
+            file("local.properties").inputStream().use { properties.load(it) }
+            val flutterSdkPath = properties.getProperty("flutter.sdk")
+            require(flutterSdkPath != null) { "flutter.sdk not set in local.properties" }
+            flutterSdkPath
+        }
+
+    includeBuild("$flutterSdkPath/packages/flutter_tools/gradle")
+
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+plugins {
+    id("dev.flutter.flutter-plugin-loader") version "1.0.0"
+    id("com.android.application") version "9.0.1" apply false
+    id("org.jetbrains.kotlin.android") version "2.3.20" apply false
+}
+
+include(":app")

watch_app/lib/application/watch_session_view_model.dart

@@ -0,0 +1,285 @@
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+import 'package:watch_bridge_contract/watch_bridge_contract.dart';
+
+import '../infrastructure/watch_bridge/native_watch_bridge_client.dart';
+
+final class WatchSessionUiState {
+  const WatchSessionUiState({
+    required this.projection,
+    this.commandPending = false,
+    this.waitingForPhone = false,
+    this.connectionLost = false,
+    this.staleProjection = false,
+    this.lastAck,
+  });
+
+  final WatchSessionProjection projection;
+  final bool commandPending;
+  final bool waitingForPhone;
+  final bool connectionLost;
+  final bool staleProjection;
+  final WatchCommandAckEvent? lastAck;
+
+  bool get actionsEnabled => !commandPending && !connectionLost;
+
+  WatchSessionUiState copyWith({
+    WatchSessionProjection? projection,
+    bool? commandPending,
+    bool? waitingForPhone,
+    bool? connectionLost,
+    bool? staleProjection,
+    WatchCommandAckEvent? lastAck,
+  }) {
+    return WatchSessionUiState(
+      projection: projection ?? this.projection,
+      commandPending: commandPending ?? this.commandPending,
+      waitingForPhone: waitingForPhone ?? this.waitingForPhone,
+      connectionLost: connectionLost ?? this.connectionLost,
+      staleProjection: staleProjection ?? this.staleProjection,
+      lastAck: lastAck ?? this.lastAck,
+    );
+  }
+}
+
+final class WatchSessionViewModel extends ValueNotifier<WatchSessionUiState> {
+  WatchSessionViewModel({
+    NativeWatchBridgeClient nativeClient =
+        const MethodChannelNativeWatchBridgeClient(),
+    Duration waitingThreshold = const Duration(milliseconds: 500),
+    Duration commandTimeout = const Duration(seconds: 2),
+    Duration staleProjectionThreshold = const Duration(seconds: 6),
+    Duration connectionLostThreshold = const Duration(seconds: 10),
+  }) : _nativeClient = nativeClient,
+       _waitingThreshold = waitingThreshold,
+       _commandTimeout = commandTimeout,
+       _staleProjectionThreshold = staleProjectionThreshold,
+       _connectionLostThreshold = connectionLostThreshold,
+       super(WatchSessionUiState(projection: _initialProjection())) {
+    _subscriptions.add(_nativeClient.projections.listen(_handleProjection));
+    _subscriptions.add(_nativeClient.acks.listen(_handleAck));
+    _subscriptions.add(
+      _nativeClient.connectionEvents.listen(_handleConnectionEvent),
+    );
+    unawaited(_nativeClient.requestCapabilityRefresh());
+    unawaited(_nativeClient.requestResync());
+    _freshnessTimer = Timer.periodic(const Duration(seconds: 1), (_) {
+      _syncFreshnessState();
+    });
+  }
+
+  final NativeWatchBridgeClient _nativeClient;
+  final Duration _waitingThreshold;
+  final Duration _commandTimeout;
+  final Duration _staleProjectionThreshold;
+  final Duration _connectionLostThreshold;
+  final _subscriptions = <StreamSubscription<dynamic>>[];
+
+  Timer? _waitingTimer;
+  Timer? _commandTimeoutTimer;
+  Timer? _freshnessTimer;
+  WatchCommandEnvelope? _pendingCommand;
+  DateTime? _lastProjectionReceivedAt;
+  var _commandCounter = 0;
+
+  Future<void> refresh() async {
+    value = value.copyWith(connectionLost: false);
+    try {
+      await _nativeClient.requestCapabilityRefresh();
+      await _nativeClient.requestResync();
+    } on PlatformException {
+      value = value.copyWith(connectionLost: true);
+      unawaited(HapticFeedback.heavyImpact());
+    }
+  }
+
+  Future<void> sendPrimaryAction() async {
+    final action = value.projection.primaryAction;
+    final command = switch (action) {
+      WatchPrimaryAction.none => null,
+      WatchPrimaryAction.startCurrentExercise =>
+        WatchCommandType.startCurrentExercise,
+      WatchPrimaryAction.pauseSession => WatchCommandType.pauseSession,
+      WatchPrimaryAction.resumeSession => WatchCommandType.resumeSession,
+      WatchPrimaryAction.startPreparedTimedStep =>
+        WatchCommandType.startPreparedTimedStep,
+      WatchPrimaryAction.skipCurrentRest => WatchCommandType.skipCurrentRest,
+    };
+    if (command == null) {
+      await refresh();
+      return;
+    }
+    await _sendCommand(command);
+  }
+
+  Future<void> sendSecondaryAction(WatchSecondaryAction action) {
+    final command = switch (action) {
+      WatchSecondaryAction.skipCurrentStep => WatchCommandType.skipCurrentStep,
+      WatchSecondaryAction.skipCurrentPassage =>
+        WatchCommandType.skipCurrentPassage,
+      WatchSecondaryAction.finishCurrentSet => WatchCommandType.finishCurrentSet,
+      WatchSecondaryAction.skipCurrentSet => WatchCommandType.skipCurrentSet,
+      WatchSecondaryAction.skipCurrentRest => WatchCommandType.skipCurrentRest,
+    };
+    return _sendCommand(command);
+  }
+
+  @override
+  void dispose() {
+    _waitingTimer?.cancel();
+    _commandTimeoutTimer?.cancel();
+    _freshnessTimer?.cancel();
+    for (final subscription in _subscriptions) {
+      unawaited(subscription.cancel());
+    }
+    super.dispose();
+  }
+
+  Future<void> _sendCommand(WatchCommandType type) async {
+    if (!value.actionsEnabled || value.projection.deviceSessionId.isEmpty) {
+      return;
+    }
+    final nowMs = DateTime.now().toUtc().millisecondsSinceEpoch;
+    final command = WatchCommandEnvelope(
+      commandId: 'watch-$nowMs-${_commandCounter++}',
+      type: type,
+      sessionId: value.projection.deviceSessionId,
+      expectedRevision: value.projection.revision,
+      sentAtEpochMs: nowMs,
+    );
+    _pendingCommand = command;
+    value = value.copyWith(
+      commandPending: true,
+      waitingForPhone: false,
+      connectionLost: false,
+    );
+    _waitingTimer?.cancel();
+    _commandTimeoutTimer?.cancel();
+    _waitingTimer = Timer(_waitingThreshold, () {
+      value = value.copyWith(waitingForPhone: true);
+    });
+    _commandTimeoutTimer = Timer(_commandTimeout, () {
+      _pendingCommand = null;
+      value = value.copyWith(
+        commandPending: false,
+        waitingForPhone: false,
+        connectionLost: true,
+      );
+      unawaited(HapticFeedback.heavyImpact());
+    });
+    try {
+      await _nativeClient.sendCommand(command);
+    } on PlatformException {
+      _pendingCommand = null;
+      _clearCommandTimers();
+      value = value.copyWith(
+        commandPending: false,
+        waitingForPhone: false,
+        connectionLost: true,
+      );
+      unawaited(HapticFeedback.heavyImpact());
+    }
+  }
+
+  void _handleProjection(WatchSessionProjection projection) {
+    final previousProjection = value.projection;
+    _lastProjectionReceivedAt = DateTime.now();
+    _pendingCommand = null;
+    _clearCommandTimers();
+    value = WatchSessionUiState(
+      projection: projection,
+      lastAck: value.lastAck,
+    );
+    _triggerProjectionHaptic(previousProjection, projection);
+  }
+
+  void _handleAck(WatchCommandAckEvent ack) {
+    if (_pendingCommand?.commandId != ack.commandId) {
+      value = value.copyWith(lastAck: ack);
+      return;
+    }
+    _waitingTimer?.cancel();
+    value = value.copyWith(
+      waitingForPhone: false,
+      connectionLost: false,
+      lastAck: ack,
+    );
+    unawaited(HapticFeedback.lightImpact());
+    if (_isRejected(ack.status)) {
+      _pendingCommand = null;
+      _clearCommandTimers();
+      value = value.copyWith(commandPending: false);
+      unawaited(_nativeClient.requestResync());
+    }
+  }
+
+  void _handleConnectionEvent(WatchBridgeConnectionEvent event) {
+    value = value.copyWith(connectionLost: !event.isReachable);
+    if (event.isReachable || event.requestsResync) {
+      unawaited(_nativeClient.requestResync());
+    }
+  }
+
+  void _syncFreshnessState() {
+    final receivedAt = _lastProjectionReceivedAt;
+    if (receivedAt == null) {
+      return;
+    }
+    final age = DateTime.now().difference(receivedAt);
+    final stale = age >= _staleProjectionThreshold;
+    final lost = age >= _connectionLostThreshold;
+    if (stale != value.staleProjection || lost != value.connectionLost) {
+      value = value.copyWith(staleProjection: stale, connectionLost: lost);
+    }
+  }
+
+  void _clearCommandTimers() {
+    _waitingTimer?.cancel();
+    _waitingTimer = null;
+    _commandTimeoutTimer?.cancel();
+    _commandTimeoutTimer = null;
+  }
+
+  void _triggerProjectionHaptic(
+    WatchSessionProjection previous,
+    WatchSessionProjection current,
+  ) {
+    final phaseChanged = previous.phase != current.phase;
+    final enteredReadyTimer = current.phase == WatchSessionPhase.nextTimerReady &&
+        previous.phase != WatchSessionPhase.nextTimerReady;
+    final enteredRestEnd =
+        previous.phase == WatchSessionPhase.restRunning &&
+        current.phase != WatchSessionPhase.restRunning &&
+        current.phase != WatchSessionPhase.restPaused;
+    if (phaseChanged && (enteredReadyTimer || enteredRestEnd)) {
+      unawaited(HapticFeedback.mediumImpact());
+      unawaited(Future<void>.delayed(const Duration(milliseconds: 120), () {
+        return HapticFeedback.mediumImpact();
+      }));
+    }
+  }
+}
+
+bool _isRejected(WatchCommandAck ack) {
+  return switch (ack) {
+    WatchCommandAck.accepted || WatchCommandAck.acceptedNoOp => false,
+    _ => true,
+  };
+}
+
+WatchSessionProjection _initialProjection() {
+  return WatchSessionProjection(
+    deviceSessionId: '',
+    revision: 0,
+    projectedAtEpochMs: DateTime.now().toUtc().millisecondsSinceEpoch,
+    phase: WatchSessionPhase.noActiveSession,
+    phoneReachable: false,
+    seriesIndex: 0,
+    seriesTotal: 0,
+    exerciseName: '',
+    primaryAction: WatchPrimaryAction.none,
+    statusLabel: 'Téléphone indisponible',
+  );
+}

watch_app/lib/infrastructure/watch_bridge/native_watch_bridge_client.dart

@@ -0,0 +1,159 @@
+import 'package:flutter/services.dart';
+import 'package:watch_bridge_contract/watch_bridge_contract.dart';
+
+final class WatchBridgeConnectionEvent {
+  const WatchBridgeConnectionEvent({
+    required this.isReachable,
+    this.requestsResync = false,
+  });
+
+  final bool isReachable;
+  final bool requestsResync;
+}
+
+final class WatchCommandAckEvent {
+  const WatchCommandAckEvent({
+    required this.commandId,
+    required this.status,
+    required this.sessionId,
+    this.revisionAtAck,
+    this.reasonCode,
+  });
+
+  final String commandId;
+  final WatchCommandAck status;
+  final String sessionId;
+  final int? revisionAtAck;
+  final String? reasonCode;
+}
+
+abstract interface class NativeWatchBridgeClient {
+  Stream<WatchSessionProjection> get projections;
+
+  Stream<WatchCommandAckEvent> get acks;
+
+  Stream<WatchBridgeConnectionEvent> get connectionEvents;
+
+  Future<void> sendCommand(WatchCommandEnvelope command);
+
+  Future<void> requestResync();
+
+  Future<void> requestCapabilityRefresh();
+}
+
+final class MethodChannelNativeWatchBridgeClient
+    implements NativeWatchBridgeClient {
+  const MethodChannelNativeWatchBridgeClient({
+    MethodChannel methodChannel = const MethodChannel(_methodChannelName),
+    EventChannel projectionChannel = const EventChannel(
+      _projectionChannelName,
+    ),
+    EventChannel ackChannel = const EventChannel(_ackChannelName),
+    EventChannel connectionChannel = const EventChannel(
+      _connectionChannelName,
+    ),
+  }) : _methodChannel = methodChannel,
+       _projectionChannel = projectionChannel,
+       _ackChannel = ackChannel,
+       _connectionChannel = connectionChannel;
+
+  static const _methodChannelName = 'gametime.watch_bridge/methods';
+  static const _projectionChannelName = 'gametime.watch_bridge/projections';
+  static const _ackChannelName = 'gametime.watch_bridge/acks';
+  static const _connectionChannelName = 'gametime.watch_bridge/connection';
+
+  final MethodChannel _methodChannel;
+  final EventChannel _projectionChannel;
+  final EventChannel _ackChannel;
+  final EventChannel _connectionChannel;
+
+  @override
+  Stream<WatchSessionProjection> get projections {
+    return _projectionChannel
+        .receiveBroadcastStream()
+        .where((event) => event is Map)
+        .map((event) {
+          return WatchSessionProjection.fromJson(_stringObjectMap(event));
+        });
+  }
+
+  @override
+  Stream<WatchCommandAckEvent> get acks {
+    return _ackChannel
+        .receiveBroadcastStream()
+        .where((event) => event is Map)
+        .map((event) {
+          final json = _stringObjectMap(event);
+          return WatchCommandAckEvent(
+            commandId: _stringFromJson(json['commandId']),
+            status: _enumFromJson(
+              json['status'],
+              WatchCommandAck.values,
+              WatchCommandAck.rejectedPhoneBusy,
+            ),
+            sessionId: _stringFromJson(json['sessionId']),
+            revisionAtAck: _nullableIntFromJson(json['revisionAtAck']),
+            reasonCode: _nullableStringFromJson(json['reasonCode']),
+          );
+        });
+  }
+
+  @override
+  Stream<WatchBridgeConnectionEvent> get connectionEvents {
+    return _connectionChannel
+        .receiveBroadcastStream()
+        .where((event) => event is Map)
+        .map((event) {
+          final json = _stringObjectMap(event);
+          return WatchBridgeConnectionEvent(
+            isReachable: json['isReachable'] == true,
+            requestsResync: json['requestsResync'] == true,
+          );
+        });
+  }
+
+  @override
+  Future<void> sendCommand(WatchCommandEnvelope command) {
+    return _methodChannel.invokeMethod<void>('sendCommand', command.toJson());
+  }
+
+  @override
+  Future<void> requestCapabilityRefresh() {
+    return _methodChannel.invokeMethod<void>('requestCapabilityRefresh');
+  }
+
+  @override
+  Future<void> requestResync() {
+    return _methodChannel.invokeMethod<void>('requestResync');
+  }
+}
+
+Map<String, Object?> _stringObjectMap(Object? value) {
+  if (value is Map) {
+    return value.map((key, value) => MapEntry(key.toString(), value));
+  }
+  return const {};
+}
+
+String _stringFromJson(Object? value) {
+  return value is String ? value : '';
+}
+
+String? _nullableStringFromJson(Object? value) {
+  return value is String ? value : null;
+}
+
+int? _nullableIntFromJson(Object? value) {
+  return value is int ? value : value is num ? value.toInt() : null;
+}
+
+T _enumFromJson<T extends Enum>(Object? value, List<T> values, T fallback) {
+  if (value is String) {
+    for (final enumValue in values) {
+      if (enumValue.name == value) {
+        return enumValue;
+      }
+    }
+  }
+  return fallback;
+}

watch_app/lib/main.dart

@@ -0,0 +1,7 @@
+import 'package:flutter/material.dart';
+
+import 'presentation/watch_session_app.dart';
+
+void main() {
+  runApp(const WatchSessionApp());
+}

watch_app/lib/presentation/watch_session_app.dart

@@ -0,0 +1,38 @@
+import 'package:flutter/material.dart';
+
+import '../application/watch_session_view_model.dart';
+import 'watch_session_screen.dart';
+import 'watch_theme.dart';
+
+final class WatchSessionApp extends StatefulWidget {
+  const WatchSessionApp({super.key});
+
+  @override
+  State<WatchSessionApp> createState() => _WatchSessionAppState();
+}
+
+final class _WatchSessionAppState extends State<WatchSessionApp> {
+  late final WatchSessionViewModel _viewModel;
+
+  @override
+  void initState() {
+    super.initState();
+    _viewModel = WatchSessionViewModel();
+  }
+
+  @override
+  void dispose() {
+    _viewModel.dispose();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      debugShowCheckedModeBanner: false,
+      title: 'GameTime',
+      theme: watchTheme(),
+      home: WatchSessionScreen(viewModel: _viewModel),
+    );
+  }
+}

watch_app/lib/presentation/watch_session_screen.dart

@@ -0,0 +1,549 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:watch_bridge_contract/watch_bridge_contract.dart';
+
+import '../application/watch_session_view_model.dart';
+
+final class WatchSessionScreen extends StatefulWidget {
+  const WatchSessionScreen({required this.viewModel, super.key});
+
+  final WatchSessionViewModel viewModel;
+
+  @override
+  State<WatchSessionScreen> createState() => _WatchSessionScreenState();
+}
+
+final class _WatchSessionScreenState extends State<WatchSessionScreen> {
+  late final PageController _pageController;
+  Timer? _ticker;
+
+  @override
+  void initState() {
+    super.initState();
+    _pageController = PageController();
+    _ticker = Timer.periodic(const Duration(seconds: 1), (_) {
+      if (mounted) {
+        setState(() {});
+      }
+    });
+  }
+
+  @override
+  void dispose() {
+    _ticker?.cancel();
+    _pageController.dispose();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return ValueListenableBuilder<WatchSessionUiState>(
+      valueListenable: widget.viewModel,
+      builder: (context, state, _) {
+        final projection = state.projection;
+        if (projection.phase == WatchSessionPhase.noActiveSession) {
+          return _RoundScaffold(
+            child: _NoSessionView(
+              projection: projection,
+              pending: state.commandPending,
+              onRefresh: widget.viewModel.refresh,
+            ),
+          );
+        }
+        return PageView(
+          controller: _pageController,
+          children: [
+            _RoundScaffold(
+              child: _SessionMainView(
+                state: state,
+                onPrimary: widget.viewModel.sendPrimaryAction,
+                onRetry: widget.viewModel.refresh,
+                onActions: _showActions,
+              ),
+            ),
+            _RoundScaffold(
+              child: _ActionsView(
+                state: state,
+                onAction: _handleSecondaryAction,
+                onSession: _showSession,
+              ),
+            ),
+          ],
+        );
+      },
+    );
+  }
+
+  void _showActions() {
+    _pageController.animateToPage(
+      1,
+      duration: const Duration(milliseconds: 180),
+      curve: Curves.easeOut,
+    );
+  }
+
+  void _showSession() {
+    _pageController.animateToPage(
+      0,
+      duration: const Duration(milliseconds: 180),
+      curve: Curves.easeOut,
+    );
+  }
+
+  Future<void> _handleSecondaryAction(WatchSecondaryAction action) async {
+    final confirmed = switch (action) {
+      WatchSecondaryAction.skipCurrentPassage => await _confirm(
+        title: 'Passer le passage ?',
+        message: "L'étape en cours sera ignorée.",
+        confirmLabel: 'Passer',
+      ),
+      WatchSecondaryAction.skipCurrentSet => await _confirm(
+        title: 'Passer la série ?',
+        message: 'Le chrono en cours sera ignoré.',
+        confirmLabel: 'Passer',
+      ),
+      _ => true,
+    };
+    if (confirmed && mounted) {
+      unawaited(widget.viewModel.sendSecondaryAction(action));
+      _showSession();
+    }
+  }
+
+  Future<bool> _confirm({
+    required String title,
+    required String message,
+    required String confirmLabel,
+  }) async {
+    final result = await showDialog<bool>(
+      context: context,
+      builder: (context) {
+        return AlertDialog(
+          title: Text(title),
+          content: Text(message),
+          actions: [
+            TextButton(
+              onPressed: () => Navigator.of(context).pop(false),
+              child: const Text('Annuler'),
+            ),
+            FilledButton(
+              onPressed: () => Navigator.of(context).pop(true),
+              child: Text(confirmLabel),
+            ),
+          ],
+        );
+      },
+    );
+    return result ?? false;
+  }
+}
+
+final class _RoundScaffold extends StatelessWidget {
+  const _RoundScaffold({required this.child});
+
+  final Widget child;
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: SafeArea(
+        minimum: const EdgeInsets.symmetric(horizontal: 14, vertical: 10),
+        child: Center(
+          child: ConstrainedBox(
+            constraints: const BoxConstraints(maxWidth: 210, maxHeight: 210),
+            child: child,
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+final class _NoSessionView extends StatelessWidget {
+  const _NoSessionView({
+    required this.projection,
+    required this.pending,
+    required this.onRefresh,
+  });
+
+  final WatchSessionProjection projection;
+  final bool pending;
+  final VoidCallback onRefresh;
+
+  @override
+  Widget build(BuildContext context) {
+    final phoneReachable = projection.phoneReachable;
+    return Column(
+      mainAxisAlignment: MainAxisAlignment.center,
+      children: [
+        Text(
+          phoneReachable ? 'Aucune séance en cours' : 'Téléphone indisponible',
+          textAlign: TextAlign.center,
+          style: Theme.of(context).textTheme.titleSmall,
+        ),
+        const SizedBox(height: 10),
+        Text(
+          phoneReachable
+              ? 'Lance une séance sur le téléphone.'
+              : 'Rouvre GameTime sur le téléphone.',
+          textAlign: TextAlign.center,
+          style: Theme.of(context).textTheme.bodySmall,
+        ),
+        const SizedBox(height: 16),
+        FilledButton(
+          onPressed: pending ? null : onRefresh,
+          child: Text(pending ? 'Envoi...' : 'Actualiser'),
+        ),
+      ],
+    );
+  }
+}
+
+final class _SessionMainView extends StatelessWidget {
+  const _SessionMainView({
+    required this.state,
+    required this.onPrimary,
+    required this.onRetry,
+    required this.onActions,
+  });
+
+  final WatchSessionUiState state;
+  final VoidCallback onPrimary;
+  final VoidCallback onRetry;
+  final VoidCallback onActions;
+
+  @override
+  Widget build(BuildContext context) {
+    final projection = state.projection;
+    final isRest = projection.phase == WatchSessionPhase.restRunning ||
+        projection.phase == WatchSessionPhase.restPaused;
+    if (state.connectionLost || !projection.phoneReachable) {
+      return _ConnectionLostView(onRetry: onRetry);
+    }
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.stretch,
+      children: [
+        Align(
+          alignment: Alignment.centerRight,
+          child: TextButton(
+            onPressed: onActions,
+            style: TextButton.styleFrom(
+              visualDensity: VisualDensity.compact,
+              minimumSize: const Size(56, 26),
+              padding: const EdgeInsets.symmetric(horizontal: 8),
+            ),
+            child: const Text('Actions'),
+          ),
+        ),
+        Expanded(
+          child: isRest
+              ? _RestContent(projection: projection)
+              : _ActiveContent(projection: projection),
+        ),
+        if (state.staleProjection)
+          Padding(
+            padding: const EdgeInsets.only(bottom: 4),
+            child: Text(
+              'Dernier état reçu',
+              textAlign: TextAlign.center,
+              style: Theme.of(context).textTheme.bodySmall,
+            ),
+          ),
+        FilledButton(
+          onPressed: state.actionsEnabled ? onPrimary : null,
+          child: Text(_primaryLabel(state)),
+        ),
+      ],
+    );
+  }
+}
+
+final class _ActiveContent extends StatelessWidget {
+  const _ActiveContent({required this.projection});
+
+  final WatchSessionProjection projection;
+
+  @override
+  Widget build(BuildContext context) {
+    final timer = projection.dominantTimer;
+    return Column(
+      mainAxisAlignment: MainAxisAlignment.center,
+      children: [
+        Text(
+          'SÉRIE ${projection.seriesIndex} / ${projection.seriesTotal}',
+          textAlign: TextAlign.center,
+          style: Theme.of(context).textTheme.labelSmall,
+        ),
+        const SizedBox(height: 3),
+        Text(
+          projection.exerciseName,
+          maxLines: 2,
+          overflow: TextOverflow.ellipsis,
+          textAlign: TextAlign.center,
+          style: Theme.of(context).textTheme.titleSmall,
+        ),
+        if (_contextLine(projection) case final contextLine?)
+          Padding(
+            padding: const EdgeInsets.only(top: 4),
+            child: Text(
+              contextLine,
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+              textAlign: TextAlign.center,
+              style: Theme.of(context).textTheme.bodySmall,
+            ),
+          ),
+        const SizedBox(height: 8),
+        if (timer == null)
+          Text(
+            projection.statusLabel ?? '',
+            textAlign: TextAlign.center,
+            style: Theme.of(context).textTheme.bodyMedium,
+          )
+        else ...[
+          Text(
+            _timerText(timer),
+            textAlign: TextAlign.center,
+            style: Theme.of(context).textTheme.displayLarge,
+          ),
+          Text(
+            projection.statusLabel ?? timer.label,
+            textAlign: TextAlign.center,
+            style: Theme.of(context).textTheme.bodySmall,
+          ),
+        ],
+        if (projection.secondaryTimers.isNotEmpty)
+          Padding(
+            padding: const EdgeInsets.only(top: 7),
+            child: Text(
+              projection.secondaryTimers.map(_compactTimerText).join(' · '),
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+              textAlign: TextAlign.center,
+              style: Theme.of(context).textTheme.bodySmall,
+            ),
+          ),
+      ],
+    );
+  }
+}
+
+final class _RestContent extends StatelessWidget {
+  const _RestContent({required this.projection});
+
+  final WatchSessionProjection projection;
+
+  @override
+  Widget build(BuildContext context) {
+    final timer = projection.dominantTimer;
+    return Column(
+      mainAxisAlignment: MainAxisAlignment.center,
+      children: [
+        Text(
+          'REPOS',
+          textAlign: TextAlign.center,
+          style: Theme.of(context).textTheme.labelSmall,
+        ),
+        const SizedBox(height: 3),
+        Text(
+          'Après série ${projection.seriesIndex} / ${projection.seriesTotal}',
+          textAlign: TextAlign.center,
+          style: Theme.of(context).textTheme.bodySmall,
+        ),
+        const SizedBox(height: 10),
+        Text(
+          timer == null ? '--:--' : _timerText(timer),
+          textAlign: TextAlign.center,
+          style: Theme.of(context).textTheme.displayLarge,
+        ),
+        Text(
+          projection.statusLabel ?? timer?.label ?? '',
+          textAlign: TextAlign.center,
+          style: Theme.of(context).textTheme.bodySmall,
+        ),
+        if (projection.nextExerciseName case final next?)
+          Padding(
+            padding: const EdgeInsets.only(top: 9),
+            child: Column(
+              children: [
+                Text(
+                  'Exercice suivant',
+                  textAlign: TextAlign.center,
+                  style: Theme.of(context).textTheme.bodySmall,
+                ),
+                Text(
+                  next,
+                  maxLines: 1,
+                  overflow: TextOverflow.ellipsis,
+                  textAlign: TextAlign.center,
+                  style: Theme.of(context).textTheme.bodyMedium,
+                ),
+              ],
+            ),
+          ),
+      ],
+    );
+  }
+}
+
+final class _ActionsView extends StatelessWidget {
+  const _ActionsView({
+    required this.state,
+    required this.onAction,
+    required this.onSession,
+  });
+
+  final WatchSessionUiState state;
+  final ValueChanged<WatchSecondaryAction> onAction;
+  final VoidCallback onSession;
+
+  @override
+  Widget build(BuildContext context) {
+    final actions = state.projection.secondaryActions;
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.stretch,
+      children: [
+        Row(
+          children: [
+            Expanded(
+              child: Text(
+                'Actions',
+                style: Theme.of(context).textTheme.titleSmall,
+              ),
+            ),
+            IconButton(
+              onPressed: onSession,
+              tooltip: 'Séance',
+              visualDensity: VisualDensity.compact,
+              icon: const Icon(Icons.chevron_left),
+            ),
+          ],
+        ),
+        Expanded(
+          child: actions.isEmpty || !state.projection.phoneReachable ||
+                  state.connectionLost
+              ? Center(
+                  child: Text(
+                    state.projection.phoneReachable && !state.connectionLost
+                        ? 'Aucune action'
+                        : 'Connexion perdue',
+                    textAlign: TextAlign.center,
+                    style: Theme.of(context).textTheme.bodySmall,
+                  ),
+                )
+              : ListView.separated(
+                  padding: const EdgeInsets.only(top: 4, bottom: 12),
+                  itemBuilder: (context, index) {
+                    final action = actions[index];
+                    return OutlinedButton(
+                      onPressed: state.actionsEnabled
+                          ? () => onAction(action)
+                          : null,
+                      child: Text(_secondaryLabel(action)),
+                    );
+                  },
+                  separatorBuilder: (_, _) => const SizedBox(height: 8),
+                  itemCount: actions.length,
+                ),
+        ),
+      ],
+    );
+  }
+}
+
+final class _ConnectionLostView extends StatelessWidget {
+  const _ConnectionLostView({required this.onRetry});
+
+  final VoidCallback onRetry;
+
+  @override
+  Widget build(BuildContext context) {
+    return Column(
+      mainAxisAlignment: MainAxisAlignment.center,
+      crossAxisAlignment: CrossAxisAlignment.stretch,
+      children: [
+        Text(
+          'Connexion perdue',
+          textAlign: TextAlign.center,
+          style: Theme.of(context).textTheme.titleSmall,
+        ),
+        const SizedBox(height: 8),
+        Text(
+          'Dernier état reçu il y a quelques secondes',
+          textAlign: TextAlign.center,
+          style: Theme.of(context).textTheme.bodySmall,
+        ),
+        const SizedBox(height: 16),
+        FilledButton(onPressed: onRetry, child: const Text('Réessayer')),
+      ],
+    );
+  }
+}
+
+String _primaryLabel(WatchSessionUiState state) {
+  if (state.commandPending) {
+    return state.waitingForPhone ? 'En attente du téléphone' : 'Envoi...';
+  }
+  return switch (state.projection.primaryAction) {
+    WatchPrimaryAction.none => 'Actualiser',
+    WatchPrimaryAction.startCurrentExercise => 'Démarrer l’exercice',
+    WatchPrimaryAction.pauseSession => 'Pause',
+    WatchPrimaryAction.resumeSession => 'Reprendre',
+    WatchPrimaryAction.startPreparedTimedStep => 'Démarrer le chrono',
+    WatchPrimaryAction.skipCurrentRest => 'Passer le repos',
+  };
+}
+
+String _secondaryLabel(WatchSecondaryAction action) {
+  return switch (action) {
+    WatchSecondaryAction.skipCurrentStep => 'Passer l’étape',
+    WatchSecondaryAction.skipCurrentPassage => 'Passer le passage',
+    WatchSecondaryAction.finishCurrentSet => 'Terminer la série',
+    WatchSecondaryAction.skipCurrentSet => 'Passer la série',
+    WatchSecondaryAction.skipCurrentRest => 'Passer le repos',
+  };
+}
+
+String? _contextLine(WatchSessionProjection projection) {
+  final parts = [
+    if (projection.passageIndex != null && projection.passageTotal != null)
+      'Passage ${projection.passageIndex} / ${projection.passageTotal}',
+    if (projection.stepIndex != null && projection.stepTotal != null)
+      'Étape ${projection.stepIndex} / ${projection.stepTotal}',
+  ];
+  if (parts.isEmpty) {
+    return null;
+  }
+  return parts.join(' · ');
+}
+
+String _timerText(WatchTimerProjection timer) {
+  final duration = _displayDuration(timer);
+  final totalSeconds = duration.inSeconds;
+  final minutes = (totalSeconds ~/ 60).toString().padLeft(2, '0');
+  final seconds = (totalSeconds % 60).toString().padLeft(2, '0');
+  return '$minutes:$seconds';
+}
+
+String _compactTimerText(WatchTimerProjection timer) {
+  return '${timer.label} ${_timerText(timer)}';
+}
+
+Duration _displayDuration(WatchTimerProjection timer) {
+  final elapsedMs = _interpolatedElapsedMs(timer);
+  final displayMs = switch (timer.displayMode) {
+    WatchTimerDisplayMode.elapsed => elapsedMs,
+    WatchTimerDisplayMode.countdown => (timer.targetMs ?? 0) - elapsedMs,
+  };
+  return Duration(milliseconds: displayMs < 0 ? 0 : displayMs);
+}
+
+int _interpolatedElapsedMs(WatchTimerProjection timer) {
+  if (timer.runState != WatchTimerRunState.running ||
+      timer.startedAtEpochMs == null) {
+    return timer.accumulatedMs;
+  }
+  final nowMs = DateTime.now().millisecondsSinceEpoch;
+  return timer.accumulatedMs + nowMs - timer.startedAtEpochMs!;
+}

watch_app/lib/presentation/watch_theme.dart

@@ -0,0 +1,71 @@
+import 'package:flutter/material.dart';
+
+ThemeData watchTheme() {
+  const background = Color(0xFF080A12);
+  const surface = Color(0xFF141824);
+  const text = Color(0xFFF5F1E8);
+  const muted = Color(0xFFA7ADBA);
+  const accent = Color(0xFFD72638);
+
+  final textTheme = Typography.whiteMountainView.copyWith(
+    labelSmall: const TextStyle(
+      fontSize: 10,
+      fontWeight: FontWeight.w800,
+      color: muted,
+    ),
+    bodySmall: const TextStyle(fontSize: 11, color: muted, height: 1.15),
+    bodyMedium: const TextStyle(fontSize: 13, color: text, height: 1.15),
+    titleSmall: const TextStyle(
+      fontSize: 16,
+      fontWeight: FontWeight.w800,
+      color: text,
+      height: 1.05,
+    ),
+    displayLarge: const TextStyle(
+      fontSize: 44,
+      fontWeight: FontWeight.w900,
+      color: text,
+      height: 0.95,
+      fontFeatures: [FontFeature.tabularFigures()],
+    ),
+  );
+
+  return ThemeData(
+    useMaterial3: true,
+    brightness: Brightness.dark,
+    scaffoldBackgroundColor: background,
+    colorScheme: const ColorScheme.dark(
+      primary: accent,
+      onPrimary: Colors.white,
+      secondary: Color(0xFFC9A24A),
+      surface: surface,
+      onSurface: text,
+      onSurfaceVariant: muted,
+      error: Color(0xFFFF4D5E),
+    ),
+    textTheme: textTheme,
+    filledButtonTheme: FilledButtonThemeData(
+      style: FilledButton.styleFrom(
+        minimumSize: const Size.fromHeight(38),
+        padding: const EdgeInsets.symmetric(horizontal: 14, vertical: 10),
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(8)),
+        textStyle: textTheme.labelLarge?.copyWith(
+          fontSize: 13,
+          fontWeight: FontWeight.w800,
+        ),
+      ),
+    ),
+    outlinedButtonTheme: OutlinedButtonThemeData(
+      style: OutlinedButton.styleFrom(
+        minimumSize: const Size.fromHeight(38),
+        padding: const EdgeInsets.symmetric(horizontal: 14, vertical: 10),
+        side: const BorderSide(color: Color(0xFF303748)),
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(8)),
+        textStyle: textTheme.labelLarge?.copyWith(
+          fontSize: 13,
+          fontWeight: FontWeight.w800,
+        ),
+      ),
+    ),
+  );
+}

watch_app/pubspec.lock

@@ -0,0 +1,78 @@
+# Generated by pub
+# See https://dart.dev/tools/pub/glossary#lockfile
+packages:
+  characters:
+    dependency: transitive
+    description:
+      name: characters
+      sha256: faf38497bda5ead2a8c7615f4f7939df04333478bf32e4173fcb06d428b5716b
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.4.1"
+  collection:
+    dependency: transitive
+    description:
+      name: collection
+      sha256: "2f5709ae4d3d59dd8f7cd309b4e023046b57d8a6c82130785d2b0e5868084e76"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.19.1"
+  flutter:
+    dependency: "direct main"
+    description: flutter
+    source: sdk
+    version: "0.0.0"
+  flutter_lints:
+    dependency: "direct dev"
+    description:
+      name: flutter_lints
+      sha256: "3105dc8492f6183fb076ccf1f351ac3d60564bff92e20bfc4af9cc1651f4e7e1"
+      url: "https://pub.dev"
+    source: hosted
+    version: "6.0.0"
+  lints:
+    dependency: transitive
+    description:
+      name: lints
+      sha256: "12f842a479589fea194fe5c5a3095abc7be0c1f2ddfa9a0e76aed1dbd26a87df"
+      url: "https://pub.dev"
+    source: hosted
+    version: "6.1.0"
+  material_color_utilities:
+    dependency: transitive
+    description:
+      name: material_color_utilities
+      sha256: "9c337007e82b1889149c82ed242ed1cb24a66044e30979c44912381e9be4c48b"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.13.0"
+  meta:
+    dependency: transitive
+    description:
+      name: meta
+      sha256: "1741988757a65eb6b36abe716829688cf01910bbf91c34354ff7ec1c3de2b349"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.18.0"
+  sky_engine:
+    dependency: transitive
+    description: flutter
+    source: sdk
+    version: "0.0.0"
+  vector_math:
+    dependency: transitive
+    description:
+      name: vector_math
+      sha256: d530bd74fea330e6e364cda7a85019c434070188383e1cd8d9777ee586914c5b
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.2.0"
+  watch_bridge_contract:
+    dependency: "direct main"
+    description:
+      path: "../packages/watch_bridge_contract"
+      relative: true
+    source: path
+    version: "0.1.0"
+sdks:
+  dart: ">=3.10.0 <4.0.0"

watch_app/pubspec.yaml

@@ -0,0 +1,20 @@
+name: gametime_watch
+description: Wear OS companion app for GameTime workout sessions.
+publish_to: 'none'
+
+version: 0.1.0+1
+
+environment:
+  sdk: ^3.10.0
+
+dependencies:
+  flutter:
+    sdk: flutter
+  watch_bridge_contract:
+    path: ../packages/watch_bridge_contract
+
+dev_dependencies:
+  flutter_lints: ^6.0.0
+
+flutter:
+  uses-material-design: true