# Mobile et desktop : PWA, projection, Tauri, grand écran

::::summary{title="En bref" audience="Développeurs, et qui doit montrer l'application sur un écran ou l'installer." reading="8 min" updated="12 novembre 2026"}

Les trois façons d'avoir l'application en mobile, la mise en page desktop, les prérequis, les commandes et ce qui a été vérifié.

:::details[Données utilisées]
Aucune ; le jeu de données est déjà dans le code de l'application.
:::

::::

## Trois façons, un seul build

```mermaid
flowchart TD
  accTitle: Un build, trois formes mobiles
  accDescr: Le build Vite produit app/dist avec des chemins relatifs et un routage par fragment. Servi sur le web, il devient une PWA avec manifeste et service worker. L'application du gestionnaire, construite à côté, ouvre la projection : deux téléphones côte à côte. Embarqué par Tauri, il devient une application iOS, Android ou de bureau.
  B["pnpm --filter @flux/app build → app/dist"] --> W["Servi sur le web (Vercel, sous-dossier…)"]
  W --> PWA["PWA : installable, hors ligne"]
  W --> PRO["Application du gestionnaire : projection, deux téléphones à l'écran"]
  B --> T["Tauri 2 : frontendDist ../dist"]
  T --> IOS["iOS"]
  T --> AND["Android"]
  T --> DES["Bureau : macOS, Windows, Linux"]
```

:::howto{caption="Source : app/vite.config.ts, app/src-tauri/tauri.conf.json"}
Tout part du même dossier `app/dist` ; l'application du gestionnaire y a son propre sous-dossier, ni installable ni gardée hors ligne. Les chemins relatifs (`base: "./"`) et le routage par `#/` lui permettent de tourner partout sans réglage.
:::

## Projection mobile

Adresse : `#/projection` de l'application du gestionnaire, donnée aux offices de tourisme (plus dans l'application publique depuis le 11 novembre 2026) · Code : `packages/projection/src/Projection.tsx`, composant `CadreTelephone` de `@flux/ui`.

![Projection « L'appli, dans la poche », sur fond blanc : à gauche « Plutôt là · Isère », l'Éclaireur au chapeau, « Chaque téléphone affiche l'application elle-même, à sa vraie taille : tout se touche et tout fonctionne », les réglages en pastilles (Appareil : iPhone, choisi, ou Android ; Écrans : Les deux, choisi, Visiteur ou Gestionnaire), le bouton « Recharger les écrans », « iPhone · 390 × 844 · affiché à 75 % », puis ce que font le visiteur et le gestionnaire ; au centre, l'espace visiteur sur son accueil dans un cadre d'iPhone ; à droite, l'espace gestionnaire dans un second cadre, sur son tableau de bord (18 lieux suivis, 0 lieu signalé) ; au-dessus de chaque cadre, un lien « Ouvrir seul »](/plutotla/p1-projection.png)

:::howto{caption="Capture du 12 novembre 2026, 1 440 × 900 px"}
Chaque cadre affiche l'application elle-même, dans une `iframe`, aux dimensions d'un vrai téléphone (iPhone : 390 × 844, ici affiché à 75 %). Tout se touche et tout fonctionne. Le tableau de bord indique 0 lieu signalé : les cadres ne lisent que le stockage de ce navigateur, et le signalement de démonstration des autres captures a été fait ailleurs.
:::

- **Réglages** : appareil (iPhone, Android), écrans (les deux, visiteur, gestionnaire), « Recharger les écrans ». Tout est en clair.
- **Échelle** : les cadres se réduisent pour tenir dans la fenêtre, en largeur comme en hauteur (entre 30 % et 100 %, `echelleScene`). Le pourcentage dépend de la taille de la fenêtre et s'affiche sous les réglages.
- **Deux applications** : le téléphone de gauche montre l'application publique, celui de droite l'application du gestionnaire. Elles sont servies par le même domaine.
- **Démonstration** : enregistrer un signalement dans le téléphone de droite change le téléphone de gauche sans recharger. Les deux cadres partagent le même `localStorage` et écoutent l'événement `storage`. Signaler « Plage de Charavines » à droite fait passer « Le Lac de Paladru » en « signalé » à gauche, car le signalement vaut pour tout le lieu.
- Sur un vrai téléphone (640 px de large ou moins), la page propose d'ouvrir directement l'application publique ou celle du gestionnaire, ou d'afficher la projection quand même.
- Dans une `iframe`, `env(safe-area-inset-*)` vaut 0 : le cadre dessine lui-même la barre d'état et la barre d'accueil.

