nandi/frq · main.cljd

nandi/frqpublic⑂ Fork 0
⑂ 77d4bec54fb40346898290155c8c0845376324e5
main.cljd · 542 lines · 25.5 KBGDScript3    Blame HistoryRaw
Split the tree three ways, and let the phone be Flutter's   1(ns frq.main
Build the APK, out of ClojureDart and Flutter   2  "The Flutter entry point: what `frq.cosmic` is to the jolt half.
Split the tree three ways, and let the phone be Flutter's   3
Two jobs, and the first one is why `frq.io.dart` cannot install itself the
way `frq.io.jolt` does: the app's storage directory arrives from
Build the APK, out of ClojureDart and Flutter   6  path_provider as a Future, so `main` is async, awaits it, and installs the
host before a widget is built. Everything under ../common asks `frq.io` for
the filesystem, so nothing shared can run until that has happened.
`ensureInitialized` first, and not as a formality: path_provider is a
platform channel, and a channel used before the binding exists throws.
Split the tree three ways, and let the phone be Flutter's   12
The screens themselves are not written. `frq.app` is 1,834 lines of hiccup
over glimmer's widget tags, and glimmer is not here — Flutter brings its own
reconciler, so those screens are a rewrite against cljd.flutter rather than a
Build the APK, out of ClojureDart and Flutter   16  port. What this paints is the proof the shared half is alive under a second
compiler: the clock and the saved session, read through exactly the
namespaces the desktop reads them through."
Tell the truth about TLS on the phone, and stop the guest spinner   19  (:require ["dart:async" :as async]
          ["package:flutter/material.dart" :as m]
Split the tree three ways, and let the phone be Flutter's   21            ["package:path_provider/path_provider.dart" :as pp]
          [cljd.flutter :as f]
Paint glimmer's hiccup with Flutter, rather than porting the screens   23            [frq.hiccup :as h]
Paint the phone in COSMIC's own theme, read from cosmic-config   24            [frq.theme :as t]
Split the tree three ways, and let the phone be Flutter's   25            [frq.io.dart :as host]
Sign in with Bluesky on the phone, browser and all   26            ;; The seam, not the implementation above: `open-url!` is asked for
          ;; the same way the shared half asks for it.
          [frq.io :as fio]
Sign on the phone: msgsig shared, crypto seamed   29            [frq.crypto.dart :as crypto-dart]
Reach irc.freeq.at over TLS from the phone   30            [frq.net.dart :as net]
Resolve an identity from the phone, over the shared AT Protocol core   31            [frq.atproto.dart :as atproto]
Split the tree three ways, and let the phone be Flutter's   32            [frq.clock :as clock]
Share the connect screen, and the cells under it   33            [frq.store :as store]
          [frq.actions :as actions]
          [frq.cells :as cells]
Take what is left: fill-height, and the chats screen on the phone   36            [frq.screens.connect :as connect]
          [frq.screens.chats :as chats]
Draw the conversation on the phone   38            [frq.screens.chat :as chat]
Share Discover and Settings, and the frame around them   39            [frq.screens.settings :as settings]
Share the root, and with it the last of the screens   40            [frq.screens.app :as screens]
Take what is left: fill-height, and the chats screen on the phone   41            [frq.rooms :as rooms]
Share who is in the room, and stop Bluesky signing in as somebody else   42            [frq.members :as members]
          [frq.oauth.core :as oauth]
Sign in with Bluesky on the phone, browser and all   44            [frq.oauth.dart :as oauth-dart]
Sign in from the phone with the handshake both halves now share   45            [frq.irc.parse :as irc]
          [frq.irc.handshake :as handshake]))
