diff --git a/lib/l10n/app_de.arb b/lib/l10n/app_de.arb index bfe9ab4b5..74a4e4c56 100644 --- a/lib/l10n/app_de.arb +++ b/lib/l10n/app_de.arb @@ -3613,6 +3613,39 @@ "pairModeTitle": "In den Kopplungsmodus versetzen", "pairModeNoSite": "Ein generisches Gerät ohne einzelnen Hersteller, daher gibt es keine Herstelleranleitung.", "pairOuraExistingKeyGuidance": "Nutzt du schon die Oura-App? Lass den Ring in der App gekoppelt und kopple ihn mit seinem vorhandenen Schlüssel. Überspringe die Schritte zum Zurücksetzen unten. Setze ihn nur zurück, wenn du einen neuen Schlüssel möchtest.", + "pairAddDevice": "Gerät hinzufügen", + "pairKindAll": "Alle", + "pairKindStrap": "Brustgurte & Armsensoren", + "pairKindRing": "Ringe", + "pairKindWatch": "Uhren", + "pairGoBack": "Zurück", + "pairAddDeviceSub": "Ringe, Uhren und Herzfrequenzgurte", + "pairAddDeviceSubtitle": "Bei jedem Gerät steht, wofür es passt: jeden Tag oder nur beim Training.", + "pairBandFoundBody": "Jeden Tag kann es viel mehr als nur beim Training. Was möchtest du?", + "pairBandFoundBodyHasBand": "Du hast schon ein Band. Es kann immer nur eines dein Band sein.", + "pairIdentifiedBody": "Es sah wie ein Herzfrequenzgurt aus, hat sich beim Verbinden aber als {label} gemeldet. Es wurde nichts gespeichert.", + "pairAsMyBand": "Als mein Band koppeln", + "pairSecondaryPaired": "Fürs Training gekoppelt.", + "pairBandNow": "Dein Band jetzt: {name}. Deine Daten bleiben beim Wechsel erhalten.", + "pairReplaceBand": "Dieses Band koppeln, dann {name} trennen", + "pairReplaceConfirmTitle": "{name} nach erfolgreicher Verbindung ersetzen?", + "pairReplaceConfirmBody": "Dein bisheriges Band bleibt bei Fehlern oder Abbruch gekoppelt. Daten, die bereits auf diesem Telefon gespeichert sind, bleiben erhalten. Was auf dem alten Band noch nicht synchronisiert wurde, wird nach dem Wechsel nicht mehr auf dieses Telefon übertragen.", + "pairReplaceConfirmYes": "Ersatz koppeln", + "pairCurrentBandFallback": "dein Band", + "pairWearableLead": "Es kann deine Tage mit Schlaf, Erholung und Herzfrequenz füllen.", + "pairWearableNote": "Füllt Tage ohne dein WHOOP. Experimentell, also schalte es unter Geräte ein.", + "pairStrapLead": "Es liefert Herzfrequenz beim Training. Schlaf, Erholung und tägliche Belastung zeichnet es nicht auf.", + "pairStrapNote": "Schalte „Beim Training nutzen“ ein, damit die Herzfrequenz beim Training aufgezeichnet wird.", + "pairDeviceNamed": "{name} koppeln", + "pairUseForWorkouts": "Nur fürs Training nutzen", + "pairReplaceUnpairFailed": "Dein neues Band ist gekoppelt, aber das alte Band konnte nicht entfernt werden.", + "pairWearableLeadPebble": "Pebble 2 kann deine Tage mit Schlaf und Herzfrequenz füllen. Pebble 2 SE zeigt die eigenen Schlaf- und Schrittdaten der Uhr. Sie hat keinen Herzfrequenzsensor, daher kann diese App daraus weder die tägliche Belastung berechnen noch die Erholung schätzen.", + "pairMainBandWhoopOnly": "Hauptband: nur WHOOP 4.0 oder WHOOP 5.0/MG. Andere Geräte lassen sich als zusätzliche Geräte hinzufügen.", + "pairBandTitle": "Band koppeln", + "pairBandSubtitle": "Wähle das, das du trägst. Wir suchen es in der Nähe.", + "pairStrapOnlyLink": "Ich habe nur einen Herzfrequenzgurt", + "pairWhoopRowLine": "Schlaf, Erholung, Belastung, Herzfrequenz und mehr", + "pairSetUpTitle": "Einrichten", "welcomeCoachKeyReentry": "Dein API-Schlüssel für den Coach bleibt im sicheren Speicher und wurde nicht gesichert. Gib ihn in den KI-Einstellungen erneut ein, um den Coach auf diesem Telefon zu nutzen.", "welcomeSettingsSkipped": "{n, plural, =1{1 Einstellung in der Sicherung war nicht lesbar und wurde übersprungen} other{{n} Einstellungen in der Sicherung waren nicht lesbar und wurden übersprungen}}", "@welcomeSettingsSkipped": { @@ -3686,40 +3719,13 @@ "whoopFirmwareWarningTitle": "WHOOP-Nutzer: Verbinde dich nicht wieder mit der WHOOP-App", "whoopFirmwareWarningAction": "Wenn du OpenStrap oder eine andere Open-Source-App nutzt oder später zu einer wechseln möchtest, verbinde dein Band nicht wieder mit der offiziellen WHOOP-App. Sie kann Firmware-Updates automatisch installieren. Deinstalliere oder deaktiviere die WHOOP-App, damit sie dein Band nicht aktualisiert.", "whoopFirmwareWarningDetails": "Berichte zur WHOOP 5.0 / MG Firmware 50.43.1.0 und 50.43.2.0 beschreiben einen blockierten Datenzugriff. Bluetooth kann sich weiterhin verbinden. OpenStrap kann das von WHOOP signierte Mitgliedschafts-Token nicht ausstellen, das betroffene Bänder entsperrt. Wir arbeiten an einer Lösung, aber es gibt noch keine Abhilfe.", - "bandStatusFirmwareLockedTitle": "Die Firmware des Bands hält wahrscheinlich seine Daten zurück", - "bandStatusFirmwareLockedReason": "Dieses Band läuft mit WHOOP-Firmware 50.43. Sie kann sich verbinden und der App antworten, aber keine Aufzeichnungen und keine Live-Herzfrequenz senden, solange kein von WHOOP signiertes Mitgliedschafts-Token auf dem Band ist. Das ist ein möglicher Grund, warum keine Daten ankommen. OpenStrap kann dieses Token nicht ausstellen. Alles, was hier schon gespeichert ist, bleibt erhalten.", - "bandStatusFirmwareLockedFix": "Liegt es an der Firmware, lässt sich das in der App nicht ändern, und der Hinweis verschwindet, sobald das Band wieder Aufzeichnungen sendet", - "healthWearNotUpdatedSince": "nicht aktualisiert seit {time}", - "dayStrainWornAsOf": "Getragen, Stand {time}", - "dayStepsWhoop4NoCounter": "Ein WHOOP 4.0 hat keinen eigenen Schrittzähler und zählt Schritte nur, solange diese App seine Live-Daten empfängt.", - "pairAddDevice": "Gerät hinzufügen", - "pairKindAll": "Alle", - "pairKindStrap": "Brustgurte & Armsensoren", - "pairKindRing": "Ringe", - "pairKindWatch": "Uhren", - "pairGoBack": "Zurück", - "pairAddDeviceSub": "Ringe, Uhren und Herzfrequenzgurte", - "pairAddDeviceSubtitle": "Bei jedem Gerät steht, wofür es passt: jeden Tag oder nur beim Training.", - "pairBandFoundBody": "Jeden Tag kann es viel mehr als nur beim Training. Was möchtest du?", - "pairBandFoundBodyHasBand": "Du hast schon ein Band. Es kann immer nur eines dein Band sein.", - "pairIdentifiedBody": "Es sah wie ein Herzfrequenzgurt aus, hat sich beim Verbinden aber als {label} gemeldet. Es wurde nichts gespeichert.", - "pairAsMyBand": "Als mein Band koppeln", - "pairSecondaryPaired": "Fürs Training gekoppelt.", - "pairBandNow": "Dein Band jetzt: {name}. Deine Daten bleiben beim Wechsel erhalten.", - "pairReplaceBand": "Dieses Band koppeln, dann {name} trennen", - "pairReplaceConfirmTitle": "{name} nach erfolgreicher Verbindung ersetzen?", - "pairReplaceConfirmBody": "Dein bisheriges Band bleibt bei Fehlern oder Abbruch gekoppelt. Daten, die bereits auf diesem Telefon gespeichert sind, bleiben erhalten. Was auf dem alten Band noch nicht synchronisiert wurde, wird nach dem Wechsel nicht mehr auf dieses Telefon übertragen.", - "pairReplaceConfirmYes": "Ersatz koppeln", - "pairCurrentBandFallback": "dein Band", - "pairWearableLead": "Es kann deine Tage mit Schlaf, Erholung und Herzfrequenz füllen.", - "pairWearableNote": "Füllt Tage ohne dein WHOOP. Experimentell, also schalte es unter Geräte ein.", - "pairStrapLead": "Es liefert Herzfrequenz beim Training. Schlaf, Erholung und tägliche Belastung zeichnet es nicht auf.", - "pairStrapNote": "Für beides muss „Beim Training nutzen“ an sein.", - "pairDeviceNamed": "{name} koppeln", - "pairUseForWorkouts": "Nur fürs Training nutzen", - "pairReplaceUnpairFailed": "Dein neues Band ist gekoppelt, aber das alte Band konnte nicht entfernt werden.", - "pairWearableLeadPebble": "Pebble 2 kann deine Tage mit Schlaf, Erholung und Herzfrequenz füllen. Pebble 2 SE zeigt die eigenen Schlaf- und Schrittdaten der Uhr. Sie hat keinen Herzfrequenzsensor, daher kann diese App daraus weder die tägliche Belastung berechnen noch die Erholung schätzen.", "pairSearchDevices": "Nach Geräten suchen", "pairPrimaryCannotBeSensor": "Dies ist bereits dein Hauptarmband. Es kann nicht zusätzlich als Trainingssensor gekoppelt werden.", - "pairReplaceMyBand": "Mein Band ersetzen" + "pairReplaceMyBand": "Mein Band ersetzen", + "dayStepsWhoop4NoCounter": "Ein WHOOP 4.0 hat keinen eigenen Schrittzähler und zählt Schritte nur, solange diese App seine Live-Daten empfängt.", + "healthWearNotUpdatedSince": "nicht aktualisiert seit {time}", + "dayStrainWornAsOf": "Getragen, Stand {time}", + "bandStatusFirmwareLockedTitle": "Die Firmware des Bands hält wahrscheinlich seine Daten zurück", + "bandStatusFirmwareLockedReason": "Dieses Band läuft mit WHOOP-Firmware 50.43. Sie kann sich verbinden und der App antworten, aber keine Aufzeichnungen und keine Live-Herzfrequenz senden, solange kein von WHOOP signiertes Mitgliedschafts-Token auf dem Band ist. Das ist ein möglicher Grund, warum keine Daten ankommen. OpenStrap kann dieses Token nicht ausstellen. Alles, was hier schon gespeichert ist, bleibt erhalten.", + "bandStatusFirmwareLockedFix": "Liegt es an der Firmware, lässt sich das in der App nicht ändern, und der Hinweis verschwindet, sobald das Band wieder Aufzeichnungen sendet" } diff --git a/lib/l10n/app_en.arb b/lib/l10n/app_en.arb index 01dbbbfff..ea8ea869a 100644 --- a/lib/l10n/app_en.arb +++ b/lib/l10n/app_en.arb @@ -16873,9 +16873,9 @@ "@pairStrapLead": { "description": "Sheet lead for a heart-rate strap or sensor." }, - "pairStrapNote": "Both need “Use during workouts” on.", + "pairStrapNote": "Turn on “Use during workouts” to record heart rate while you work out.", "@pairStrapNote": { - "description": "Note under a strap’s table: both workout rows need the switch. Quotes deviceUseWorkoutsTitle." + "description": "Note on a strap’s sheet: workout recording needs the switch. Quotes deviceUseWorkoutsTitle." }, "pairDeviceNamed": "Pair {name}", "@pairDeviceNamed": { @@ -16894,10 +16894,34 @@ "@pairReplaceUnpairFailed": { "description": "Shown when unpairing the old band failed during “Unpair (your band) and pair this one”; nothing else ran." }, - "pairWearableLeadPebble": "Pebble 2 can fill your days with sleep, recovery and heart rate. Pebble 2 SE shows the watch’s own sleep and steps. It has no heart-rate sensor, so this app cannot calculate daily strain or estimate recovery from it.", + "pairWearableLeadPebble": "Pebble 2 can fill your days with sleep and heart rate. Pebble 2 SE shows the watch’s own sleep and steps. It has no heart-rate sensor, so this app cannot calculate daily strain or estimate recovery from it.", "@pairWearableLeadPebble": { "description": "Pebble-family pairing lead: SE shows the watch’s own sleep and steps; no HR sensor means no app-calculated daily strain or recovery estimate from the SE alone." }, + "pairMainBandWhoopOnly": "Main band: WHOOP 4.0 or WHOOP 5.0/MG only. Other devices can be added as additional devices.", + "@pairMainBandWhoopOnly": { + "description": "Plain statement on the pairing screens: only WHOOP can be the main band; other devices are added as additional devices." + }, + "pairBandTitle": "Pair your band", + "@pairBandTitle": { + "description": "Title of the first-run list of bands." + }, + "pairBandSubtitle": "Pick the one you wear. We will look for it nearby.", + "@pairBandSubtitle": { + "description": "Subtitle of the first-run list of bands." + }, + "pairStrapOnlyLink": "I only have a heart-rate strap", + "@pairStrapOnlyLink": { + "description": "Text link under the band list for someone with only a heart-rate strap." + }, + "pairWhoopRowLine": "Sleep, recovery, strain, heart rate and more", + "@pairWhoopRowLine": { + "description": "Line under each WHOOP on the first-run list." + }, + "pairSetUpTitle": "Set up", + "@pairSetUpTitle": { + "description": "Top bar title of the first-run pairing screen." + }, "welcomeCoachKeyReentry": "Your coach API key stays in secure storage and was not backed up. Enter it again in AI settings to use the coach on this phone.", "welcomeSettingsSkipped": "{n, plural, =1{1 setting in the backup could not be read and was skipped} other{{n} settings in the backup could not be read and were skipped}}", "@welcomeSettingsSkipped": { diff --git a/lib/l10n/app_es.arb b/lib/l10n/app_es.arb index be47323da..68308a213 100644 --- a/lib/l10n/app_es.arb +++ b/lib/l10n/app_es.arb @@ -3063,6 +3063,39 @@ "pairModeTitle": "Ponlo en modo de emparejamiento", "pairModeNoSite": "Un dispositivo genérico sin un único fabricante, así que no hay pasos del fabricante.", "pairOuraExistingKeyGuidance": "¿Ya usas la app de Oura? Mantén el anillo en esa app y emparéjalo con la clave que ya tiene. Omite los pasos de restablecimiento de abajo. Restablécelo solo si quieres una clave nueva.", + "pairAddDevice": "Añadir un dispositivo", + "pairKindAll": "Todos", + "pairKindStrap": "Bandas de pecho y brazo", + "pairKindRing": "Anillos", + "pairKindWatch": "Relojes", + "pairGoBack": "Volver", + "pairAddDeviceSub": "Anillos, relojes y bandas de frecuencia cardiaca", + "pairAddDeviceSubtitle": "Cada dispositivo muestra dónde encaja: todos los días o solo en entrenamientos.", + "pairBandFoundBody": "Hace mucho más todos los días que solo en los entrenamientos. ¿Qué prefieres?", + "pairBandFoundBodyHasBand": "Ya tienes una pulsera. Solo una puede ser tu pulsera a la vez.", + "pairIdentifiedBody": "Parecía una banda de frecuencia cardíaca, pero al conectar se identificó como {label}. No se guardó nada.", + "pairAsMyBand": "Emparejar como mi pulsera", + "pairSecondaryPaired": "Emparejado solo para entrenamientos.", + "pairBandNow": "Tu pulsera ahora: {name}. Tus datos se conservan al cambiar.", + "pairReplaceBand": "Vincular esta pulsera y después desconectar {name}", + "pairReplaceConfirmTitle": "¿Reemplazar {name} después de conectar esta pulsera?", + "pairReplaceConfirmBody": "Tu pulsera actual seguirá vinculada si falla la configuración o cancelas. Los datos ya guardados en este teléfono se conservan. Lo que aún no se haya sincronizado desde la pulsera anterior no se sincronizará con este teléfono tras el cambio.", + "pairReplaceConfirmYes": "Vincular reemplazo", + "pairCurrentBandFallback": "tu pulsera", + "pairWearableLead": "Puede completar tus días con sueño, recuperación y frecuencia cardiaca.", + "pairWearableNote": "Completa los días sin tu WHOOP. Es experimental, así que actívalo en Dispositivos.", + "pairStrapLead": "Añade la frecuencia cardiaca mientras entrenas. No registra sueño, recuperación ni esfuerzo diario.", + "pairStrapNote": "Activa «Usar durante los entrenamientos» para registrar la frecuencia cardiaca durante los entrenamientos.", + "pairDeviceNamed": "Emparejar {name}", + "pairUseForWorkouts": "Usarla solo para entrenamientos", + "pairReplaceUnpairFailed": "Tu pulsera nueva está emparejada, pero no se pudo quitar la anterior.", + "pairWearableLeadPebble": "Pebble 2 puede completar tus días con sueño y frecuencia cardiaca. Pebble 2 SE muestra el sueño y los pasos registrados por el propio reloj. No tiene sensor de frecuencia cardiaca, por lo que esta app no puede calcular la carga diaria ni estimar la recuperación a partir de sus datos.", + "pairMainBandWhoopOnly": "Pulsera principal: solo WHOOP 4.0 o WHOOP 5.0/MG. Los demás dispositivos se pueden añadir como dispositivos adicionales.", + "pairBandTitle": "Empareja tu pulsera", + "pairBandSubtitle": "Elige la que llevas puesta. La buscaremos cerca.", + "pairStrapOnlyLink": "Solo tengo una banda de frecuencia cardíaca", + "pairWhoopRowLine": "Sueño, recuperación, esfuerzo, frecuencia cardiaca y más", + "pairSetUpTitle": "Configurar", "alarmNextLabel": "SIGUIENTE", "alarmScheduleGroup": "Horario semanal", "alarmWakeTimeRowTitle": "Hora de despertar", @@ -3386,40 +3419,13 @@ "whoopFirmwareWarningTitle": "Usuarios de WHOOP: no vuelvas a conectarte a la app de WHOOP", "whoopFirmwareWarningAction": "Si usas OpenStrap u otra app de código abierto, o piensas cambiarte a una más adelante, no vuelvas a conectar tu banda a la app oficial de WHOOP. Puede instalar actualizaciones de firmware automáticamente. Desinstala o desactiva la app de WHOOP para evitar que actualice tu banda.", "whoopFirmwareWarningDetails": "Hay informes de que el firmware 50.43.1.0 y 50.43.2.0 de WHOOP 5.0 / MG bloquea el acceso a los datos. Es posible que el Bluetooth siga conectándose. OpenStrap no puede emitir el token de membresía firmado por WHOOP que se necesita para desbloquear las bandas afectadas. Estamos trabajando en una solución, pero todavía no hay ningún arreglo disponible.", - "bandStatusFirmwareLockedTitle": "Probablemente el firmware de la banda está reteniendo sus datos", - "bandStatusFirmwareLockedReason": "Esta banda usa el firmware 50.43 de WHOOP, que puede conectarse y responder a la app sin enviar registros ni frecuencia cardíaca en vivo hasta que haya en ella un token de membresía firmado por WHOOP. Es una posible razón de que no lleguen datos. OpenStrap no puede emitir ese token. Todo lo que ya está guardado aquí está a salvo.", - "bandStatusFirmwareLockedFix": "Si es el firmware, la app no puede cambiarlo y el aviso desaparece cuando la banda vuelva a enviar registros", - "healthWearNotUpdatedSince": "sin actualizar desde {time}", - "dayStrainWornAsOf": "Llevada, a las {time}", - "dayStepsWhoop4NoCounter": "Una WHOOP 4.0 no tiene contador de pasos propio, así que solo cuenta pasos mientras esta app recibe sus datos en vivo.", - "pairAddDevice": "Añadir un dispositivo", - "pairKindAll": "Todos", - "pairKindStrap": "Bandas de pecho y brazo", - "pairKindRing": "Anillos", - "pairKindWatch": "Relojes", - "pairGoBack": "Volver", - "pairAddDeviceSub": "Anillos, relojes y bandas de frecuencia cardiaca", - "pairAddDeviceSubtitle": "Cada dispositivo muestra dónde encaja: todos los días o solo en entrenamientos.", - "pairBandFoundBody": "Hace mucho más todos los días que solo en los entrenamientos. ¿Qué prefieres?", - "pairBandFoundBodyHasBand": "Ya tienes una pulsera. Solo una puede ser tu pulsera a la vez.", - "pairIdentifiedBody": "Parecía una banda de frecuencia cardíaca, pero al conectar se identificó como {label}. No se guardó nada.", - "pairAsMyBand": "Emparejar como mi pulsera", - "pairSecondaryPaired": "Emparejado solo para entrenamientos.", - "pairBandNow": "Tu pulsera ahora: {name}. Tus datos se conservan al cambiar.", - "pairReplaceBand": "Vincular esta pulsera y después desconectar {name}", - "pairReplaceConfirmTitle": "¿Reemplazar {name} después de conectar esta pulsera?", - "pairReplaceConfirmBody": "Tu pulsera actual seguirá vinculada si falla la configuración o cancelas. Los datos ya guardados en este teléfono se conservan. Lo que aún no se haya sincronizado desde la pulsera anterior no se sincronizará con este teléfono tras el cambio.", - "pairReplaceConfirmYes": "Vincular reemplazo", - "pairCurrentBandFallback": "tu pulsera", - "pairWearableLead": "Puede completar tus días con sueño, recuperación y frecuencia cardiaca.", - "pairWearableNote": "Completa los días sin tu WHOOP. Es experimental, así que actívalo en Dispositivos.", - "pairStrapLead": "Añade la frecuencia cardiaca mientras entrenas. No registra sueño, recuperación ni esfuerzo diario.", - "pairStrapNote": "Ambos necesitan «Usar durante los entrenamientos» activado.", - "pairDeviceNamed": "Emparejar {name}", - "pairUseForWorkouts": "Usarla solo para entrenamientos", - "pairReplaceUnpairFailed": "Tu pulsera nueva está emparejada, pero no se pudo quitar la anterior.", - "pairWearableLeadPebble": "Pebble 2 puede completar tus días con sueño, recuperación y frecuencia cardiaca. Pebble 2 SE muestra el sueño y los pasos registrados por el propio reloj. No tiene sensor de frecuencia cardiaca, por lo que esta app no puede calcular la carga diaria ni estimar la recuperación a partir de sus datos.", "pairSearchDevices": "Buscar dispositivos", "pairPrimaryCannotBeSensor": "Esta ya es tu pulsera principal. No se puede emparejar también como sensor de entrenamiento.", - "pairReplaceMyBand": "Reemplazar mi pulsera" + "pairReplaceMyBand": "Reemplazar mi pulsera", + "dayStepsWhoop4NoCounter": "Una WHOOP 4.0 no tiene contador de pasos propio, así que solo cuenta pasos mientras esta app recibe sus datos en vivo.", + "healthWearNotUpdatedSince": "sin actualizar desde {time}", + "dayStrainWornAsOf": "Llevada, a las {time}", + "bandStatusFirmwareLockedTitle": "Probablemente el firmware de la banda está reteniendo sus datos", + "bandStatusFirmwareLockedReason": "Esta banda usa el firmware 50.43 de WHOOP, que puede conectarse y responder a la app sin enviar registros ni frecuencia cardíaca en vivo hasta que haya en ella un token de membresía firmado por WHOOP. Es una posible razón de que no lleguen datos. OpenStrap no puede emitir ese token. Todo lo que ya está guardado aquí está a salvo.", + "bandStatusFirmwareLockedFix": "Si es el firmware, la app no puede cambiarlo y el aviso desaparece cuando la banda vuelva a enviar registros" } diff --git a/lib/l10n/app_fr.arb b/lib/l10n/app_fr.arb index 54f08cbe8..2355ad698 100644 --- a/lib/l10n/app_fr.arb +++ b/lib/l10n/app_fr.arb @@ -3383,15 +3383,6 @@ "pairModeTitle": "Mettez-le en mode association", "pairModeNoSite": "Un appareil générique sans fabricant unique : il n’y a donc pas d’étapes du fabricant.", "pairOuraExistingKeyGuidance": "Vous utilisez déjà l’application Oura ? Gardez l’anneau associé dans cette application et associez-le avec sa clé actuelle. Passez les étapes de réinitialisation ci-dessous. Réinitialisez-le uniquement si vous voulez une nouvelle clé.", - "whoopFirmwareWarningTitle": "Utilisateurs WHOOP : ne vous reconnectez pas à l’application WHOOP", - "whoopFirmwareWarningAction": "Si vous utilisez OpenStrap ou une autre application open source, ou si vous comptez y passer plus tard, ne reconnectez pas votre bracelet à l’application WHOOP officielle. Elle peut installer des mises à jour du firmware automatiquement. Désinstallez ou désactivez l’application WHOOP pour l’empêcher de mettre à jour votre bracelet.", - "whoopFirmwareWarningDetails": "Des signalements concernant les firmwares 50.43.1.0 et 50.43.2.0 des WHOOP 5.0 / MG décrivent un accès aux données bloqué. Le Bluetooth peut encore se connecter. OpenStrap ne peut pas émettre le jeton d’abonnement signé par WHOOP nécessaire pour déverrouiller les bracelets concernés. Nous travaillons sur une solution, mais aucun correctif n’est encore disponible.", - "bandStatusFirmwareLockedTitle": "Le firmware du bracelet retient probablement ses données", - "bandStatusFirmwareLockedReason": "Ce bracelet utilise le firmware WHOOP 50.43, qui peut se connecter et répondre à l’application sans envoyer ni enregistrements ni fréquence cardiaque en direct tant qu’un jeton d’abonnement signé par WHOOP n’est pas présent sur le bracelet. C’est une raison possible pour laquelle aucune donnée n’arrive. OpenStrap ne peut pas émettre ce jeton. Tout ce qui est déjà enregistré ici est en sécurité.", - "bandStatusFirmwareLockedFix": "Si c’est le firmware, l’application n’y peut rien et ce message disparaît dès que le bracelet renvoie des enregistrements", - "healthWearNotUpdatedSince": "pas mis à jour depuis {time}", - "dayStrainWornAsOf": "Porté, à {time}", - "dayStepsWhoop4NoCounter": "Un WHOOP 4.0 n’a pas de podomètre intégré : il ne compte les pas que lorsque cette application reçoit ses données en direct.", "pairAddDevice": "Ajouter un appareil", "pairKindAll": "Tous", "pairKindStrap": "Ceintures et brassards", @@ -3414,12 +3405,27 @@ "pairWearableLead": "Il peut compléter vos journées avec le sommeil, la récupération et la fréquence cardiaque.", "pairWearableNote": "Complète les jours sans votre WHOOP. Expérimental : activez-le dans Appareils.", "pairStrapLead": "Il ajoute la fréquence cardiaque pendant l’entraînement. Il n’enregistre ni le sommeil, ni la récupération, ni l’effort quotidien.", - "pairStrapNote": "Les deux nécessitent « Utiliser pendant les entraînements » activé.", + "pairStrapNote": "Activez « Utiliser pendant les entraînements » pour enregistrer la fréquence cardiaque pendant vos entraînements.", "pairDeviceNamed": "Associer {name}", "pairUseForWorkouts": "L’utiliser seulement pour les entraînements", "pairReplaceUnpairFailed": "Votre nouveau bracelet est associé, mais l’ancien n’a pas pu être retiré.", - "pairWearableLeadPebble": "Pebble 2 peut compléter vos journées avec le sommeil, la récupération et la fréquence cardiaque. Pebble 2 SE affiche le sommeil et les pas enregistrés par la montre. Elle n’a pas de capteur de fréquence cardiaque, donc cette app ne peut pas calculer la charge quotidienne ni estimer la récupération à partir de ses données.", + "pairWearableLeadPebble": "Pebble 2 peut compléter vos journées avec le sommeil et la fréquence cardiaque. Pebble 2 SE affiche le sommeil et les pas enregistrés par la montre. Elle n’a pas de capteur de fréquence cardiaque, donc cette app ne peut pas calculer la charge quotidienne ni estimer la récupération à partir de ses données.", + "pairMainBandWhoopOnly": "Bracelet principal : uniquement WHOOP 4.0 ou WHOOP 5.0/MG. Les autres appareils peuvent être ajoutés comme appareils supplémentaires.", + "pairBandTitle": "Associez votre bracelet", + "pairBandSubtitle": "Choisissez celui que vous portez. Nous le chercherons à proximité.", + "pairStrapOnlyLink": "J’ai seulement une ceinture cardiaque", + "pairWhoopRowLine": "Sommeil, récupération, effort, fréquence cardiaque et plus", + "pairSetUpTitle": "Configuration", + "whoopFirmwareWarningTitle": "Utilisateurs WHOOP : ne vous reconnectez pas à l’application WHOOP", + "whoopFirmwareWarningAction": "Si vous utilisez OpenStrap ou une autre application open source, ou si vous comptez y passer plus tard, ne reconnectez pas votre bracelet à l’application WHOOP officielle. Elle peut installer des mises à jour du firmware automatiquement. Désinstallez ou désactivez l’application WHOOP pour l’empêcher de mettre à jour votre bracelet.", + "whoopFirmwareWarningDetails": "Des signalements concernant les firmwares 50.43.1.0 et 50.43.2.0 des WHOOP 5.0 / MG décrivent un accès aux données bloqué. Le Bluetooth peut encore se connecter. OpenStrap ne peut pas émettre le jeton d’abonnement signé par WHOOP nécessaire pour déverrouiller les bracelets concernés. Nous travaillons sur une solution, mais aucun correctif n’est encore disponible.", "pairSearchDevices": "Rechercher des appareils", "pairPrimaryCannotBeSensor": "C’est déjà votre bracelet principal. Il ne peut pas aussi être jumelé comme capteur d’entraînement.", - "pairReplaceMyBand": "Remplacer mon bracelet" + "pairReplaceMyBand": "Remplacer mon bracelet", + "dayStepsWhoop4NoCounter": "Un WHOOP 4.0 n’a pas de podomètre intégré : il ne compte les pas que lorsque cette application reçoit ses données en direct.", + "healthWearNotUpdatedSince": "pas mis à jour depuis {time}", + "dayStrainWornAsOf": "Porté, à {time}", + "bandStatusFirmwareLockedTitle": "Le firmware du bracelet retient probablement ses données", + "bandStatusFirmwareLockedReason": "Ce bracelet utilise le firmware WHOOP 50.43, qui peut se connecter et répondre à l’application sans envoyer ni enregistrements ni fréquence cardiaque en direct tant qu’un jeton d’abonnement signé par WHOOP n’est pas présent sur le bracelet. C’est une raison possible pour laquelle aucune donnée n’arrive. OpenStrap ne peut pas émettre ce jeton. Tout ce qui est déjà enregistré ici est en sécurité.", + "bandStatusFirmwareLockedFix": "Si c’est le firmware, l’application n’y peut rien et ce message disparaît dès que le bracelet renvoie des enregistrements" } diff --git a/lib/l10n/app_hi.arb b/lib/l10n/app_hi.arb index 81e005d33..0df9e2575 100644 --- a/lib/l10n/app_hi.arb +++ b/lib/l10n/app_hi.arb @@ -3034,12 +3034,44 @@ "pairModeTitle": "इसे पेयरिंग मोड में डालें", "pairModeNoSite": "यह किसी एक निर्माता का नहीं, एक सामान्य डिवाइस है, इसलिए निर्माता के कोई चरण नहीं हैं।", "pairOuraExistingKeyGuidance": "क्या आप पहले से Oura ऐप इस्तेमाल करते हैं? रिंग को उस ऐप में पेयर रहने दें और उसकी मौजूदा कुंजी से पेयर करें। नीचे दिए रीसेट के चरण छोड़ दें। केवल नई कुंजी चाहिए तो ही रीसेट करें।", + "pairAddDevice": "डिवाइस जोड़ें", + "pairKindAll": "सभी", + "pairKindStrap": "चेस्ट स्ट्रैप और आर्मबैंड", + "pairKindRing": "रिंग", + "pairKindWatch": "घड़ियाँ", + "pairGoBack": "वापस जाएँ", + "pairAddDeviceSub": "रिंग, घड़ियाँ और हार्ट-रेट स्ट्रैप", + "pairAddDeviceSubtitle": "हर डिवाइस दिखाता है कि वह कहाँ फ़िट होता है: हर दिन, या केवल वर्कआउट में।", + "pairBandFoundBody": "यह सिर्फ़ वर्कआउट की तुलना में हर दिन कहीं ज़्यादा करता है। आप क्या चाहते हैं?", + "pairBandFoundBodyHasBand": "आपके पास पहले से एक बैंड है। एक समय में केवल एक ही आपका बैंड हो सकता है।", + "pairIdentifiedBody": "यह हार्ट-रेट स्ट्रैप जैसा दिखा, लेकिन कनेक्ट होने पर इसने खुद को {label} बताया। कुछ भी सहेजा नहीं गया।", + "pairAsMyBand": "इसे मेरे बैंड के रूप में पेयर करें", + "pairSecondaryPaired": "केवल वर्कआउट के लिए पेयर किया गया।", + "pairBandNow": "अभी आपका बैंड: {name}। बदलने पर आपका डेटा बना रहता है।", + "pairReplaceBand": "यह बैंड पेयर करें, फिर {name} को डिस्कनेक्ट करें", + "pairReplaceConfirmTitle": "यह बैंड कनेक्ट होने के बाद {name} को बदलें?", + "pairReplaceConfirmBody": "सेटअप विफल होने या रद्द करने पर आपका मौजूदा बैंड पेयर रहेगा। इस फ़ोन पर पहले से सहेजा गया डेटा बना रहेगा। पुराने बैंड पर जो डेटा अभी सिंक नहीं हुआ है, वह बदलाव के बाद इस फ़ोन पर सिंक नहीं होगा।", + "pairReplaceConfirmYes": "नया बैंड पेयर करें", + "pairCurrentBandFallback": "आपका बैंड", + "pairWearableLead": "यह आपके दिनों को नींद, रिकवरी और हृदय गति से भर सकता है।", + "pairWearableNote": "आपके WHOOP के बिना वाले दिनों को भरता है। प्रायोगिक है, इसलिए इसे डिवाइस में चालू करें।", + "pairStrapLead": "यह वर्कआउट के दौरान हृदय गति जोड़ता है। यह नींद, रिकवरी या दैनिक शारीरिक परिश्रम रिकॉर्ड नहीं करता।", + "pairStrapNote": "वर्कआउट के दौरान हृदय गति रिकॉर्ड करने के लिए “वर्कआउट के दौरान इस्तेमाल करें” चालू करें।", + "pairDeviceNamed": "{name} पेयर करें", + "pairUseForWorkouts": "इसे केवल वर्कआउट के लिए इस्तेमाल करें", + "pairReplaceUnpairFailed": "आपका नया बैंड पेयर हो गया है, लेकिन पुराना बैंड हटाया नहीं जा सका।", + "pairWearableLeadPebble": "Pebble 2 आपके दिनों को नींद और हृदय गति से भर सकता है। Pebble 2 SE घड़ी की अपनी नींद और कदमों की रीडिंग दिखाता है। उसमें हृदय गति सेंसर नहीं है, इसलिए यह ऐप उसके डेटा से रोज़ का शारीरिक भार नहीं निकाल सकता और न ही रिकवरी का अनुमान लगा सकता है।", + "pairMainBandWhoopOnly": "मुख्य बैंड: केवल WHOOP 4.0 या WHOOP 5.0/MG। दूसरे डिवाइस अतिरिक्त डिवाइस के रूप में जोड़े जा सकते हैं।", + "pairBandTitle": "अपना बैंड पेयर करें", + "pairBandSubtitle": "वही चुनें जो आप पहनते हैं। हम उसे आस-पास खोजेंगे।", + "pairStrapOnlyLink": "मेरे पास सिर्फ़ हार्ट-रेट स्ट्रैप है", + "pairWhoopRowLine": "नींद, रिकवरी, शारीरिक परिश्रम, हृदय गति और बहुत कुछ", + "pairSetUpTitle": "सेट अप", "whoopFirmwareWarningTitle": "WHOOP उपयोगकर्ता: WHOOP ऐप से दोबारा कनेक्ट न करें", "whoopFirmwareWarningAction": "अगर आप OpenStrap या कोई दूसरा ओपन-सोर्स ऐप इस्तेमाल करते हैं, या बाद में किसी पर जाने की सोच रहे हैं, तो अपना बैंड आधिकारिक WHOOP ऐप से दोबारा कनेक्ट न करें। वह फ़र्मवेयर अपडेट अपने-आप इंस्टॉल कर सकता है। WHOOP ऐप को अनइंस्टॉल या अक्षम कर दें, ताकि वह आपके बैंड को अपडेट न कर सके।", "whoopFirmwareWarningDetails": "WHOOP 5.0 / MG के फ़र्मवेयर 50.43.1.0 और 50.43.2.0 के बारे में रिपोर्टें बताती हैं कि डेटा तक पहुँच रोक दी जाती है। ब्लूटूथ फिर भी कनेक्ट हो सकता है। प्रभावित बैंड को अनलॉक करने के लिए WHOOP द्वारा साइन किया गया मेंबरशिप टोकन चाहिए, जिसे OpenStrap जारी नहीं कर सकता। हम समाधान पर काम कर रहे हैं, लेकिन अभी कोई उपाय उपलब्ध नहीं है।", - "bandStatusFirmwareLockedTitle": "बैंड का फ़र्मवेयर शायद उसका डेटा रोक रहा है", - "bandStatusFirmwareLockedReason": "यह बैंड WHOOP फ़र्मवेयर 50.43 पर चल रहा है, जो कनेक्ट होकर ऐप को जवाब दे सकता है, लेकिन जब तक बैंड पर WHOOP द्वारा साइन किया गया सदस्यता टोकन न हो, तब तक हो सकता है कि कोई रिकॉर्डिंग या लाइव हृदय गति न भेजे। डेटा न आने का एक संभावित कारण यह हो सकता है। OpenStrap वह टोकन जारी नहीं कर सकता। यहाँ पहले से सहेजा गया सब कुछ सुरक्षित है।", - "bandStatusFirmwareLockedFix": "अगर वजह फ़र्मवेयर है, तो ऐप इसे बदल नहीं सकता और बैंड के फिर से रिकॉर्डिंग भेजते ही यह संदेश हट जाएगा", + "pairSearchDevices": "डिवाइस खोजें", + "pairPrimaryCannotBeSensor": "यह पहले से आपका मुख्य बैंड है। इसे वर्कआउट सेंसर के रूप में भी पेयर नहीं किया जा सकता।", "alarmNextLabel": "अगला", "alarmScheduleGroup": "साप्ताहिक शेड्यूल", "alarmWakeTimeRowTitle": "जागने का समय", @@ -3389,37 +3421,11 @@ "stepCalSaveFailed": "वह कैलिब्रेशन सहेजा नहीं जा सका।", "stepCalDoneGait": "सहेजा गया। आपने {count} कदम गिने और बैंड ने {band} कदम देखे। अब से इस तरह की चाल {pct}% से ठीक की जाएगी।", "stepCalDoneHousehold": "सहेजा गया। बैंड द्वारा देखे गए {band} कदमों में से आपके फ़ोन ने {count} कदम गिने। घर के कामों की हलचल अब {gain} के अनुपात में समायोजित होगी।", + "pairReplaceMyBand": "मेरा बैंड बदलें", + "dayStepsWhoop4NoCounter": "WHOOP 4.0 में अपना कोई स्टेप काउंटर नहीं है, इसलिए यह कदम तभी गिनता है जब यह ऐप उसका लाइव डेटा प्राप्त कर रहा हो।", "healthWearNotUpdatedSince": "{time} से अपडेट नहीं हुआ", "dayStrainWornAsOf": "पहना, {time} तक का आंकड़ा", - "dayStepsWhoop4NoCounter": "WHOOP 4.0 में अपना कोई स्टेप काउंटर नहीं है, इसलिए यह कदम तभी गिनता है जब यह ऐप उसका लाइव डेटा प्राप्त कर रहा हो।", - "pairAddDevice": "डिवाइस जोड़ें", - "pairKindAll": "सभी", - "pairKindStrap": "चेस्ट स्ट्रैप और आर्मबैंड", - "pairKindRing": "रिंग", - "pairKindWatch": "घड़ियाँ", - "pairGoBack": "वापस जाएँ", - "pairAddDeviceSub": "रिंग, घड़ियाँ और हार्ट-रेट स्ट्रैप", - "pairAddDeviceSubtitle": "हर डिवाइस दिखाता है कि वह कहाँ फ़िट होता है: हर दिन, या केवल वर्कआउट में।", - "pairBandFoundBody": "यह सिर्फ़ वर्कआउट की तुलना में हर दिन कहीं ज़्यादा करता है। आप क्या चाहते हैं?", - "pairBandFoundBodyHasBand": "आपके पास पहले से एक बैंड है। एक समय में केवल एक ही आपका बैंड हो सकता है।", - "pairIdentifiedBody": "यह हार्ट-रेट स्ट्रैप जैसा दिखा, लेकिन कनेक्ट होने पर इसने खुद को {label} बताया। कुछ भी सहेजा नहीं गया।", - "pairAsMyBand": "इसे मेरे बैंड के रूप में पेयर करें", - "pairSecondaryPaired": "केवल वर्कआउट के लिए पेयर किया गया।", - "pairBandNow": "अभी आपका बैंड: {name}। बदलने पर आपका डेटा बना रहता है।", - "pairReplaceBand": "यह बैंड पेयर करें, फिर {name} को डिस्कनेक्ट करें", - "pairReplaceConfirmTitle": "यह बैंड कनेक्ट होने के बाद {name} को बदलें?", - "pairReplaceConfirmBody": "सेटअप विफल होने या रद्द करने पर आपका मौजूदा बैंड पेयर रहेगा। इस फ़ोन पर पहले से सहेजा गया डेटा बना रहेगा। पुराने बैंड पर जो डेटा अभी सिंक नहीं हुआ है, वह बदलाव के बाद इस फ़ोन पर सिंक नहीं होगा।", - "pairReplaceConfirmYes": "नया बैंड पेयर करें", - "pairCurrentBandFallback": "आपका बैंड", - "pairWearableLead": "यह आपके दिनों को नींद, रिकवरी और हृदय गति से भर सकता है।", - "pairWearableNote": "आपके WHOOP के बिना वाले दिनों को भरता है। प्रायोगिक है, इसलिए इसे डिवाइस में चालू करें।", - "pairStrapLead": "यह वर्कआउट के दौरान हृदय गति जोड़ता है। यह नींद, रिकवरी या दैनिक शारीरिक परिश्रम रिकॉर्ड नहीं करता।", - "pairStrapNote": "दोनों के लिए “वर्कआउट के दौरान इस्तेमाल करें” चालू होना चाहिए।", - "pairDeviceNamed": "{name} पेयर करें", - "pairUseForWorkouts": "इसे केवल वर्कआउट के लिए इस्तेमाल करें", - "pairReplaceUnpairFailed": "आपका नया बैंड पेयर हो गया है, लेकिन पुराना बैंड हटाया नहीं जा सका।", - "pairWearableLeadPebble": "Pebble 2 आपके दिनों को नींद, रिकवरी और हृदय गति से भर सकता है। Pebble 2 SE घड़ी की अपनी नींद और कदमों की रीडिंग दिखाता है। उसमें हृदय गति सेंसर नहीं है, इसलिए यह ऐप उसके डेटा से रोज़ का शारीरिक भार नहीं निकाल सकता और न ही रिकवरी का अनुमान लगा सकता है।", - "pairSearchDevices": "डिवाइस खोजें", - "pairPrimaryCannotBeSensor": "यह पहले से आपका मुख्य बैंड है। इसे वर्कआउट सेंसर के रूप में भी पेयर नहीं किया जा सकता।", - "pairReplaceMyBand": "मेरा बैंड बदलें" + "bandStatusFirmwareLockedTitle": "बैंड का फ़र्मवेयर शायद उसका डेटा रोक रहा है", + "bandStatusFirmwareLockedReason": "यह बैंड WHOOP फ़र्मवेयर 50.43 पर चल रहा है, जो कनेक्ट होकर ऐप को जवाब दे सकता है, लेकिन जब तक बैंड पर WHOOP द्वारा साइन किया गया सदस्यता टोकन न हो, तब तक हो सकता है कि कोई रिकॉर्डिंग या लाइव हृदय गति न भेजे। डेटा न आने का एक संभावित कारण यह हो सकता है। OpenStrap वह टोकन जारी नहीं कर सकता। यहाँ पहले से सहेजा गया सब कुछ सुरक्षित है।", + "bandStatusFirmwareLockedFix": "अगर वजह फ़र्मवेयर है, तो ऐप इसे बदल नहीं सकता और बैंड के फिर से रिकॉर्डिंग भेजते ही यह संदेश हट जाएगा" } diff --git a/lib/l10n/app_ru.arb b/lib/l10n/app_ru.arb index 125493439..c63dc4323 100644 --- a/lib/l10n/app_ru.arb +++ b/lib/l10n/app_ru.arb @@ -8213,7 +8213,7 @@ "pairWearableLead": "Он может заполнять ваши дни данными о сне, восстановлении и пульсе.", "pairWearableNote": "Заполняет дни без вашего WHOOP. Экспериментально, поэтому включите это в разделе «Устройства».", "pairStrapLead": "Он добавляет пульс во время тренировки. Сон, восстановление и дневную нагрузку он не записывает.", - "pairStrapNote": "Для обоих нужно включить «Использовать во время тренировок».", + "pairStrapNote": "Включите «Использовать во время тренировок», чтобы записывать пульс во время тренировок.", "pairDeviceNamed": "Подключить {name}", "@pairDeviceNamed": { "placeholders": { @@ -8224,7 +8224,13 @@ }, "pairUseForWorkouts": "Использовать только для тренировок", "pairReplaceUnpairFailed": "Новый браслет сопряжён, но старый удалить не удалось.", - "pairWearableLeadPebble": "Pebble 2 может заполнять ваши дни данными о сне, восстановлении и пульсе. Pebble 2 SE показывает сон и шаги по данным самих часов. У него нет датчика пульса, поэтому приложение не может рассчитать дневную нагрузку или оценить восстановление по его данным.", + "pairWearableLeadPebble": "Pebble 2 может заполнять ваши дни данными о сне и пульсе. Pebble 2 SE показывает сон и шаги по данным самих часов. У него нет датчика пульса, поэтому приложение не может рассчитать дневную нагрузку или оценить восстановление по его данным.", + "pairMainBandWhoopOnly": "Основной браслет: только WHOOP 4.0 или WHOOP 5.0/MG. Другие устройства можно добавить как дополнительные.", + "pairBandTitle": "Подключите браслет", + "pairBandSubtitle": "Выберите то, что вы носите. Мы поищем его поблизости.", + "pairStrapOnlyLink": "У меня только пульсовой ремень", + "pairWhoopRowLine": "Сон, восстановление, нагрузка, пульс и многое другое", + "pairSetUpTitle": "Настройка", "pairSearchDevices": "Найти устройства", "pairPrimaryCannotBeSensor": "Это уже ваш основной браслет. Его нельзя также подключить как датчик для тренировок.", "pairReplaceMyBand": "Заменить мой браслет", diff --git a/lib/l10n/app_th.arb b/lib/l10n/app_th.arb index a93612e91..eeb256eb0 100644 --- a/lib/l10n/app_th.arb +++ b/lib/l10n/app_th.arb @@ -16739,7 +16739,7 @@ "@pairStrapLead": { "description": "Sheet lead for a heart-rate strap or sensor." }, - "pairStrapNote": "ทั้งสองอย่างต้องเปิด “ใช้ระหว่างออกกำลังกาย”", + "pairStrapNote": "เปิด “ใช้ระหว่างออกกำลังกาย” เพื่อบันทึกอัตราการเต้นของหัวใจระหว่างออกกำลังกาย", "@pairStrapNote": { "description": "Note under a strap’s table: both workout rows need the switch. Quotes deviceUseWorkoutsTitle." }, @@ -16760,7 +16760,31 @@ "@pairReplaceUnpairFailed": { "description": "Shown when unpairing the old band failed during “Unpair (your band) and pair this one”; nothing else ran." }, - "pairWearableLeadPebble": "Pebble 2 เติมข้อมูลการนอน การฟื้นตัว และอัตราการเต้นของหัวใจให้แต่ละวันได้ Pebble 2 SE แสดงข้อมูลการนอนและจำนวนก้าวที่นาฬิกาบันทึกเอง รุ่นนี้ไม่มีเซ็นเซอร์วัดอัตราการเต้นของหัวใจ แอปจึงคำนวณภาระร่างกายรายวันหรือประเมินการฟื้นตัวจากข้อมูลของรุ่นนี้ไม่ได้", + "pairWearableLeadPebble": "Pebble 2 เติมข้อมูลการนอนและอัตราการเต้นของหัวใจให้แต่ละวันได้ Pebble 2 SE แสดงข้อมูลการนอนและจำนวนก้าวที่นาฬิกาบันทึกเอง รุ่นนี้ไม่มีเซ็นเซอร์วัดอัตราการเต้นของหัวใจ แอปจึงคำนวณภาระร่างกายรายวันหรือประเมินการฟื้นตัวจากข้อมูลของรุ่นนี้ไม่ได้", + "pairMainBandWhoopOnly": "สายรัดหลัก: WHOOP 4.0 หรือ WHOOP 5.0/MG เท่านั้น อุปกรณ์อื่นเพิ่มเป็นอุปกรณ์เสริมได้", + "@pairMainBandWhoopOnly": { + "description": "Plain statement on the pairing screens: only WHOOP can be the main band; other devices are added as additional devices." + }, + "pairBandTitle": "จับคู่สายรัดของคุณ", + "@pairBandTitle": { + "description": "Title of the first-run list of bands." + }, + "pairBandSubtitle": "เลือกอันที่คุณสวมอยู่ เราจะค้นหาในบริเวณใกล้เคียง", + "@pairBandSubtitle": { + "description": "Subtitle of the first-run list of bands." + }, + "pairStrapOnlyLink": "ฉันมีแค่สายคาดวัดหัวใจ", + "@pairStrapOnlyLink": { + "description": "Text link under the band list for someone with only a heart-rate strap." + }, + "pairWhoopRowLine": "การนอน การฟื้นตัว ความหนัก อัตราการเต้นของหัวใจ และอื่นๆ", + "@pairWhoopRowLine": { + "description": "Line under each WHOOP on the first-run list." + }, + "pairSetUpTitle": "ตั้งค่า", + "@pairSetUpTitle": { + "description": "Top bar title of the first-run pairing screen." + }, "pairSearchDevices": "ค้นหาอุปกรณ์", "pairPrimaryCannotBeSensor": "นี่คือสายรัดหลักของคุณอยู่แล้ว จึงไม่สามารถจับคู่เป็นเซ็นเซอร์ออกกำลังกายด้วยได้", "pairReplaceMyBand": "เปลี่ยนสายรัดของฉัน", diff --git a/lib/l10n/app_zh.arb b/lib/l10n/app_zh.arb index 0b589bf08..6ce778859 100644 --- a/lib/l10n/app_zh.arb +++ b/lib/l10n/app_zh.arb @@ -3034,12 +3034,43 @@ "pairModeTitle": "让它进入配对模式", "pairModeNoSite": "这是没有单一厂商的通用设备,因此没有厂商步骤可循。", "pairOuraExistingKeyGuidance": "已经在用 Oura 应用?请保留戒指在该应用中的配对,并使用戒指现有的密钥配对。跳过下面的重置步骤。只有想使用新密钥时才重置戒指。", + "pairAddDevice": "添加设备", + "pairKindAll": "全部", + "pairKindStrap": "胸带和臂带", + "pairKindRing": "戒指", + "pairKindWatch": "手表", + "pairGoBack": "返回", + "pairAddDeviceSub": "戒指、手表和心率带", + "pairAddDeviceSubtitle": "每个设备都会标明适合的用法:每天,或仅运动时。", + "pairBandFoundBody": "每天佩戴比仅在运动时使用能提供多得多的数据。你想怎么用?", + "pairBandFoundBodyHasBand": "你已经有一个手环。同一时间只能有一个作为你的手环。", + "pairIdentifiedBody": "它看起来像心率带,但连接后它表明自己是 {label}。没有保存任何内容。", + "pairAsMyBand": "配对为我的手环", + "pairSecondaryPaired": "已配对,仅在运动时使用。", + "pairBandNow": "当前手环:{name}。更换后你的数据仍会保留。", + "pairReplaceBand": "先配对此手环,再断开 {name}", + "pairReplaceConfirmTitle": "此手环连接成功后替换 {name}?", + "pairReplaceConfirmBody": "如果设置失败或取消,当前手环仍保持配对。已保存在这部手机上的数据会保留。旧手环上尚未同步的数据,在更换后不会再同步到这部手机。", + "pairReplaceConfirmYes": "配对新手环", + "pairCurrentBandFallback": "你的手环", + "pairWearableLead": "它可以为你的每一天补上睡眠、恢复和心率。", + "pairWearableNote": "填补没有 WHOOP 数据的日子。这是实验功能,请在“设备”中开启。", + "pairStrapLead": "它在你运动时提供心率,不记录睡眠、恢复或每日负荷。", + "pairStrapNote": "开启“在锻炼时使用”,即可在锻炼时记录心率。", + "pairDeviceNamed": "配对 {name}", + "pairUseForWorkouts": "仅在运动时使用", + "pairReplaceUnpairFailed": "新手环已配对,但无法移除旧手环。", + "pairWearableLeadPebble": "Pebble 2 可以为你的每一天补上睡眠和心率。Pebble 2 SE 显示手表自身记录的睡眠和步数。它没有心率传感器,因此本应用无法根据它的数据计算每日身体负荷或估算恢复。", + "pairMainBandWhoopOnly": "主手环:仅支持 WHOOP 4.0 或 WHOOP 5.0/MG。其他设备可作为附加设备添加。", + "pairBandTitle": "配对你的手环", + "pairBandSubtitle": "选择你佩戴的那一个,我们会在附近寻找它。", + "pairStrapOnlyLink": "我只有心率带", + "pairWhoopRowLine": "睡眠、恢复、负荷、心率等", + "pairSetUpTitle": "设置", "whoopFirmwareWarningTitle": "WHOOP 用户:请勿重新连接 WHOOP 应用", "whoopFirmwareWarningAction": "如果你在使用 OpenStrap 或其他开源应用,或打算以后改用,请不要再把手环连接到 WHOOP 官方应用。它可能会自动安装固件更新。请卸载或停用 WHOOP 应用,以免它更新你的手环。", "whoopFirmwareWarningDetails": "有报告称,WHOOP 5.0 / MG 固件 50.43.1.0 和 50.43.2.0 会阻止访问数据。蓝牙可能仍能连接。解锁受影响的手环需要由 WHOOP 签名的会员令牌,OpenStrap 无法签发。我们正在寻找解决办法,但目前还没有可用的修复。", - "bandStatusFirmwareLockedTitle": "手环固件可能正在扣留它的数据", - "bandStatusFirmwareLockedReason": "这个手环运行的是 WHOOP 固件 50.43:它可以连接并响应应用,但在手环上没有 WHOOP 签名的会员令牌之前,可能不会发送任何记录或实时心率。这可能是收不到数据的原因之一。OpenStrap 无法签发这个令牌。已保存在这里的所有数据都是安全的。", - "bandStatusFirmwareLockedFix": "如果是固件的原因,应用无法更改,手环重新发送记录后此提示会自动消失", + "pairSearchDevices": "搜索设备", "alarmNextLabel": "下一次", "alarmScheduleGroup": "每周计划", "alarmWakeTimeRowTitle": "起床时间", @@ -3389,37 +3420,12 @@ "stepCalSaveFailed": "无法保存此次校准。", "stepCalDoneGait": "已保存。你数了 {count} 步,腕带记录了 {band} 步。今后这类走路将按 {pct}% 进行校正。", "stepCalDoneHousehold": "已保存。在腕带记录的 {band} 步中,你的手机记录了 {count} 步。居家活动现在将按 {gain} 进行缩放。", + "pairPrimaryCannotBeSensor": "这已经是你的主手环,不能同时配对为运动传感器。", + "pairReplaceMyBand": "更换我的手环", + "dayStepsWhoop4NoCounter": "WHOOP 4.0 没有自带计步器,因此只有在本应用接收其实时数据时才会计步。", "healthWearNotUpdatedSince": "自 {time} 起未更新", "dayStrainWornAsOf": "佩戴(截至 {time} 的数据)", - "dayStepsWhoop4NoCounter": "WHOOP 4.0 没有自带计步器,因此只有在本应用接收其实时数据时才会计步。", - "pairAddDevice": "添加设备", - "pairKindAll": "全部", - "pairKindStrap": "胸带和臂带", - "pairKindRing": "戒指", - "pairKindWatch": "手表", - "pairGoBack": "返回", - "pairAddDeviceSub": "戒指、手表和心率带", - "pairAddDeviceSubtitle": "每个设备都会标明适合的用法:每天,或仅运动时。", - "pairBandFoundBody": "每天佩戴比仅在运动时使用能提供多得多的数据。你想怎么用?", - "pairBandFoundBodyHasBand": "你已经有一个手环。同一时间只能有一个作为你的手环。", - "pairIdentifiedBody": "它看起来像心率带,但连接后它表明自己是 {label}。没有保存任何内容。", - "pairAsMyBand": "配对为我的手环", - "pairSecondaryPaired": "已配对,仅在运动时使用。", - "pairBandNow": "当前手环:{name}。更换后你的数据仍会保留。", - "pairReplaceBand": "先配对此手环,再断开 {name}", - "pairReplaceConfirmTitle": "此手环连接成功后替换 {name}?", - "pairReplaceConfirmBody": "如果设置失败或取消,当前手环仍保持配对。已保存在这部手机上的数据会保留。旧手环上尚未同步的数据,在更换后不会再同步到这部手机。", - "pairReplaceConfirmYes": "配对新手环", - "pairCurrentBandFallback": "你的手环", - "pairWearableLead": "它可以为你的每一天补上睡眠、恢复和心率。", - "pairWearableNote": "填补没有 WHOOP 数据的日子。这是实验功能,请在“设备”中开启。", - "pairStrapLead": "它在你运动时提供心率,不记录睡眠、恢复或每日负荷。", - "pairStrapNote": "两项都需要开启“在锻炼时使用”。", - "pairDeviceNamed": "配对 {name}", - "pairUseForWorkouts": "仅在运动时使用", - "pairReplaceUnpairFailed": "新手环已配对,但无法移除旧手环。", - "pairWearableLeadPebble": "Pebble 2 可以为你的每一天补上睡眠、恢复和心率。Pebble 2 SE 显示手表自身记录的睡眠和步数。它没有心率传感器,因此本应用无法根据它的数据计算每日身体负荷或估算恢复。", - "pairSearchDevices": "搜索设备", - "pairPrimaryCannotBeSensor": "这已经是你的主手环,不能同时配对为运动传感器。", - "pairReplaceMyBand": "更换我的手环" + "bandStatusFirmwareLockedTitle": "手环固件可能正在扣留它的数据", + "bandStatusFirmwareLockedReason": "这个手环运行的是 WHOOP 固件 50.43:它可以连接并响应应用,但在手环上没有 WHOOP 签名的会员令牌之前,可能不会发送任何记录或实时心率。这可能是收不到数据的原因之一。OpenStrap 无法签发这个令牌。已保存在这里的所有数据都是安全的。", + "bandStatusFirmwareLockedFix": "如果是固件的原因,应用无法更改,手环重新发送记录后此提示会自动消失" } diff --git a/lib/state/alarm_schedule.dart b/lib/state/alarm_schedule.dart index ca8c6050a..8711497c6 100644 --- a/lib/state/alarm_schedule.dart +++ b/lib/state/alarm_schedule.dart @@ -33,6 +33,37 @@ Future bindAlarmEpochToBand(SharedPreferences prefs, String remoteId) asyn return prefs.setString(kAlarmRemoteId, remoteId); } +/// Persist the armed [epoch] under its owner, in an order that never leaves a +/// window where the epoch reads as another band's arm: a previous owner's +/// epoch is removed first, then the owner is written, then the new epoch. +/// Every write is checked; on a failure this throws and no new epoch is saved. +/// Both the foreground and the headless writer use it. +/// +/// [stillCurrent] answers "has a newer arm or a clear superseded this one?". +/// It is asked before anything is written and again, synchronously, right +/// before the epoch write: the removes/writes above await, and a clear or a +/// newer arm that ran in those gaps must not have its result overwritten by +/// this older epoch. Returns false when superseded (nothing more is written). +Future saveArmedAlarmEpoch( + SharedPreferences prefs, int epoch, String? remoteId, + {bool Function()? stillCurrent}) async { + if (stillCurrent != null && !stillCurrent()) return false; + if (remoteId != null && prefs.getString(kAlarmRemoteId) != remoteId) { + if (prefs.getInt('alarm_epoch') != null && + !await prefs.remove('alarm_epoch')) { + throw StateError('Could not clear the previous alarm.'); + } + if (!await prefs.setString(kAlarmRemoteId, remoteId)) { + throw StateError('Could not record which band holds the alarm.'); + } + } + if (stillCurrent != null && !stillCurrent()) return false; + if (!await prefs.setInt('alarm_epoch', epoch)) { + throw StateError('Could not save the armed alarm.'); + } + return true; +} + /// One weekday's slot in the schedule. Immutable — callers build a new one to /// change a field. class AlarmScheduleEntry { diff --git a/lib/state/app_state.dart b/lib/state/app_state.dart index f7664e09a..d97c580c7 100644 --- a/lib/state/app_state.dart +++ b/lib/state/app_state.dart @@ -4201,8 +4201,13 @@ class AppState extends ChangeNotifier { static const String _kLiveSessionCheckpoint = 'live_session_checkpoint'; Future _checkpointLiveSession() async { - final resetGeneration = ResetGate.generation; if (_gaitRuns.isEmpty) return; + // The runs were collected under THEIR generation, not the one current now: + // a reset that began or finished since must not have its deleted steps + // written back (and recovered after the next connect). Refused up front + // and again after the reads below. + final resetGeneration = _gaitRunsGeneration ?? ResetGate.generation; + if (ResetGate.changedSince(resetGeneration)) return; try { final prefs = await SharedPreferences.getInstance(); final calibration = await _liveStepCalibrationRuns(); @@ -4904,6 +4909,17 @@ class AppState extends ChangeNotifier { var committed = false; var started = false; try { + // The primary peripheral must never also hold a secondary connection. A + // candidate that is already a workout sensor here would be saved as the + // primary with its secondary row and link still alive, and the sensor + // link would reconnect the same peripheral. Refuse before anything starts. + if (replacing && + (await LocalDb.deviceRows()).any((r) => + r['remote_id'] == remoteId && + r['id'] != LocalDb.kPrimaryDeviceId)) { + throw Exception( + 'That device is already paired as a sensor. Forget it there first.'); + } final confirmed = await _sync.connectForPairing( PairedDevice(remoteId, serial), replacingRemoteId: replacing ? existing?.remoteId : null, @@ -5318,6 +5334,10 @@ class AppState extends ChangeNotifier { } notifyListeners(); } + // The band that receives this SET. unpair()/replacement can finish while + // the write waits for its reply; the result then belongs to a band that + // is no longer the paired one (see [_onArmed]). + final armedFor = paired?.remoteId; final result = await armNextScheduledOccurrence( engine: engine, schedule: _schedule, @@ -5335,7 +5355,7 @@ class AppState extends ChangeNotifier { final epoch = result.epoch; if (epoch == null) return true; await _onArmed(DateTime.fromMillisecondsSinceEpoch(epoch * 1000), epoch, - echoed: result.echoed); + echoed: result.echoed, armedFor: armedFor); return true; } catch (e) { _log('[alarm] weekly-schedule arm failed: $e'); @@ -5463,6 +5483,7 @@ class AppState extends ChangeNotifier { // rich 20-byte firing form (a hardcoded 0 subsec would still fire, but the // engine owns the exact on-wire layout). Persist the wall instant the // engine reports armed (null = write never reached the band). + final armedFor = paired?.remoteId; final (:armed, :echoed) = await engine.armAlarm(when); if (armed == null) { // Do NOT persist or start the confirmation machine, or we'd strand a @@ -5476,7 +5497,7 @@ class AppState extends ChangeNotifier { throw Exception('Alarm not set'); } await _onArmed(armed, armed.millisecondsSinceEpoch ~/ 1000, - echoed: echoed); + echoed: echoed, armedFor: armedFor); } /// Shared bookkeeping for anything that just armed the band: optimistic @@ -5487,7 +5508,19 @@ class AppState extends ChangeNotifier { /// /// [echoed]: the strap's reply already reported this exact wake time, so the /// arm is confirmed now; event 56 stays as later corroboration. - Future _onArmed(DateTime when, int epoch, {bool echoed = false}) async { + /// + /// [armedFor] is the band that received the SET, captured BEFORE the write. + /// If it is no longer the paired band (a forget or replacement finished while + /// the reply was pending), this arm is dropped: persisting it would save an + /// ownerless epoch that any later band reads as its own and is then never + /// armed. + Future _onArmed(DateTime when, int epoch, + {bool echoed = false, required String? armedFor}) async { + if (armedFor != paired?.remoteId) { + _log('[alarm] the band that took this alarm is no longer paired; ' + 'not recording it.'); + return; + } final gen = ++_armGen; _savedAlarm = epoch; device.alarmEpoch = epoch; // optimistic display @@ -5499,8 +5532,11 @@ class AppState extends ChangeNotifier { final prefs = await SharedPreferences.getInstance(); // A newer arm (or a clear) during the await owns what is persisted now. if (_disposed || _armGen != gen) return; - if (!await prefs.setInt('alarm_epoch', epoch)) { - throw StateError('Could not save the armed alarm.'); + // Asked again right before the epoch write: the helper awaits, and a clear + // or newer arm in those gaps must not be overwritten by this older epoch. + if (!await saveArmedAlarmEpoch(prefs, epoch, armedFor, + stillCurrent: () => !_disposed && _armGen == gen)) { + return; } if (_disposed || _armGen != gen) return; await prefs.setInt('alarm_set_at_ms', setAtMs); @@ -5508,13 +5544,6 @@ class AppState extends ChangeNotifier { // Not confirmed yet — event 56 (below, in _handleAlarmEvent) flips this. await prefs.setBool('alarm_epoch_confirmed', echoed); if (_disposed || _armGen != gen) return; - final remoteId = paired?.remoteId; - // After a replacement the key can still name the OLD band: an unchecked - // failed write would report success with the new epoch under the old owner. - if (remoteId != null && !await prefs.setString(kAlarmRemoteId, remoteId)) { - throw StateError('Could not record which band holds the alarm.'); - } - if (_disposed || _armGen != gen) return; if (echoed) { await _finishEchoConfirmed(prefs, gen); return; diff --git a/lib/sync/background_sync.dart b/lib/sync/background_sync.dart index 230768eb6..560949fdf 100644 --- a/lib/sync/background_sync.dart +++ b/lib/sync/background_sync.dart @@ -97,12 +97,9 @@ Future headlessArmAndConfirm(Future Function() arm, // The strap's own reply already named this wake time: no wait needed. final confirmed = result.echoed || await awaitAlarmLatch(() => latchedSince(armedAtMs)); - if (!await prefs.setInt('alarm_epoch', result.epoch!)) { - throw StateError('Could not save the armed alarm.'); - } + await saveArmedAlarmEpoch(prefs, result.epoch!, remoteId); await prefs.setInt('alarm_set_at_ms', armedAtMs); await prefs.setBool('alarm_epoch_confirmed', confirmed); - if (remoteId != null) await prefs.setString(kAlarmRemoteId, remoteId); } } diff --git a/lib/ui2/pairing/device_picker.dart b/lib/ui2/pairing/device_picker.dart index 03c928d00..20e4ecfe5 100644 --- a/lib/ui2/pairing/device_picker.dart +++ b/lib/ui2/pairing/device_picker.dart @@ -54,6 +54,7 @@ import '../../state/app_state.dart'; import '../onboarding/pairing.dart' show PairingScreen; import '../ui2.dart'; import 'add_device_flow.dart'; +import 'pair_band_view.dart'; import 'category_filter_pills.dart'; import 'pair_dispatch.dart'; import 'pair_text.dart' @@ -68,6 +69,21 @@ import '../profile/devices.dart' import '../profile/pair_sensor.dart' show PairSensorScreen; import '../profile/profile.dart' show SetRow; +/// Refreshes the sensor list once a pairing has been SAVED. The pairing is +/// already durable here, so a failing refresh must not surface as "could not +/// pair" (the caller's catch would say exactly that). The list reloads on its +/// next load. Returns whether the refresh worked. +@visibleForTesting +Future refreshAfterPair(Future Function() refresh) async { + try { + await refresh(); + return true; + } catch (e) { + debugPrint('[pair] sensor list refresh failed after a saved pairing: $e'); + return false; + } +} + class DevicePickerScreen extends StatefulWidget { /// Walk past pairing entirely. Non-null only at true first-run onboarding /// — a re-pair or add-a-sensor push always has a screen underneath to pop @@ -100,7 +116,7 @@ class DevicePickerScreen extends StatefulWidget { } class _DevicePickerScreenState extends State - implements AddDeviceIo { + implements AddDeviceIo, PairBandHost { final _query = TextEditingController(); String _q = ''; @@ -284,8 +300,10 @@ class _DevicePickerScreenState extends State } } + @override void pickBand(BandEntry entry) => unawaited(_browseEntry(entry, modelKnown: true)); + @override void strapOnlyConfirmed() => unawaited(_browseEntry(kBleHrs, confirmed: true)); /// The pairing operation itself, for [AddDeviceFlow]. @@ -401,7 +419,7 @@ class _DevicePickerScreenState extends State Future _afterPair() async { // Neither sub-flow tells AppState a `device` row changed underneath it. - if (mounted) await context.read().refreshSensors(); + if (mounted) await refreshAfterPair(context.read().refreshSensors); // A framed pair changes `AppState.isPaired`, which nothing here watches // directly — the pushed `PairingScreen` closes itself on success, and the // gate (or `RePair`) reacts to the flag underneath. @@ -416,7 +434,13 @@ class _DevicePickerScreenState extends State @override Widget build(BuildContext c) { final l = AppLocalizations.of(c); - final entries = [if (widget.includeBand) kWhoopGen4, ..._notifyEntries]; + if (widget.includeBand) { + return PairBandView( + entries: firstRunBandEntries(), host: this, onSkip: widget.onSkip, + onBack: widget.onBack, problem: _problem, + ); + } + final entries = _notifyEntries; return DevicePickerView( query: _query, title: l?.pairAddDevice ?? 'Add a device', diff --git a/lib/ui2/pairing/pair_band_view.dart b/lib/ui2/pairing/pair_band_view.dart new file mode 100644 index 000000000..9ec0e40b2 --- /dev/null +++ b/lib/ui2/pairing/pair_band_view.dart @@ -0,0 +1,191 @@ +// First-run "Pair your band": the devices that can be the user's main band, +// each marked "Every day", the always-open "Trouble connecting?" card, and +// the ways out (a heart-rate strap only, skip). +import 'package:flutter/material.dart'; +import 'package:lucide_icons_flutter/lucide_icons.dart'; + +import '../../ble/adapters/_registry.dart'; +import '../../l10n/display_text.dart'; +import '../ui2.dart'; +import 'category_filter_pills.dart'; +import 'pair_help.dart'; +import 'pair_sheets.dart'; +import 'pair_text.dart'; +import 'pair_widgets.dart'; +import 'whoop_firmware_warning.dart'; + +/// The devices the first run offers as the main band, in registry order. +List firstRunBandEntries() => [ + for (final e in kBandRegistry) + if (e.canBeMainDevice) e, +]; + +/// What the first-run list asks of the screen around it. +abstract interface class PairBandHost { + /// A device row was tapped. + void pickBand(BandEntry entry); + + /// The user confirmed pairing a heart-rate strap as a sensor (no band). + void strapOnlyConfirmed(); +} + +class PairBandView extends StatefulWidget { + final List entries; + final PairBandHost host; + + /// Non-null only at true first run: walk past pairing. + final VoidCallback? onSkip; + + /// Where the back chevron goes when there is no route underneath to pop + /// (first-run onboarding); null keeps the default `Navigator.maybePop`. + final VoidCallback? onBack; + + /// The last failure, in a sentence. + final String? problem; + final PairLinkOpener openLink; + + const PairBandView({ + super.key, + required this.entries, + required this.host, + this.onSkip, + this.onBack, + this.problem, + this.openLink = const SystemLinkOpener(), + }); + + @override + State createState() => _PairBandViewState(); +} + +class _PairBandViewState extends State { + final _group = ValueNotifier(null); + + @override + void initState() { + super.initState(); + _group.addListener(() => setState(() {})); + } + + @override + void dispose() { + _group.dispose(); + super.dispose(); + } + + Future _strapOnly() async { + if (await showStrapSheet(context, sensor: kBleHrs)) { + widget.host.strapOnlyConfirmed(); + } + } + + @override + Widget build(BuildContext c) { + final p = P.of(c); + final l = pairL10n(c); + final shown = filterByGroup(widget.entries, _group.value); + return Scaffold( + backgroundColor: p.bg, + body: SafeArea( + child: Column(children: [ + Padding( + padding: const EdgeInsets.symmetric(horizontal: S.x4), + child: NavBar(l.pairSetUpTitle, onBack: widget.onBack), + ), + Expanded( + child: ListView( + padding: const EdgeInsets.fromLTRB(S.x4, S.x2, S.x4, S.x10), + children: [ + const WhoopFirmwareWarning(), + const SizedBox(height: S.x4), + Text(l.pairBandTitle, + key: const ValueKey('pair-band-title'), + style: F.t1.copyWith(color: p.ink)), + const SizedBox(height: S.x2), + Text(l.pairBandSubtitle, style: F.body.copyWith(color: p.ink2)), + const SizedBox(height: S.x2), + Text(l.pairMainBandWhoopOnly, + key: const ValueKey('main-band-whoop-only-note'), + style: F.cap.copyWith(color: p.ink3)), + const SizedBox(height: S.x4), + CategoryFilterPills( + kinds: [for (final e in widget.entries) e.kind], + selection: _group, + ), + if (shown.isNotEmpty) const SizedBox(height: S.x3), + for (var i = 0; i < shown.length; i++) ...[ + if (i > 0) const SizedBox(height: S.x3), + _BandRow( + entry: shown[i], + onTap: () => widget.host.pickBand(shown[i]), + ), + ], + if (widget.problem != null) ...[ + const SizedBox(height: S.x4), + StatusCard(l.pairSensorThatDidNotWork, widget.problem!, + icon: LucideIcons.circleAlert), + ], + const SizedBox(height: S.x4), + TroubleConnectingCard( + entries: widget.entries, openLink: widget.openLink), + TextLinkButton(l.pairStrapOnlyLink, onTap: _strapOnly), + if (widget.onSkip != null) ...[ + BigButton(l.pairingSkipForNow, + color: C.blue, soft: true, onTap: widget.onSkip), + const SizedBox(height: S.x2), + Text(l.pairingSkipNote, + style: F.cap.copyWith(color: p.ink3)), + ], + ], + ), + ), + ]), + ), + ); + } +} + +/// The line under a row says what a WHOOP sends. It is WHOOP copy, so another +/// main-band entry added later gets no line until it has its own. +bool _isWhoop(BandEntry e) => e.id == kWhoopGen4.id || e.id == kWhoopGen5.id; + +class _BandRow extends StatelessWidget { + final BandEntry entry; + final VoidCallback onTap; + const _BandRow({required this.entry, required this.onTap}); + + @override + Widget build(BuildContext c) { + final p = P.of(c); + final l = pairL10n(c); + return Surface( + key: ValueKey('band-row-${entry.id}'), + onTap: onTap, + child: Row(children: [ + Container( + width: 48, + height: 48, + alignment: Alignment.center, + decoration: BoxDecoration(color: p.card2, borderRadius: R.rMd), + child: Icon(deviceKindIcon(entry.kind), size: 22, color: p.ink2), + ), + const SizedBox(width: S.x3), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(uiText(c, entry.label), + style: F.body + .copyWith(color: p.ink, fontWeight: FontWeight.w600)), + if (_isWhoop(entry)) ...[ + const SizedBox(height: 2), + Text(l.pairWhoopRowLine, + style: F.cap.copyWith(color: p.ink2)), + ], + ]), + ), + Icon(LucideIcons.chevronRight, size: 18, color: p.ink3), + ]), + ); + } +} diff --git a/lib/ui2/pairing/pair_choice_sheet.dart b/lib/ui2/pairing/pair_choice_sheet.dart index eeb661a92..b3c869bad 100644 --- a/lib/ui2/pairing/pair_choice_sheet.dart +++ b/lib/ui2/pairing/pair_choice_sheet.dart @@ -109,6 +109,8 @@ Future showPairChoiceSheet(BuildContext c, PairChoiceSheet sheet) { context: c, backgroundColor: p.card, isScrollControlled: true, + // Honours Reduce Motion like every other modal sheet in ui2. + sheetAnimationStyle: sheetMotion(c), // A full-height sheet must not slide under the status bar or a notch. useSafeArea: true, showDragHandle: true, diff --git a/lib/ui2/profile/pair_sensor.dart b/lib/ui2/profile/pair_sensor.dart index df697b343..1f4df6057 100644 --- a/lib/ui2/profile/pair_sensor.dart +++ b/lib/ui2/profile/pair_sensor.dart @@ -405,15 +405,18 @@ class _PairSensorScreenState extends State @override Future pair(BandCandidate cand, BandEntry entry, PairConfirmation? confirmation) async { + // Read before the await: if pairing throws after this screen is gone, the + // catch below must not touch a disposed context. + final l = AppLocalizations.of(context); try { return await pairRegisteredEntry(entry, cand.device, label: cand.label, earlierBand: cand.alsoBand, confirmation: confirmation); } catch (e) { - return PairOutcome.failed(AppLocalizations.of(context) - ?.pairSensorCouldNotPair(e.toString()) ?? - 'Could not pair that device: $e'); + return PairOutcome.failed( + l?.pairSensorCouldNotPair(e.toString()) ?? + 'Could not pair that device: $e'); } } diff --git a/test/alarm_epoch_owner_write_test.dart b/test/alarm_epoch_owner_write_test.dart new file mode 100644 index 000000000..fda0d2586 --- /dev/null +++ b/test/alarm_epoch_owner_write_test.dart @@ -0,0 +1,146 @@ +// The armed alarm epoch is stored with the band that holds it. The owner must +// be written BEFORE the epoch and every write checked: if the owner write +// fails the epoch must not be saved under the previous owner, where it would +// read back as the previous band's arm and as nothing for the band that took it. +import 'package:flutter_test/flutter_test.dart'; +import 'package:openstrap_edge/state/alarm_schedule.dart'; +import 'package:openstrap_edge/ui2/pairing/device_picker.dart' show refreshAfterPair; +import 'package:shared_preferences/shared_preferences.dart'; +// ignore: depend_on_referenced_packages +import 'package:shared_preferences_platform_interface/shared_preferences_platform_interface.dart'; + +import 'support/failing_preferences_store.dart'; + +void main() { + late SharedPreferencesStorePlatform original; + + setUp(() { + original = SharedPreferencesStorePlatform.instance; + }); + tearDown(() => SharedPreferencesStorePlatform.instance = original); + + Future prefsWith(Map values) async { + SharedPreferences.setMockInitialValues(values); + return SharedPreferences.getInstance(); + } + + group('saveArmedAlarmEpoch', () { + test('a new band takes the arm: old epoch cleared, owner then epoch written', + () async { + final prefs = await prefsWith({'alarm_epoch': 100, kAlarmRemoteId: 'A'}); + await saveArmedAlarmEpoch(prefs, 200, 'B'); + expect(prefs.getString(kAlarmRemoteId), 'B'); + expect(persistedAlarmEpoch(prefs, 'B'), 200); + expect(persistedAlarmEpoch(prefs, 'A'), isNull); + }); + + test('the same band just refreshes its epoch', () async { + final prefs = await prefsWith({'alarm_epoch': 100, kAlarmRemoteId: 'A'}); + await saveArmedAlarmEpoch(prefs, 200, 'A'); + expect(persistedAlarmEpoch(prefs, 'A'), 200); + }); + + test('a failed owner write throws and never saves the epoch under the old owner', + () async { + final prefs = await prefsWith({'alarm_epoch': 100, kAlarmRemoteId: 'A'}); + SharedPreferencesStorePlatform.instance = FailingPreferencesStore( + SharedPreferencesStorePlatform.instance, + key: kAlarmRemoteId, + throws: false); + await expectLater(saveArmedAlarmEpoch(prefs, 200, 'B'), throwsStateError); + expect(prefs.getInt('alarm_epoch'), isNull, + reason: 'neither the old nor the new epoch is left behind'); + expect(persistedAlarmEpoch(prefs, 'A'), isNull, + reason: 'the previous band is not handed a different band\'s epoch'); + }); + + test('a failed clear of the previous epoch throws before the owner changes', + () async { + final prefs = await prefsWith({'alarm_epoch': 100, kAlarmRemoteId: 'A'}); + SharedPreferencesStorePlatform.instance = FailingPreferencesStore( + SharedPreferencesStorePlatform.instance, + key: 'alarm_epoch', + throws: false); + await expectLater(saveArmedAlarmEpoch(prefs, 200, 'B'), throwsStateError); + expect(prefs.getString(kAlarmRemoteId), 'A', + reason: 'the owner is only changed after the old epoch is gone'); + }); + + test('a clear that lands during the owner change stops the older epoch', () async { + final prefs = await prefsWith({'alarm_epoch': 100, kAlarmRemoteId: 'A'}); + var current = true; + SharedPreferencesStorePlatform.instance = _OnWrite( + SharedPreferencesStorePlatform.instance, + 'flutter.$kAlarmRemoteId', + () => current = false); // a clear/newer arm starts during the write + final saved = await saveArmedAlarmEpoch(prefs, 200, 'B', + stillCurrent: () => current); + expect(saved, isFalse); + expect(prefs.getInt('alarm_epoch'), isNull, + reason: 'the superseded epoch must not be written after the clear'); + }); + + test('superseded before anything is written: nothing is touched', () async { + final prefs = await prefsWith({'alarm_epoch': 100, kAlarmRemoteId: 'A'}); + final saved = await saveArmedAlarmEpoch(prefs, 200, 'B', + stillCurrent: () => false); + expect(saved, isFalse); + expect(prefs.getInt('alarm_epoch'), 100); + expect(prefs.getString(kAlarmRemoteId), 'A'); + }); + + test('with no paired band the epoch is saved untagged, as before', () async { + final prefs = await prefsWith({}); + await saveArmedAlarmEpoch(prefs, 200, null); + expect(prefs.getInt('alarm_epoch'), 200); + expect(prefs.getString(kAlarmRemoteId), isNull); + }); + }); + + group('bindAlarmEpochToBand', () { + test('tags an untagged epoch with the band being left', () async { + final prefs = await prefsWith({'alarm_epoch': 100}); + expect(await bindAlarmEpochToBand(prefs, 'A'), isTrue); + expect(persistedAlarmEpoch(prefs, 'B'), isNull); + expect(persistedAlarmEpoch(prefs, 'A'), 100); + }); + + test('leaves another band\'s tagged epoch alone', () async { + final prefs = await prefsWith({'alarm_epoch': 100, kAlarmRemoteId: 'X'}); + expect(await bindAlarmEpochToBand(prefs, 'A'), isTrue); + expect(prefs.getString(kAlarmRemoteId), 'X'); + }); + }); + + group('refreshAfterPair', () { + test('a failing refresh does not turn a saved pairing into a failure', () async { + expect(await refreshAfterPair(() async => throw StateError('db busy')), + isFalse); + }); + + test('a working refresh reports success', () async { + var ran = false; + expect(await refreshAfterPair(() async => ran = true), isTrue); + expect(ran, isTrue); + }); + }); +} + +// Runs [onWrite] when the matching key is written, then lets the write through. +class _OnWrite extends SharedPreferencesStorePlatform { + _OnWrite(this.delegate, this.key, this.onWrite); + final SharedPreferencesStorePlatform delegate; + final String key; + final void Function() onWrite; + @override + Future> getAll() => delegate.getAll(); + @override + Future clear() => delegate.clear(); + @override + Future remove(String key) => delegate.remove(key); + @override + Future setValue(String type, String key, Object value) { + if (key == this.key) onWrite(); + return delegate.setValue(type, key, value); + } +} diff --git a/test/app_state_pairing_confirmation_test.dart b/test/app_state_pairing_confirmation_test.dart index bd2fa3748..63288d951 100644 --- a/test/app_state_pairing_confirmation_test.dart +++ b/test/app_state_pairing_confirmation_test.dart @@ -450,6 +450,31 @@ void main() { reason: 'the old band must not be reconnected after the save'); })); + // WHY: the primary peripheral must never also be a secondary sensor. A + // candidate that already has a workout-only row would be saved as primary + // with that row (and its link) still alive. + // catches: replacing onto a band that is already a secondary sensor. + test('replacement refuses a candidate that is already a secondary sensor', + syncCase((rig, timers) async { + await PairedDevice.save(kRemoteId, kSerial, generation: 'gen4'); + await rig.openAndSettle(); + await LocalDb.upsertDevice( + id: 'ble_hrs-$replacementId', + adapterId: 'ble_hrs', + remoteId: replacementId, + label: 'Chest strap'); + rig.engine.events.clear(); + await expectLater( + rig.app.replaceWith(BluetoothDevice.fromId(replacementId)), + throwsA(isA())); + expect((await PairedDevice.load())?.remoteId, kRemoteId, + reason: 'the current band stays paired'); + expect(rig.engine.only('connect'), isEmpty, + reason: 'nothing starts before the refusal'); + expect((await LocalDb.deviceRows()).where((r) => r['remote_id'] == replacementId), + hasLength(1), reason: 'the sensor row is untouched'); + })); + // WHY: an upgraded install can hold an armed epoch with no owner tag, which // every band reads as its own. After a forget, a new band would be treated // as already armed and never receive SET_ALARM. @@ -548,6 +573,31 @@ void main() { reason: 'the replacement must not be saved after the reset'); })); + // WHY: setAlarm waits for the band's reply. If the band is forgotten while + // it waits, the arm must not be saved afterwards: with no paired band the + // epoch would be written ownerless, and any later band reads it as its own. + // catches: persisting an arm for a band that is no longer paired. + test('an alarm arm pending while the band is forgotten is not recorded', + syncCase((rig, timers) async { + await PairedDevice.save(kRemoteId, kSerial, generation: 'gen4'); + await rig.openAndSettle(); + final prefs = await SharedPreferences.getInstance(); + await prefs.remove('alarm_epoch'); + await prefs.remove(kAlarmRemoteId); + final gate = Completer(); + rig.engine.armGate = gate; + final arming = rig.app.setAlarm(DateTime.now().add(const Duration(hours: 8))); + await rig.waitFor(() => rig.engine.events.any((e) => e.startsWith('armAlarm'))); + await rig.app.unpair(); + rig.engine.armGate = null; + gate.complete(); + await arming; + expect(prefs.getInt('alarm_epoch'), isNull, + reason: 'an ownerless epoch would be read as armed by the next band'); + expect(persistedAlarmEpoch(prefs, replacementId), isNull); + expect(rig.app.alarmEpoch, isNull); + })); + // WHY: a lost band's retry must finish before candidate bootstrap starts. // catches: rejecting replacement because the old loop is reconnecting, // or clearing its flag without waiting for its in-flight connect. diff --git a/test/backup/settings_audit_guard_test.dart b/test/backup/settings_audit_guard_test.dart index 3c657b085..6e3171a1e 100644 --- a/test/backup/settings_audit_guard_test.dart +++ b/test/backup/settings_audit_guard_test.dart @@ -114,8 +114,6 @@ const _indirectKeys = >{ 'health_import_profile_at', 'health_import_workouts_at'], 'lib/notify/notification_prefs.dart:_kBatteryPct': ['notif_battery_pct'], 'lib/state/app_state.dart:_kHealthSync': ['health_sync'], - 'lib/state/app_state.dart:kAlarmRemoteId': ['alarm_remote_id'], - 'lib/sync/background_sync.dart:kAlarmRemoteId': ['alarm_remote_id'], 'lib/sync/paired_device.dart:_kWornOn': ['paired_worn_on'], 'lib/sync/paired_device.dart:key': [ 'paired_remote_id', 'paired_serial', 'paired_generation'], diff --git a/test/live_step_runs_test.dart b/test/live_step_runs_test.dart index 0e6ef67ce..5d488a146 100644 --- a/test/live_step_runs_test.dart +++ b/test/live_step_runs_test.dart @@ -441,6 +441,46 @@ void main() { expect(await db.query('live_coverage'), isNotEmpty); }); + test('control: without a reset the walk is checkpointed', () async { + SharedPreferences.setMockInitialValues({}); + final app = AppState.forTesting(); + addTearDown(app.dispose); + const recTs = 1787100000; + for (var f = 0; f < 700; f++) { + app.debugFeedLiveAccel(_walkFrame(f, 10), + recTs: recTs, atMs: recTs * 1000 + f * 100); + } + await Future.delayed(const Duration(milliseconds: 50)); + final prefs = await SharedPreferences.getInstance(); + expect(prefs.containsKey('live_session_checkpoint'), isTrue); + }); + + test('a reset after the steps were collected is not checkpointed back', + () async { + SharedPreferences.setMockInitialValues({}); + final app = AppState.forTesting(); + addTearDown(app.dispose); + const recTs = 1787000000; + // One full walking minute: runs are buffered and a first checkpoint lands. + for (var f = 0; f < 700; f++) { + app.debugFeedLiveAccel(_walkFrame(f, 10), + recTs: recTs, atMs: recTs * 1000 + f * 100); + } + await Future.delayed(const Duration(milliseconds: 50)); + final prefs = await SharedPreferences.getInstance(); + await prefs.remove('live_session_checkpoint'); + ResetGate.enter(); + ResetGate.leave(); + // The next minute completes AFTER the reset; the buffered runs predate it. + for (var f = 700; f < 1400; f++) { + app.debugFeedLiveAccel(_walkFrame(f, 10), + recTs: recTs, atMs: recTs * 1000 + f * 100); + } + await Future.delayed(const Duration(milliseconds: 50)); + expect(prefs.containsKey('live_session_checkpoint'), isFalse, + reason: 'runs from before the reset must not be written back'); + }); + test('a reset after the steps were collected keeps them out of storage', () async { final app = await walked(); diff --git a/test/no_gen4_default_test.dart b/test/no_gen4_default_test.dart index d73415a5c..6e66f35f2 100644 --- a/test/no_gen4_default_test.dart +++ b/test/no_gen4_default_test.dart @@ -18,6 +18,8 @@ const _bandProfileGen4Defaults = 6; final _pureComment = RegExp(r'^\s*(///|//|\*|/\*)'); +RegExp _assignmentOf(String symbol) => RegExp('(?])=\\s*${RegExp.escape(symbol)}\\b'); + int _countMatches(RegExp pattern) { var total = 0; for (final f in Directory('lib') @@ -33,10 +35,24 @@ int _countMatches(RegExp pattern) { } void main() { + // WHY: a model comparison added by the pairing screen is not a fallback. + // catches: counting the second '=' in == or the '=' in !=/<=/>=. + test('the default counter distinguishes assignment from comparisons', () { + for (final symbol in ['kWhoopGen4', 'BandProfile.gen4']) { + final assignment = _assignmentOf(symbol); + expect(assignment.hasMatch('BandEntry entry = $symbol;'), isTrue); + for (final operator in ['==', '!=', '<=', '>=']) { + expect(assignment.hasMatch('entry $operator $symbol.id'), isFalse, + reason: '$operator is a comparison, not an assignment'); + } + } + }); + + test('kWhoopGen4 default-fallback count only goes down', () { // `?? kWhoopGen4` sites plus the one field default (`= kWhoopGen4`). final count = _countMatches(RegExp(r'\?\?\s*kWhoopGen4')) + - _countMatches(RegExp(r'=\s*kWhoopGen4\b')); + _countMatches(_assignmentOf('kWhoopGen4')); expect(count, _kWhoopGen4Defaults, reason: 'kWhoopGen4-default count drifted from the tracked value. ' 'If a commit just retired a site, lower _kWhoopGen4Defaults in ' @@ -47,7 +63,7 @@ void main() { // `?? BandProfile.gen4` sites plus the one field/parameter default // (`= BandProfile.gen4`). final count = _countMatches(RegExp(r'\?\?\s*BandProfile\.gen4')) + - _countMatches(RegExp(r'=\s*BandProfile\.gen4\b')); + _countMatches(_assignmentOf('BandProfile.gen4')); expect(count, _bandProfileGen4Defaults, reason: 'BandProfile.gen4-default count drifted from the tracked ' 'value. If a commit just retired a site, lower ' diff --git a/test/pairing_copy_test.dart b/test/pairing_copy_test.dart new file mode 100644 index 000000000..5b40ee094 --- /dev/null +++ b/test/pairing_copy_test.dart @@ -0,0 +1,65 @@ +// Two pieces of pairing copy that made claims the app cannot back: +// - the strap note said "Both need ..." on a sheet that shows no table, so +// "both" had nothing to point at; +// - the Pebble 2 lead promised recovery, but the adapter decodes heart rate, +// steps and sleep only, and readiness needs two inputs it does not provide. +import 'dart:convert'; +import 'dart:io'; + +import 'package:flutter_test/flutter_test.dart'; + +const _locales = ['en', 'de', 'es', 'fr', 'hi', 'ru', 'th', 'zh']; + +// The word for "recovery" in each locale's own copy. +const _recovery = { + 'en': 'recovery', + 'de': 'Erholung', + 'es': 'recuperación', + 'fr': 'récupération', + 'hi': 'रिकवरी', + 'ru': 'восстановлен', + 'th': 'การฟื้นตัว', + 'zh': '恢复', +}; + +// Words that only make sense with a table in view. +const _both = { + 'en': 'Both', + 'de': 'beides', + 'es': 'Ambos', + 'fr': 'Les deux', + 'hi': 'दोनों', + 'ru': 'обоих', + 'th': 'ทั้งสองอย่าง', + 'zh': '两项', +}; + +Map _arb(String l) => + jsonDecode(File('lib/l10n/app_$l.arb').readAsStringSync()) as Map; + +void main() { + for (final l in _locales) { + group(l, () { + test('the strap note stands alone: no "both", and it names the switch', () { + final note = _arb(l)['pairStrapNote'] as String; + expect(note.contains(_both[l]!), isFalse, + reason: '"$note" refers to a table this sheet does not show'); + // It quotes the localized name of the switch it tells the user to turn on. + final switchName = + RegExp('[“«„](.+?)[”»“]').firstMatch(note)?.group(1) ?? + RegExp('« (.+?) »').firstMatch(note)?.group(1); + expect(switchName, isNotNull, reason: 'the note must name the switch: $note'); + expect(note, contains(switchName!)); + }); + + test('the Pebble 2 lead does not promise recovery', () { + final lead = _arb(l)['pairWearableLeadPebble'] as String; + // Only the part before "Pebble 2 SE" describes what Pebble 2 provides. + // What follows says what an SE (no heart-rate sensor) cannot give. + final first = lead.split('Pebble 2 SE').first; + expect(first.contains(_recovery[l]!), isFalse, + reason: 'Pebble 2 supplies at most one readiness input: "$first"'); + }); + }); + } +} diff --git a/test/pairing_stack_review_test.dart b/test/pairing_stack_review_test.dart index 7ac372a71..9c9b3f212 100644 --- a/test/pairing_stack_review_test.dart +++ b/test/pairing_stack_review_test.dart @@ -29,6 +29,7 @@ class _App extends AppState { Completer? supported; Completer? scanned; String? scannedGeneration; + String? scannedRemoteId; Object? pickerError; var replacements = 0; var pickers = 0; @@ -41,6 +42,7 @@ class _App extends AppState { String? generation, }) async { scannedGeneration = generation; + scannedRemoteId = remoteId; return scanned == null ? null : await scanned!.future; } @@ -153,42 +155,29 @@ void main() { expect(find.text('Bluetooth thermometer'), findsOneWidget); }); - // WHY: callbacks may already be queued before the disabled rows rebuild. - // catches: guarding only _flow.running, which category navigation never sets. - testWidgets( - 'category and nearby taps share a lock until navigation returns', - (t) async { - final app = _App(); - addTearDown(app.dispose); - await _screen(t, app, const DevicePickerScreen()); - final view = t.widget(find.byType(DevicePickerView)); - view.onOpenEntry!(kWhoopGen4); - view.onOpenEntry!(kWhoopGen4); - view.onPickNearby!(( - device: BluetoothDevice.fromId('new'), - label: 'WHOOP', - rssi: -50, - entryId: 'gen5', - alsoBand: null, - )); - await t.pumpAndSettle(); - expect(find.byType(PairingScreen, skipOffstage: false), findsOneWidget); - expect(find.byType(BottomSheet), findsNothing); - Navigator.of(t.element(find.byType(PairingScreen))).pop(); - await t.pumpAndSettle(); - final unlocked = t.widget( - find.byType(DevicePickerView), - ); - expect(unlocked.locked, isFalse); - unlocked.onOpenEntry!(kWhoopGen4); - await t.pumpAndSettle(); - expect( - find.byType(PairingScreen), - findsOneWidget, - reason: 'next deliberate tap is accepted', - ); - }, - ); + // WHY: first-run callbacks may already be queued before navigation covers + // the picker. Returning from the route must allow the next deliberate tap. + testWidgets('first-run taps stay locked until navigation returns', (t) async { + final app = _App(); + addTearDown(app.dispose); + await _screen(t, app, const DevicePickerScreen()); + final dynamic host = t.state(find.byType(DevicePickerScreen)); + host.pickBand(kWhoopGen4); + host.pickBand(kWhoopGen4); + host.strapOnlyConfirmed(); + await t.pumpAndSettle(); + expect(find.byType(PairingScreen, skipOffstage: false), findsOneWidget); + expect(find.byType(BottomSheet), findsNothing); + Navigator.of(t.element(find.byType(PairingScreen))).pop(); + await t.pumpAndSettle(); + host.pickBand(kWhoopGen4); + await t.pumpAndSettle(); + expect( + find.byType(PairingScreen), + findsOneWidget, + reason: 'next deliberate tap is accepted', + ); + }); // WHY: the host callbacks used by first-run must obey the same lock as // category and nearby taps, without losing the selected WHOOP model. @@ -211,17 +200,19 @@ void main() { expect(app.scannedGeneration, 'gen5'); }); - // WHY: the single WHOOP category stands for gen4 and gen5 while still - // carrying WHOOP reset help. Only a scanned candidate establishes its model. - // catches: forwarding the category representative gen4 as a scan filter. - testWidgets('WHOOP category keeps help while scanning across generations', ( + // WHY: a name-only candidate establishes the remote id, but not a model. + // The representative entry supplies safe help without filtering out gen5. + testWidgets('name-only WHOOP handoff keeps help and the exact candidate', ( t, ) async { final app = _App(); addTearDown(app.dispose); await _screen(t, app, const DevicePickerScreen()); - t.widget(find.byType(DevicePickerView)).onOpenEntry!( + final io = t.state(find.byType(DevicePickerScreen)) as AddDeviceIo; + final opened = io.openBandFlow( kWhoopGen4, + remoteId: 'picked', + modelKnown: false, ); await t.pumpAndSettle(); expect( @@ -231,6 +222,10 @@ void main() { await t.tap(find.text('Find my band')); await t.pumpAndSettle(); expect(app.scannedGeneration, isNull); + expect(app.scannedRemoteId, 'picked'); + Navigator.of(t.element(find.byType(PairingScreen))).pop(); + await t.pumpAndSettle(); + await opened; }); for (final waitingOnSupport in [false, true]) { @@ -271,7 +266,7 @@ void main() { final app = _App(); addTearDown(app.dispose); final probe = Completer(); - await _screen(t, app, DevicePickerScreen(debugScanHeldBackReason: () => probe.future)); + await _screen(t, app, DevicePickerScreen(includeBand: false, debugScanHeldBackReason: () => probe.future)); final view = t.widget(find.byType(DevicePickerView)); view.onScan!(); view.onOpenEntry!(kWhoopGen4); diff --git a/test/russian_review_findings_test.dart b/test/russian_review_findings_test.dart index 8a8bcf66a..532c57f22 100644 --- a/test/russian_review_findings_test.dart +++ b/test/russian_review_findings_test.dart @@ -335,7 +335,7 @@ void main() { addTearDown(app.dispose); await t.pumpWidget(ChangeNotifierProvider.value( value: app, - child: page(const DevicePickerScreen()), + child: page(const DevicePickerScreen(includeBand: false)), )); await t.pumpAndSettle(); final entry = kBleHrs; diff --git a/test/support/app_state_sync_harness.dart b/test/support/app_state_sync_harness.dart index 234cc435e..ceaca3dd8 100644 --- a/test/support/app_state_sync_harness.dart +++ b/test/support/app_state_sync_harness.dart @@ -170,6 +170,9 @@ class SyncFakeEngine extends BleEngine { /// Holds every runSync until completed. Completer? syncGate; + /// Holds every armAlarm reply until completed. + Completer? armGate; + /// Runs inside runSync before it answers (to move the durable frontier). Future Function()? onRunSync; @@ -278,6 +281,7 @@ class SyncFakeEngine extends BleEngine { Future<({DateTime? armed, bool echoed})> armAlarm(DateTime when, {int index = 0, List? haptics}) async { events.add('armAlarm:${when.millisecondsSinceEpoch ~/ 1000}'); + if (armGate != null) await armGate!.future; return (armed: when, echoed: true); } diff --git a/test/ui2_pair_band_view_test.dart b/test/ui2_pair_band_view_test.dart new file mode 100644 index 000000000..a1b5797b3 --- /dev/null +++ b/test/ui2_pair_band_view_test.dart @@ -0,0 +1,253 @@ +// First-run "Pair your band": the list, the filter pills, the strap-only +// sheet, the always-open Trouble connecting card and the way out. Rendered with fakes. +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:lucide_icons_flutter/lucide_icons.dart'; +import 'package:openstrap_edge/ble/adapters/_registry.dart'; +import 'package:openstrap_edge/ui2/community_links.dart'; +import 'package:openstrap_edge/ui2/pairing/pair_band_view.dart'; +import 'package:openstrap_edge/ui2/pairing/pair_help.dart' show PairLinkOpener; +import 'package:openstrap_edge/ui2/pairing/pair_text.dart' show PairFilter; + +import 'support/pair_ui_support.dart'; + +class _Links implements PairLinkOpener { + final opened = []; + @override + Future open(String url) async { + opened.add(url); + return true; + } +} + +class _Host implements PairBandHost { + final void Function(BandEntry) onPick; + final VoidCallback onStrap; + _Host(this.onPick, this.onStrap); + @override + void pickBand(BandEntry entry) => onPick(entry); + @override + void strapOnlyConfirmed() => onStrap(); +} + +Finder _row(BandEntry e) => find.byKey(ValueKey('band-row-${e.id}')); + +void main() { + group('which devices the first run offers', () { + test('only the WHOOP bands (DT12)', () { + final ids = [for (final e in firstRunBandEntries()) e.id]; + expect(ids, ['gen4', 'gen5']); + // Other bands pair as additional devices from "Add a device"; sensors, + // scales and the thermometer are never a main device. + for (final id in ['oura', 'colmi', 'miband234', 'ultrahuman', 'pebble', 'coros', 'garmin', + 'ble_hrs', 'polar_pmd', 'thermometer', 'miscale_bc', 'miscale2']) { + expect(ids, isNot(contains(id)), reason: id); + } + }); + }); + + group('PairBandView', () { + Widget view({ + List? entries, + ValueChanged? onPick, + VoidCallback? onStrap, + VoidCallback? onSkip, + VoidCallback? onBack, + String? problem, + _Links? links, + }) => + PairBandView( + entries: entries ?? firstRunBandEntries(), + host: _Host(onPick ?? (_) {}, onStrap ?? () {}), + onSkip: onSkip, + onBack: onBack, + problem: problem, + openLink: links ?? _Links(), + ); + + testWidgets('title, subtitle, and one row per device with what it sends', (t) async { + await pumpPair(t, view(), size: const Size(412, 2400)); + expect(find.text('Set up'), findsOneWidget); + expect(find.byKey(const ValueKey('pair-band-title')), findsOneWidget); + expect(find.text('Pair your band'), findsOneWidget); + expect(find.text('Pick the one you wear. We will look for it nearby.'), findsOneWidget); + for (final e in firstRunBandEntries()) { + expect(_row(e), findsOneWidget, reason: e.id); + expect( + find.descendant( + of: _row(e), + matching: find.text('Sleep, recovery, strain, heart rate and more')), + findsOneWidget, + reason: e.id); + } + }); + + + + testWidgets('the WHOOP description is not shown under other devices', (t) async { + await pumpPair(t, view(entries: [kWhoopGen5, kOura, kColmi]), + size: const Size(412, 2400)); + const line = 'Sleep, recovery, strain, heart rate and more'; + expect(find.descendant(of: _row(kWhoopGen5), matching: find.text(line)), + findsOneWidget); + for (final e in [kOura, kColmi]) { + expect(_row(e), findsOneWidget, reason: e.id); + expect(find.descendant(of: _row(e), matching: find.text(line)), + findsNothing, + reason: e.id); + } + }); + + testWidgets('says plainly that only WHOOP is the main band', (t) async { + await pumpPair(t, view(), size: const Size(412, 2400)); + expect(find.byKey(const ValueKey('main-band-whoop-only-note')), findsOneWidget); + expect(find.text('Main band: WHOOP 4.0 or WHOOP 5.0/MG only. Other devices can be added as additional devices.'), findsOneWidget); + }); + + testWidgets('never says what a band would NOT send, nor primary/secondary/tier', (t) async { + await pumpPair(t, view(), size: const Size(412, 2400)); + for (final w in ['Doesn’t send', 'primary', 'Primary', 'secondary', 'Secondary', 'Tier', 'Experimental']) { + expect(find.textContaining(w), findsNothing, reason: w); + } + }); + + testWidgets('pills show only the groups in the list; Rings narrows it', (t) async { + // The view works for any list; the first run itself offers WHOOP only. + final all = [kWhoopGen5, kOura, kColmi, kUltrahuman, kMiBand234, kPebble]; + await pumpPair(t, view(entries: all), size: const Size(412, 2400)); + for (final k in ['All', 'WHOOP', 'Rings', 'Watches']) { + expect(find.text(k), findsOneWidget, reason: k); + } + expect(find.text('Chest straps & armbands'), findsNothing); + expect(find.text('Bands'), findsNothing); + expect(find.text('Scales'), findsNothing); + await t.tap(find.text('Rings')); + await t.pumpAndSettle(); + expect(_row(kOura), findsOneWidget); + expect(_row(kColmi), findsOneWidget); + expect(_row(kUltrahuman), findsOneWidget); + expect(_row(kWhoopGen5), findsNothing); + expect(_row(kMiBand234), findsNothing); + // The Mi Band is a watch, with the other watches. + await t.tap(find.text('Watches')); + await t.pumpAndSettle(); + expect(_row(kMiBand234), findsOneWidget); + expect(_row(kPebble), findsOneWidget); + expect(_row(kOura), findsNothing); + await t.tap(find.text('All')); + await t.pumpAndSettle(); + expect(_row(kWhoopGen5), findsOneWidget); + }); + + test('the pills’ groups are PairFilter values (WHOOP, rings, watches, straps)', () { + expect(PairFilter.values.map((f) => f.name), ['whoop', 'rings', 'watches', 'straps']); + }); + + testWidgets('tapping a row picks that device', (t) async { + final picked = []; + await pumpPair(t, view(onPick: (e) => picked.add(e.id)), size: const Size(412, 2400)); + await t.tap(_row(kWhoopGen5)); + expect(picked, ['gen5']); + }); + + testWidgets('the strap-only link opens the strap sheet', (t) async { + await pumpPair(t, view(), size: const Size(412, 2400)); + await t.tap(find.text('I only have a heart-rate strap')); + await t.pumpAndSettle(); + expect(find.text('This is a heart-rate sensor'), findsOneWidget); + expect(find.text('Pair Bluetooth heart rate sensor'), findsOneWidget); + expect(find.text('Go back'), findsOneWidget); + }); + + testWidgets('Go back closes the sheet and pairs nothing', (t) async { + var confirmed = 0; + await pumpPair(t, view(onStrap: () => confirmed++), size: const Size(412, 2400)); + await t.tap(find.text('I only have a heart-rate strap')); + await t.pumpAndSettle(); + await t.tap(find.text('Go back')); + await t.pumpAndSettle(); + expect(find.text('This is a heart-rate sensor'), findsNothing); + expect(confirmed, 0); + }); + + testWidgets('Pair closes the sheet and carries on (strapOnlyConfirmed)', (t) async { + var confirmed = 0; + await pumpPair(t, view(onStrap: () => confirmed++), size: const Size(412, 2400)); + await t.tap(find.text('I only have a heart-rate strap')); + await t.pumpAndSettle(); + await t.tap(find.text('Pair Bluetooth heart rate sensor')); + await t.pumpAndSettle(); + expect(find.text('This is a heart-rate sensor'), findsNothing); + expect(confirmed, 1); + }); + + testWidgets('there is no “I can’t pair my band” button, and no dialog anywhere', (t) async { + await pumpPair(t, view(), size: const Size(412, 2400)); + expect(find.text('I can’t pair my band'), findsNothing); + await t.tap(_row(kWhoopGen5)); + await t.pumpAndSettle(); + expect(find.byType(Dialog), findsNothing); + expect(find.text('Need a hand pairing?'), findsNothing); + }); + + testWidgets('the Trouble connecting card is always there, with a link per WHOOP and Discord', (t) async { + final links = _Links(); + await pumpPair(t, view(links: links), size: const Size(412, 2400)); + expect(find.byKey(const ValueKey('trouble-connecting')), findsOneWidget); + expect(find.text('Trouble connecting?'), findsOneWidget); + for (final e in firstRunBandEntries()) { + expect(find.byKey(ValueKey('trouble-link-${e.id}')), findsOneWidget, reason: e.id); + } + await t.tap(find.byKey(const ValueKey('trouble-link-discord'))); + expect(links.opened, [kDiscordUrl]); + }); + + testWidgets('the card stays, unchanged, after trying a device; its links open each model’s page', (t) async { + final links = _Links(); + await pumpPair(t, view(links: links), size: const Size(412, 2400)); + await t.tap(_row(kWhoopGen5)); + await t.pumpAndSettle(); + expect(find.byKey(const ValueKey('trouble-connecting')), findsOneWidget); + await t.tap(find.byKey(ValueKey('trouble-link-${kWhoopGen5.id}'))); + expect(links.opened, [kWhoopGen5.resetSteps!.officialUrl]); + expect(find.byType(Dialog), findsNothing); + }); + + testWidgets('Skip for now shows only when there is something to skip', (t) async { + await pumpPair(t, view(), size: const Size(412, 2400)); + expect(find.text('Skip for now'), findsNothing); + var skipped = 0; + await pumpPair(t, view(onSkip: () => skipped++), size: const Size(412, 2400)); + await t.tap(find.text('Skip for now')); + expect(skipped, 1); + }); + + testWidgets('the back chevron goes where the first run says', (t) async { + var back = 0; + await pumpPair(t, view(onBack: () => back++), size: const Size(412, 2400)); + await t.tap(find.byIcon(LucideIcons.chevronLeft)); + expect(back, 1); + }); + + testWidgets('a problem is said in a card', (t) async { + await pumpPair(t, view(problem: 'Bluetooth is off.'), size: const Size(412, 2400)); + expect(find.text('Bluetooth is off.'), findsOneWidget); + // The card is under it, not instead of it. + expect(find.byKey(const ValueKey('trouble-connecting')), findsOneWidget); + }); + + testWidgets('German at 2x text on a small phone does not overflow', (t) async { + await pumpPair(t, view(onSkip: () {}), + locale: const Locale('de'), textScale: 2, size: const Size(320, 700)); + expect(t.takeException(), isNull); + // The retained firmware warning adds substantial height at 2x text. + await t.scrollUntilVisible(find.text('Ich habe nur einen Herzfrequenzgurt'), 200, maxScrolls: 100); + await t.ensureVisible(find.text('Ich habe nur einen Herzfrequenzgurt')); + await t.pumpAndSettle(); + await t.tap(find.text('Ich habe nur einen Herzfrequenzgurt')); + await t.pumpAndSettle(); + expect(find.text('Das ist ein Herzfrequenzsensor'), findsOneWidget); + expect(t.takeException(), isNull); + }); + }); +} diff --git a/test/ui2_tokens_test.dart b/test/ui2_tokens_test.dart index 1a39100ca..d28db94c5 100644 --- a/test/ui2_tokens_test.dart +++ b/test/ui2_tokens_test.dart @@ -276,6 +276,8 @@ const _notComponents = { // asserts the copy is not truncated and nothing overflows. 'StartCard', // Pairing pieces are exercised on routes by the pairing widget tests. + 'PairBandView', + // Pairing pieces are exercised on routes by the pairing widget tests. 'PairNote', 'CategoryFilterPills', 'PairChoiceSheet', // Pairing pieces are exercised on routes by the pairing widget tests. 'TroubleConnectingCard', 'ResetStepsView', 'PairingModeSection', 'PairStepRow', 'TextLinkButton', 'ChoiceRow',