## Desktop : la même application sur grand écran

Décision de l'équipe projet du 10 novembre 2026 : **une seule application**, conçue à 360-430 px de large, qui passe en mise en page desktop à partir de 1 024 px. **Le mobile reste la référence et ne régresse pas.** Il n'y a ni deuxième build ni détection d'appareil : seulement des requêtes média CSS.

| Point de rupture | Jeton | Valeur | Ce qui change |
| --- | --- | --- | --- |
| Tablette | `--ecl-rupture-tablette` | 48em (768 px) | grilles plus larges, sans changer la navigation |
| Desktop | `--ecl-rupture-desktop` | 64em (1 024 px) | navigation en haut, colonne secondaire à gauche, largeur de lecture limitée |
| Grand écran | `--ecl-rupture-large` | 80em (1 280 px) | seule la marge autour du contenu grandit |

:::howto{caption="Source : POINTS_RUPTURE (packages/design-system/src/miseEnPage.ts) et tokens.css"}
Valeurs en px à 100 % de zoom ; un test (`miseEnPage.test.ts`) vérifie que les deux disent la même chose. L'espace gestionnaire garde en plus un palier à 760 px pour ses tuiles et ses filtres.
:::

- **Pourquoi en em, pas en px.** Les requêtes média sont écrites `@media (min-width: 64em)`. Au **zoom de 200 %**, une fenêtre de 1 280 px ne mesure plus que 40em : l'écran **revient au rendu mobile**, une seule colonne, plus lisible pour une personne malvoyante.
- **Une variable CSS ne marche pas dans `@media`** : la valeur est écrite en clair, avec le jeton en commentaire (`/* --ecl-rupture-desktop */`). En JavaScript, `REQUETES_MEDIA.desktop` sert à `matchMedia` ou à `useMediaQuery`.
- **Largeurs** : `--ecl-largeur-lecture` 42 rem (environ 70 caractères par ligne), `--ecl-largeur-colonne` 24 rem (colonne de gauche), `--ecl-largeur-page` 80 rem (page entière).
- **Coquille** (`AppShell` de `@flux/ui`) : sur desktop, la navigation principale (`BarreNavigation`) passe dans la barre du haut ; le contenu prend la largeur de lecture (visiteur) ou la page entière (gestionnaire, `largeur="large"`) ; la colonne `secondaire` (« Lieux autour », « Comparer les lieux ») s'affiche à gauche, dans un `<aside>` nommé. Sous 1 024 px, elle est masquée et rien ne change.
- **Ordre du clavier** : la place des zones change, jamais l'ordre du document.
- **Fenêtres** : la feuille du bas (`FeuilleBas`, par exemple « Affiner ») s'ouvre au centre de l'écran sur desktop.

Les écrans qui en profitent sont décrits dans [Sur grand écran](/plutotla/grand-ecran) (visiteur) et dans le [parcours gestionnaire](/plutotla/parcours-gestionnaire). La fenêtre de l'application Tauri de bureau garde le format téléphone (400 × 860), donc le rendu mobile.

## PWA hors ligne

| Fichier | Rôle |
| --- | --- |
| `app/public/manifest.webmanifest` | nom, icônes (normales et *maskable*), `display: standalone`, portrait, couleur crème `#FEF4E1` des Éclaireurs (icônes produites par `app/scripts/icones/generer.mjs`), raccourcis « Visiter » et gestionnaire |
| `app/public/sw.js` | service worker, cache `plutot-la-v1` |
| `app/public/icons/` | icônes 192 et 512 px, *maskable*, `apple-touch-icon` |
| `app/src/main.tsx` | enregistre `./sw.js` seulement dans un build web ; jamais en développement (il retire même un ancien enregistrement) ni dans Tauri |

:::howto{caption="Source : app/public/, app/src/main.tsx"}
Une ligne par fichier de la PWA (*Progressive Web App*, site installable qui marche hors ligne).
:::