Split the tree three ways, and let the phone be Flutter's   47
Reach irc.freeq.at over TLS from the phone   48(defonce ^:private lines (atom []))
49(defonce ^:private conn (atom nil))
Paint glimmer's hiccup with Flutter, rather than porting the screens   50
Go somewhere when the connect succeeds   51(defonce ^:private last-line (atom nil))
Ask for the backlog on the phone, as the desktop does   53(def ^:private history-limit
"How many lines of backlog to ask a room for, as `frq.state` asks for them."
Take what is left: fill-height, and the chats screen on the phone   57(defn- room!
"The little of `frq.state/apply-msg!` the conversation list needs: the two
Share who is in the room, and stop Bluesky signing in as somebody else   59  messages that make a room appear and give it a last line, and everything
that says who is in it.
The membership half is `frq.members`, unchanged from what the desktop folds
— the server is the one deciding who is in a room, and it tells both halves
in the same words."
Take what is left: fill-height, and the chats screen on the phone   65
(let [cmd (str (:command m))
      params (vec (:params m))
Share who is in the room, and stop Bluesky signing in as somebody else   68        who (irc/nick-of (:prefix m))
      me? (= who (str @cells/form-nick))
      ensure (fn [m name] (update m name #(merge {:name name :messages [] :unread 0} %)))]
Take what is left: fill-height, and the chats screen on the phone   71
    (= "JOIN" cmd)
    (let [name (first params)]
Share who is in the room, and stop Bluesky signing in as somebody else   74        (swap! cells/channels
             #(-> (ensure % name)
                  (members/add-user name who)
                  (cond-> me? (update name merge {:joined? true
                                                  :accessed (clock/now-ms)}))))
      ;; Only our own JOIN opens the room. Someone else arriving in a
      ;; channel used to move the reader into it.
      (when me? (reset! cells/current name)))
    ;; 353 is the roll, in as many lines as it takes; 366 ends it.
    (= "353" cmd)
    (let [name (nth params 2 nil)]
      (when name
        (swap! cells/channels #(members/with-names (ensure % name) name (last params)))))
    (= "366" cmd)
    (let [name (nth params 1 nil)]
Ask for the backlog on the phone, as the desktop does   91        (when name
        (swap! cells/channels members/names-done name)
        ;; End of NAMES, and the only moment this client knows a room is
        ;; fully arrived. freeq re-joins an authenticated user's channels at
        ;; registration and leaves the backlog for the client to ask for, so
        ;; a room that reaches here with an empty buffer has no history
        ;; coming unless we ask — which is why nothing but new lines ever
        ;; appeared here. Same request `frq.state` makes on 366, and the
        ;; replayed lines come back as ordinary PRIVMSGs the branch below
        ;; already folds.
        (when (and @conn (empty? (get-in @cells/channels [name :messages])))
          (net/send-line! @conn
                          (str "CHATHISTORY LATEST " name " * " history-limit)))))
Share who is in the room, and stop Bluesky signing in as somebody else   104
    (= "PART" cmd)
    (swap! cells/channels members/remove-user (first params) who)
    (= "KICK" cmd)
    (swap! cells/channels members/remove-user (first params) (nth params 1 nil))
    (= "QUIT" cmd)
    (swap! cells/channels members/remove-everywhere who)
    (= "NICK" cmd)
    (do (swap! cells/channels members/rename-user who (last params))
        ;; Our own rename is the server settling what we are called — it
        ;; hands a guest a name of its choosing, so this is the usual way
        ;; the nick on screen becomes the real one.
        (when me? (reset! cells/form-nick (last params))))
    (= "MODE" cmd)
    (swap! cells/channels members/with-mode
           (first params) (nth params 1 "") (drop 2 params))
Take what is left: fill-height, and the chats screen on the phone   124
    (= "PRIVMSG" cmd)
    (let [target (first params)
          text (last params)
          name (if (rooms/dm? target) who target)]
      (swap! cells/channels update name
             #(-> (merge {:name name :messages [] :unread 0} %)
                  (update :messages conj {:from who :text text})))))))
Reach irc.freeq.at over TLS from the phone   133(defn- note! [m]
Go somewhere when the connect succeeds   134  (reset! last-line (str (:command m) " " (last (:params m))))
Share the connect screen, and the cells under it   135  (swap! lines (fn [v] (vec (take-last 8 (conj v m))))))
Tell the truth about TLS on the phone, and stop the guest spinner   137(def ^:private registration-failed
"Numerics that mean registration will never complete.
Only 001 used to clear `connecting?`, so anything the server said instead of
it spun for ever with no message — and the likeliest of them is the dullest:
433, the nick is already in use, which is what a second phone or a session
left open elsewhere gets."
#{"431"    ; no nickname given
  "432"    ; erroneous nickname
  "433"    ; nickname in use
  "436"    ; nick collision
  "464"    ; password incorrect
  "465"    ; banned
  "ERROR"})
152(defonce ^:private attempt (atom 0))
Repaint for every cell, follow the conversation, and send once   154;; Ticked whenever any cell changes, so one `:watch` covers all of them.
156;; What this replaced was a list of cells named by hand in the widget below,
157;; and everything not on it was a control that flipped its cell and repainted
158;; nothing — People, Overview and hide join/part all did.
159(defonce ^:private repaint (atom 0))
161(defn- watch-cells!
"Every cell in `frq.cells` ticking `repaint` when it changes.
Called from `main` rather than run from a top-level `defonce`, and that is
not a style preference: ClojureDart compiles a `def` to a Dart top-level
variable, Dart initialises those on first read, and a `defonce` whose value
nothing ever reads simply never runs. The first attempt at this installed no
watches at all and printed nothing to say so."
(doseq [c (cells/all-cells)]
  (add-watch c ::repaint
             (fn [_ _ old new]
               (when (not= old new) (swap! repaint inc))
               nil))))
Sign in from the phone with the handshake both halves now share   176(defonce ^:private caps
;; What the server has agreed to on this connection. `frq.irc.handshake`
;; holds none of it: it takes the set and hands a new one back, so the
;; desktop can keep it in an atom on the connection and the phone here.
(atom #{}))
Go somewhere when the connect succeeds   182(defonce ^:private closing?
;; Whether the close about to arrive is one we asked for. Without it a tap
;; on Disconnect comes back as "closed by the server", which is both untrue
;; and alarming.
(atom false))
Tell the truth about TLS on the phone, and stop the guest spinner   188(defn- fail! [why]
(reset! cells/connecting? false)
(reset! cells/status "Not connected")
Go somewhere when the connect succeeds   191  (reset! cells/screen :connect)
Tell the truth about TLS on the phone, and stop the guest spinner   192  (reset! cells/error why))
Share who is in the room, and stop Bluesky signing in as somebody else   194(defn ^:async bluesky-session!
"A web-token session from freeq's auth broker.
Only the half that needs no browser. A saved broker token is durable and the
web-token minted from it is single-use, so a return visit is one POST to
/session and `frq.oauth.core` already says what to send and what the answer
means. Getting the *first* broker token is the other half: the browser hands
it back to a loopback listener on the desktop, and a phone has nowhere for
that to land — it wants an Android app link, which is a decision about what
the broker will redirect to and not a porting problem. So that case says so
rather than quietly connecting as somebody else."
(if-let [bt @cells/broker-token]
    (reset! cells/status "Resuming your session…")
    (let [tokens (oauth/refresh-session-parse
                  (await (atproto/fetch
                          (oauth/refresh-session-req oauth/default-broker bt))))]
      (reset! cells/broker-token (:broker-token tokens))
      ;; On every sign-in and not only the first: /session can hand back a
      ;; rotated broker token, and the old one may stop working the moment
      ;; it does.
      (store/save-session! tokens)
      (assoc tokens :kind :web-token)))
Sign in with Bluesky on the phone, browser and all   219    ;; No saved token: the browser leg. `frq.oauth.dart` binds the loopback,
  ;; and what comes back through it is the first broker token.
  (let [tokens (await (oauth-dart/await-callback!
                       oauth/default-broker
                       (str @cells/form-handle)
                       (fn [url]
                         (reset! cells/login-url url)
                         (reset! cells/status
                                 (if (fio/open-url! url)
                                   "Waiting for the browser…"
                                   "Open the sign-in link below to continue"))
    (reset! cells/login-url nil)
    (reset! cells/broker-token (:broker-token tokens))
    (store/save-session! tokens)
    (assoc tokens :kind :web-token))))
Share who is in the room, and stop Bluesky signing in as somebody else   235
236(defn ^:async sign-in!
"Fill `cells/session` for the mode that was chosen, or say why not.
True when the connection may go ahead. A guest carries no session, and must
not carry the last one either: a leftover would have `frq.irc.handshake` ask
for sasl and authenticate as whoever signed in before."
(case @cells/auth-mode
  :guest (do (reset! cells/session nil) true)
245
    (reset! cells/connecting? true)
    (reset! cells/error nil)
    (reset! cells/session
            (await (if (= :bluesky @cells/auth-mode)
                     (bluesky-session!)
                     (do (reset! cells/status "Signing in…")
                         (atproto/create-session @cells/form-handle
                                                 @cells/form-app-password)))))
Sign in with Bluesky on the phone, browser and all   254      ;; An authenticated connection still needs a nick — the DID is the
    ;; identity, the nick is only what the channel calls you. Same order the
    ;; desktop picks it in: what the broker said, else the first label of the
    ;; handle, else whatever is in the box.
    (let [sess @cells/session
          nick (or (:nick sess)
                   (first (.split (str (or (:handle sess) "")) "."))
      (when (seq (str (or (:handle sess) "")))
        (reset! cells/form-handle (:handle sess)))
      (when (seq (str (or nick "")))
        (reset! cells/form-nick nick))
      ;; The password did its work at the PDS; do not keep it.
      (reset! cells/form-app-password ""))
Share who is in the room, and stop Bluesky signing in as somebody else   268
    (catch Object e
      (reset! cells/session nil)
      ;; The message, not the exception: `frq.atproto.core` puts the body it
      ;; could not read in the ex-data, and a PDS that answers a resolve with
      ;; an HTML error page puts the whole page there.
      (fail! (str "Sign-in failed: " (or (ex-message e) e)))
      false))))
Share the connect screen, and the cells under it   277(defn ^:async connect!
"What `frq.actions/connect!` is on the phone.
The desktop's is `frq.state/connect!` — jolt's TLS, SASL, a reader thread.
This is the dart:io one, and it reads the same cells the screen wrote: the
host, the port and the TLS tick are `frq.cells`, filled in by the entry and
the checkbutton on screen.
Reach irc.freeq.at over TLS from the phone   284
Sign in from the phone with the handshake both halves now share   285  Guest and app-password both. The handshake itself is not here: it is
`frq.irc.handshake`, which answers each line with the lines to send back,
and all this does is write them."
Share the connect screen, and the cells under it   288
Tell the truth about TLS on the phone, and stop the guest spinner   289  ;; Close whatever was open first. Connecting twice left the old socket
;; holding the nick, so the second attempt got 433 from its own predecessor.
Go somewhere when the connect succeeds   291  (when-let [c @conn]
  (reset! closing? true)
  (net/close! c)
  (reset! conn nil))
Share who is in the room, and stop Bluesky signing in as somebody else   295  ;; Whatever identity was asked for, settled before the socket opens. Both
;; of the signed-in modes are an HTTPS round trip that has nothing to do
;; with IRC, and a failure in either must stop here: connecting anyway lands
;; us on the server as a guest, which looks like a success and is not the
;; one that was asked for. Bluesky did exactly that until it was asked.
(when (await (sign-in!))
(let [n (swap! attempt inc)]
Sign in from the phone with the handshake both halves now share   302      (reset! caps #{})
    (reset! cells/connecting? true)
    (reset! cells/error nil)
    (reset! cells/status (str "Connecting to " @cells/form-host "…"))
    (reset! lines [])
    ;; A watchdog, because "no answer at all" is a real outcome: a TLS
    ;; handshake that hangs, or a server that accepts the socket and says
    ;; nothing, leaves every callback below unfired.
    (.then (async/Future.delayed (Duration .seconds 20))
           (fn [_]
             (when (and @cells/connecting? (= n @attempt))
               (fail! "No answer from the server after 20s"))))
314
      (let [sock (await (net/connect!
                         {:host @cells/form-host
                          ;; The cell is a string, because it is what an
                          ;; :entry holds.
                          :port (or (parse-long (str @cells/form-port)) 6697)
                          :tls? (boolean @cells/form-tls?)
                          :on-msg (fn [m]
                                    ;; Capability negotiation and SASL, out of
                                    ;; common/ — the same steps the desktop
                                    ;; takes, and all this does is write what
                                    ;; they answer with.
                                    (let [{:keys [send] next-caps :caps}
                                          (handshake/step {:session @cells/session
                                      (reset! caps next-caps)
                                      (doseq [line send]
                                        (when-let [c @conn] (net/send-line! c line))))
                                    (let [cmd (str (:command m))
                                          text (str (last (:params m)))]
                                        (do (reset! cells/connecting? false)
                                            (reset! cells/error nil)
                                            (reset! cells/status
                                                    (str "Connected as " @cells/form-nick))
                                            ;; Off the connect screen, as
                                            ;; frq.state does on 001. Without
                                            ;; this a successful connect just
                                            ;; puts the Connect button back
                                            ;; and looks exactly like a
                                            (reset! cells/screen :chats)
                                            (when-let [c @conn]
                                              (net/send-line! c "JOIN #test")))
                                        (contains? registration-failed cmd)
                                        (fail! (if (= "433" cmd)
                                                 (str "Nick " @cells/form-nick
                                                      " is already in use — try another")
                                                 (str cmd " " text)))
                                        ;; Something is happening; say so
                                        ;; rather than sit on one message.
                                        @cells/connecting?
                                        (reset! cells/status (str "… " cmd)))))
                          :on-close (fn [why]
                                      (reset! conn nil)
                                      ;; Say what the last thing seen was. A
                                      ;; connection that registers and then
                                      ;; drops is a different bug from one
                                      ;; that never registers, and only the
                                      ;; last line apart tells them.
                                      (if @closing?
                                        (reset! closing? false)
                                        (fail! (str (or why "closed by the server")
                                                    " (after " (count @lines)
                                                    " lines, last: " @last-line ")"))))}))]
        (reset! conn sock)
        ;; CAP first, then registration — the order the server expects, and the
        ;; order `frq.irc` uses.
        (net/send-line! sock "CAP LS 302")
        (let [nick (if-let [h (:handle @cells/session)] h @cells/form-nick)]
          (net/send-line! sock (str "NICK " nick))
          (net/send-line! sock (str "USER " nick " 0 * :frq"))))
      ;; Object, not Exception. Dart keeps Error and Exception in separate
      ;; hierarchies, so a TypeError is not an Exception and would leave
      ;; `connecting?` true for ever.
      (catch Object e
        (fail! (str e)))))))
Share the connect screen, and the cells under it   387
388(defn- disconnect! []
Go somewhere when the connect succeeds   389  (reset! closing? true)
Share the connect screen, and the cells under it   390  (when-let [c @conn] (net/close! c))
(reset! conn nil)
(reset! cells/connecting? false)
Go somewhere when the connect succeeds   393  (reset! cells/status "Not connected")
(reset! cells/screen :connect))
Reach irc.freeq.at over TLS from the phone   395
Resolve an identity from the phone, over the shared AT Protocol core   396(defonce ^:private handle (atom "nandi-test.bsky.social"))
397(defonce ^:private identity-out (atom nil))
Share the connect screen, and the cells under it   399(defn ^:async resolve-identity! []
Resolve an identity from the phone, over the shared AT Protocol core   400  (reset! identity-out ["resolving…"])
  (let [h @handle
        did (await (atproto/resolve-handle h))
        pds (await (atproto/pds-endpoint did))]
    (reset! identity-out [(str "did  " did) (str "pds  " pds)]))
  (catch Exception e
    (reset! identity-out [(str "failed: " e)]))))
Go somewhere when the connect succeeds   409(defn- connected-screen
"Where a connect lands, until `frq.app`'s chats screen is portable.
Not much, and honest about it: the status, what the server said, and the way
back. The desktop goes to :chats here — that screen reads rooms, messages,
avatars and the media plane, which is most of what is not ported yet."
[:page {:max-width 520}
 [:title {:label "frq"}]
 [:status {:live true :label @cells/status}]
 [:card {}
  [:title-2 {:label "What the server said"}]
  (if (empty? @lines)
    [:dim-label {:label "nothing yet"}]
    (for [[i m] (map-indexed vector @lines)]
      [:label {:key i
               :label (str (:command m)
                           (when-let [p (seq (:params m))]
                             (str "  " (last p))))}]))]
 [:hbox {:spacing 8}
  [:button {:label "Disconnect" :destructive true :on-click #(disconnect!)}]]
 [:dim-label {:label "The chats screen is next: it wants rooms, messages and avatars, none of which are ported yet."}]])
Open a channel, and give it somewhere to open onto   432(defn- send-draft! []
Draw the conversation on the phone   433  (let [text (str @cells/draft)
Open a channel, and give it somewhere to open onto   434        room (str @cells/current)]
  (when (and (seq text) (seq room) @conn)
    (net/send-line! @conn (str "PRIVMSG " room " :" text))
Repaint for every cell, follow the conversation, and send once   437      ;; Echoed locally only when the server will not echo it back. With
    ;; `echo-message` negotiated it does — that is what the cap is for, and
    ;; it is how a client learns the msgid of its own line — so adding one
    ;; here as well put every sent message in the room twice.
    (when-not (handshake/acked? @caps "echo-message")
      (swap! cells/channels update room
             #(update % :messages conj {:from @cells/form-nick :text text})))
Draw the conversation on the phone   444      (reset! cells/draft ""))))
Open a channel, and give it somewhere to open onto   445
Build the APK, out of ClojureDart and Flutter   446(defn ^:async main []
(m/WidgetsFlutterBinding.ensureInitialized)
Take what is left: fill-height, and the chats screen on the phone   448  ;; Layout errors do not come back as exceptions — they happen after the
;; build, so nothing can catch them, and what they leave is a blank screen
;; and an empty log. Flutter routes them here instead.
(set! (.-onError m/FlutterError)
      (fn [details]
        (m/debugPrint (str "frq: FLUTTER ERROR " (.-exception details)))
        (m/debugPrint (str "frq: LIBRARY " (.-library details)
                           " CONTEXT " (.-context details)))))
Build the APK, out of ClojureDart and Flutter   456  (let [dir (.-path (await (pp/getApplicationSupportDirectory)))]
  (host/install! dir)
Sign on the phone: msgsig shared, crypto seamed   458    ;; Ed25519 for the reactions freeq will not take on trust. Verified
  ;; against RFC 8032 test 1 on the device: the same public key and the
  ;; same signature OpenSSL gives on the desktop, so a signature minted
  ;; here verifies the same way at the server.
  (crypto-dart/install!)
Repaint for every cell, follow the conversation, and send once   463    ;; Before any widget is built: a cell that changes before its watch is on
  ;; is a change the screen never hears about.
  (watch-cells!)
Sign in with Bluesky on the phone, browser and all   466    ;; A sign-in that already happened. Only the durable broker token comes
  ;; back — the connection mints a fresh web-token from it — so this is not
  ;; a session, it is the means to ask for one.
  (when-let [saved (store/load-session)]
    (reset! cells/broker-token (:broker-token saved))
    (when (seq (str (or (:handle saved) "")))
      (reset! cells/form-handle (:handle saved)))
    (when (seq (str (or (:nick saved) "")))
      (reset! cells/form-nick (:nick saved)))
    (reset! cells/auth-mode :bluesky)
    (reset! cells/status (str "Signed in as " (:handle saved) " — Connect to resume")))
Share the connect screen, and the cells under it   477    ;; What the shared screen calls. The desktop installs frq.state's
  ;; reducers here; this installs the phone's.
Take what is left: fill-height, and the chats screen on the phone   479    (actions/install!
   {:connect! connect!
    :disconnect! disconnect!
    :connected? (fn [] (some? @conn))
    :join! (fn [name]
             (when-let [c @conn]
               (when (seq (str name))
                 (net/send-line! c (str "JOIN " name)))))
    :leave-channel! (fn [name]
                      (when-let [c @conn] (net/send-line! c (str "PART " name)))
                      (swap! cells/channels dissoc name))
Draw the conversation on the phone   490      :send-draft! send-draft!
    :wide? (fn [] false)
    :desktop? (fn [] false)
    :mine? (fn [from] (= (str from) (str @cells/form-nick)))
    :message-by-id (fn [room id]
                     (->> (get-in @cells/channels [room :messages])
                          (filter #(= id (:id %)))
Share who is in the room, and stop Bluesky signing in as somebody else   498      :member-count (fn [room] (members/member-count @cells/channels room))
    :member-list (fn [room] (members/member-list @cells/channels room))
Draw the conversation on the phone   500      :toggle-users! (fn [] (swap! cells/show-users? not))
    :toggle-overview! (fn [] (swap! cells/overview? not))
    :toggle-chat-list! (fn [] (swap! cells/hide-chat-list? not))
Share Discover and Settings, and the frame around them   503      :toggle-hide-join-part! (fn [] (swap! cells/hide-join-part? not))
    :quit! (fn [] nil)
    :forget-session! (fn []
                       (reset! cells/broker-token nil)
                       (reset! cells/session nil))
Draw the conversation on the phone   508      :jump-to-present! (fn [] (reset! cells/at-present? true))
Open a channel, and give it somewhere to open onto   509      :open-channel! (fn [name]
                     (reset! cells/current name)
                     ;; `frq.state/open-channel!` does this and more: it
                     ;; marks the buffer read, remembers the room list and
                     ;; asks for NAMES. What it also does, and what made
                     ;; Open look like a no-op here, is go to the
                     ;; conversation — and join it on the way, because a row
                     ;; can outlive the membership behind it.
                     (swap! cells/channels update name
                            #(merge {:name name :messages [] :unread 0} %))
                     (reset! cells/screen :chat)
                     (let [buffer (get @cells/channels name)]
                       (when (and @conn
                                  (.startsWith (str name) "#")
                                  (not (:joined? buffer)))
                         (net/send-line! @conn (str "JOIN " name)))))})
Build the APK, out of ClojureDart and Flutter   525
Paint the phone in COSMIC's own theme, read from cosmic-config   526      (m/MaterialApp .title "frq" .theme (t/app-theme))
Build the APK, out of ClojureDart and Flutter   527      .home
Say "frq" once, and let the guest sign-in finish   528      ;; No AppBar. `connect-screen` opens with [:title {:label "frq"}] — the
    ;; desktop has no bar above it either, the window's title is the
    ;; window's — so a bar here says "frq" twice.
    (m/Scaffold)
Build the APK, out of ClojureDart and Flutter   532      .body
Say "frq" once, and let the guest sign-in finish   533      m/SafeArea
Reach irc.freeq.at over TLS from the phone   534      (f/widget
Repaint for every cell, follow the conversation, and send once   535       ;; One watch, not twenty. `lines` is a local atom and not a cell, so it
     ;; is named beside the tick; everything under `frq.cells` arrives
     ;; through `repaint`.
     :watch [tick repaint ls lines]
Share the root, and with it the last of the screens   539       (h/render
      ;; `frq.screens.app` decides which screen shows, the same way it does
      ;; on the desktop. The phone was switching by hand until this moved.
      [screens/app])))))