Le service worker :

- met en cache la page, le manifeste, les icônes, et tous les fichiers `assets/` qu'il trouve en lisant `index.html` puis, de proche en proche, les fichiers JS et CSS cités (120 au plus). Le jeu de données est dans le JS : il est hors ligne avec le reste ;
- **page** : réseau d'abord ; au-delà de 4 s ou sans réseau, la version en cache (réseau lent en montagne) ;
- **`assets/`** (noms avec empreinte, immuables) : cache d'abord ;
- **autres fichiers du site** : cache tout de suite, puis mise à jour en arrière-plan ;
- **autres origines** (OpenStreetMap, calculateurs) : pas interceptées ;
- à chaque nouvelle version, il range les nouveaux fichiers et retire les anciens. Pour vider le cache de tous les appareils, augmenter `VERSION` dans `sw.js`.

Installer : ouvrir l'application dans Chrome (Android) ou Safari (iOS, « Sur l'écran d'accueil »). Le service worker demande HTTPS (ou `localhost`).

## Tauri 2 : iOS, Android, bureau

Dossier : `app/src-tauri/` (sur le modèle du Studio du dépôt Récit). Son `README.md` garde seulement les commandes natives et renvoie à cette page.

| Fichier | Rôle |
| --- | --- |
| `tauri.conf.json` | identifiant `fr.isere.plutotla`, `frontendDist ../dist`, `devUrl http://localhost:5174`, fenêtre de bureau au format téléphone (400 × 860), CSP stricte (images autorisées depuis `upload.wikimedia.org`, pour les photos libres des lieux), Android `minSdkVersion 24`, iOS 16 minimum |
| `capabilities/default.json` | une seule permission : ouvrir une URL http(s) dans le navigateur du système (greffon `opener`) |
| `src/lib.rs` | point d'entrée commun et **garde de navigation** : la vue reste sur l'application ; un autre site en http(s) s'ouvre dans le navigateur ; tout autre schéma est refusé. 4 tests (`cargo test`) |
| `Info.ios.plist` | nom affiché, portrait, phrase de demande de position |
| `app-icon.png`, `icons/` | icônes, générées par `app/scripts/icones/generer.mjs` puis `pnpm tauri icon src-tauri/app-icon.png` |
| `gen/` | projets Android et Xcode, créés par `tauri android init` et `tauri ios init` (non versionnés) |

:::howto{caption="Source : app/src-tauri/"}
Une ligne par fichier du dossier `app/src-tauri/`. La CSP (*Content Security Policy*) est la liste de ce que la vue web a le droit de charger.
:::

### Prérequis exacts

- **Rust par rustup** (le Rust de Homebrew n'a pas les cibles mobiles) : `brew install rustup && rustup-init`, et `~/.cargo/bin` avant `/opt/homebrew/bin` dans le `PATH` (ou `brew uninstall rust`).
- **Android** : Android Studio ; dans le SDK Manager : une SDK Platform récente, Platform-Tools, Build-Tools, Command-line Tools et NDK (Side by side). Puis :

  ```bash
  export JAVA_HOME="/Applications/Android Studio.app/Contents/jbr/Contents/Home"
  export ANDROID_HOME="$HOME/Library/Android/sdk"
  export NDK_HOME="$ANDROID_HOME/ndk/$(ls -1 "$ANDROID_HOME/ndk" | tail -1)"
  rustup target add aarch64-linux-android armv7-linux-androideabi i686-linux-android x86_64-linux-android
  ```

- **iOS** : Xcode complet (App Store), puis :

  ```bash
  sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
  sudo xcodebuild -license accept && xcodebuild -runFirstLaunch
  brew install cocoapods
  rustup target add aarch64-apple-ios aarch64-apple-ios-sim x86_64-apple-ios
  ```

  Pour un appareil réel : une équipe de signature (`bundle.iOS.developmentTeam` ou variable `APPLE_DEVELOPMENT_TEAM`).

### Commandes (depuis la racine)

```bash
pnpm tauri dev                      # bureau, sur le serveur Vite (port 5174)
pnpm tauri build                    # bureau : .app et .dmg sur macOS
cd app/src-tauri && cargo test      # tests de la garde de navigation

pnpm tauri android init             # une fois : crée gen/android
pnpm tauri android dev              # émulateur ; appareil réel : ajouter --host
pnpm tauri android build --apk      # ou --aab pour le Play Store

pnpm tauri ios init                 # une fois : crée gen/apple (Xcode complet requis)
pnpm tauri ios dev                  # simulateur
pnpm tauri ios build                # archive pour TestFlight ou l'App Store
```

### Après `tauri android init`

À ajouter à la main dans `gen/android/app/src/main/AndroidManifest.xml` :

- `<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />` et `ACCESS_FINE_LOCATION` (le visiteur peut partir de sa position) ;
- `android:screenOrientation="portrait"` sur l'élément `<activity>`.

## Ce qui a été vérifié, et ce qui ne l'a pas été

| Élément | État | Comment |
| --- | --- | --- |
| Build web avec `sw.js`, manifeste, icônes | ✅ vérifié | `pnpm --filter @flux/app build` |
| Hors-ligne PWA | ✅ vérifié | Chrome sans tête piloté par le protocole DevTools, build servi sous `/app/` : hors ligne, `#/` affiche « Vous voulez visiter quel site ? » (l'application du gestionnaire, elle, s'utilise en ligne depuis le 11 novembre 2026) |
| Mise à jour du service worker | ✅ vérifié | nouveau JS rangé dans le cache, ancien retiré |
| CSP de Tauri | ✅ vérifiée | servie en en-tête sur `#/`, `#/admin`, `#/projection` : aucune violation ; zod tourne sans génération de code (`jitless`) |
| Rust : `cargo check`, `clippy`, `fmt`, `test` | ✅ vérifié | tauri 2.12.5, tauri-plugin-opener 2.7.2 |
| Binaire de bureau macOS | ✅ construit et lancé 6 s sans erreur | `tauri build --debug --no-bundle` ; fenêtre non vue (capture ratée) |
| Projection à 1 440 × 900, 1 024 × 768, et repli à 390 × 844 | ✅ vérifié | captures Chrome sans tête |
| Mise en page desktop à 1 280 px | ✅ vérifié | axe-core sans violation sur les écrans visiteur et gestionnaire ; captures du résultat et de la fiche de Paladru (10 novembre 2026) |
| Retour au rendu mobile au zoom de 200 % | ✅ par construction | requêtes média en em ; pas de capture au zoom réel |
| CSP de Tauri avec les photos de Wikimedia Commons | ❌ non vérifié dans une vue web Tauri | `img-src` comprend `https://upload.wikimedia.org` dans `tauri.conf.json` ; le binaire n'a pas été relancé |
| `tauri android init`, build Android | ❌ non vérifié | pas de rustup ni de SDK Android sur la machine |
| `tauri ios init`, build iOS | ❌ non vérifié | pas de Xcode complet |
| Nom accentué « Plutôt là » dans les projets natifs | ❌ non vérifié | si `init` échoue, mettre un `productName` ASCII dans `tauri.ios.conf.json` ou `tauri.android.conf.json` (le nom affiché iOS vient déjà de `Info.ios.plist`) |
| Essai sur un vrai téléphone | ❌ non fait | outils et appareils absents |

:::howto{caption="✅ vérifié · ❌ reste à faire"}
✅ fait sur la machine de développement (9 novembre 2026 pour Tauri et la PWA, 10 novembre 2026 pour le desktop) ; ❌ reste à faire, avec la raison.
:::

## Limites

:::limits{link="/plutotla/limites-et-suite"}
- Les projets natifs iOS et Android n'existent pas encore (`gen/` absent) : la première compilation mobile reste à faire.
- Le premier chargement reste long sur un réseau de montagne ; ensuite, le cache du service worker prend le relais.
- Les saisies d'une application Tauri restent dans sa vue web : elles ne sont pas partagées avec le navigateur du même téléphone.
- Desktop vérifié à 1 280 px seulement (gestionnaire aussi à 1 024 et 1 440 px) ; ni tablette en paysage, ni contraste forcé regardé à l'œil.
- Les photos des lieux viennent du réseau : hors ligne, le dessin du type de sortie les remplace.
:::
