Module appnotes 

Other apps’ notifications on a phone (docs/android.md, “Notifications from other apps”). Android’s listener (AppNotes.java, in a process of its own, “:listener”) asks here, for each notification of another app, whether it comes now or how long it waits (sioul_appnotes_decide), and, when something moved the times (a pause ended, the hours or the choices changed), how long what it holds waits now (sioul_appnotes_review). The rules are sioul_core::appnotes; what reaches you when, sioul_core::attention, with today’s slots of time for you from their file (hours::slots): Time for you holds in this process too.

Also here, for the window: Settings ▸ Other apps (setup, change), and the Porch’s line on what waits and what came back (porch_line). On a computer, nothing of it runs: the listener is the phone’s.

Structs

Counted 🔒

A notification Sioul holds, as the listener’s log line counts it (log_line): the kind of its channel, until when it waits (none, or a time past: it comes now), and why.

Constants

MACHINE 🔒

The why of a text gathered because its number is one ARCEP keeps for machines (appnotes::why_text, “appnotes-why-machine”).

TALKS_FILE 🔒

The conversations let through now from the card (release_talk), by their hashed key, with when (Unix seconds): this phone’s own file, never shared, holding no title; the listener reviews when it changes.

Functions

access_here 🔒

Whether Android lets Sioul hold other apps’ notifications here (notification access): on a phone, as Java says now; None elsewhere, or when Java cannot say (its library not loaded in this process).

area_of 🔒

What a notification’s source is for: the app’s, as you set it; else, for mail, the address it came to, when it is one of your accounts’ (unsaid: work).

at_words 🔒

A time as the log says it: “22:00” today, “tomorrow 07:00”, else “2026-10-20 09:00”.

by_time 🔒

The table of other apps by time (What reaches you ▸ Exceptions): each app seen lately a row of the matrix, by name, and the apps’ rows set that this device has not seen (a computer’s, set on the phone: by the name written with them); then the conversations chosen for (a row or a way through) and the ten seen last (“Title · App”), never a wall of them. Whether some were left out. AttentionGrid.qml draws it.

change 🔒

A choice of the tab, or one of Android’s pages (AppNotesSetup.act): the tab again, as JSON. “set” {key, value}: “hold”, app.<package>.kind, app.<package>.area, conversation.<key>, site.<host>; “open-access”, “open-info”, “open-app” {package}, “open-channel” {package, channel}; “contacts”.

changed 🔒

When a file last changed; none when it is not there.

column_words 🔒

The matrix’s columns as the log says them: their ids (“leisure”, “slot”), Free time’s “Nothing at all” when it holds (“free (nothing at all)”), and do-not-disturb with what holds it (“dnd (focus session)”, “dnd (switch)”).

columns_now 🔒

What reaches you now, as the matrix reads it: the time’s column (or two, work and admin at once), then its layers, a slot of time for you and do-not-disturb (its switch or a focus session).

decide 🔒

One notification decided (AppNotes.decide): {“hold”: milliseconds (0: it comes now), “why”}. What it says is read here and dropped; the ledger keeps its key hashed, its app’s and conversation’s names, and its time. Only for the apps you send to your computers, while that part of the sharing is on, its messages also go, sealed (phonemsgs::note; “shared”: a line was written, Java asks for a step soon).

gate 🔒

Do-not-disturb’s switch or a focus session, holding now: when it ends, when that is known (a layer of the matrix), and which of them holds (for the log).

held_talks 🔒

The conversations the phone holds now, for the card (ReachCard.qml): {key, title, app} each, the soonest first. Their titles come from the phone’s own ledger and go to its window alone: never shared, never on a computer (decision 16; none there, where nothing is held).

hold_line 🔒

The listener’s line at a hold (docs/android.md, “In the phone’s log”): the kind of its channel, until when it waits, or for good, and what decided it (appnotes::cause): its conversation’s or its app’s own row, a gathering and what gathers it, what it is for, the columns of the matrix that hold it now (do-not-disturb with what holds it). “Notes: held: messages 1 until 10:50; why: dnd (focus session).” Held again on its return at its time: “held again”. Never a name, a number, an app nor who wrote.

java 🔒

Java’s answer to verb (AppNotes.call); null elsewhere, or without one.

kind_of 🔒

The kind of channel a held notification came on, as the log says it: calls, messages, mail, or other apps (an automaton’s, an app set to come at once); never its app nor who wrote.

kind_word 🔒

The kind of channel a notification came on, as the log says it (kind_of).

let_talk_then 🔒

“Let them through then” on a held conversation (the card; the proposal’s 3.7): the cell of what holds it now set to at once, on the person’s own row when a card or a number knows them (their card’s first), else on the conversation’s: under do-not-disturb, that layer; during work, Work and Admin together; else the time now. Said in a sentence.

live 🔒

The clock as it stands, kept a minute in the listener’s process: read again sooner when the pause or free time, Health, the hours or the settings change. Asked at every notification.

log_line 🔒

The listener’s line in the phone’s log (adb logcat -s sioul), at each review of what is held and at each release (docs/android.md, “Notifications from other apps”): how many notifications are held, and how many come now, by the kind of their channel; why, the matrix’s column now and its layers (“leisure + dnd (switch)”), or Always through when that let one come; when the next one comes back. Never a name, a number, an app nor a word of a message: kinds, counts and times only. At each hold, a line of its own (hold_line).

machine_number 🔒

Whether a sender’s number comes from a root ARCEP keeps for automated systems (screening::Numbers, the call screening’s data), while the call screening sends automated callers to voicemail (its automated).

porch_line 🔒

The Porch’s line on other apps (appnotes::porch_line); “” when nothing waits nor came back lately, and on a computer (no listener there).

reachable_until 🔒

Reachable’s end, for the listener’s question (Ask::reachable, Unix seconds): while it lasts, everyone not blocked comes at once (part 3).

release_talk 🔒

“Let it through now” on a held conversation (the card): what is held of it comes at the listener’s next review, which this file’s change brings.

released_talks 🔒

review 🔒

What Android holds for Sioul now, worked out again (AppNotes.review): {“snooze”: [{“key”, “ms”}], “line”}, those whose time moved by more than a minute (1 s: it may come now), and the line the listener writes in the phone’s log (log_line). Marks of notifications Android no longer holds (their app took them away, or they came back unseen) are let go.

row 🔒

A row of the tab, as SettingRow.qml shows it: {key, kind, label, help, value, choices}.

set 🔒

One choice written: the app’s kind or area, a conversation’s way through, a site at once. What says “as usual” is taken out.

setup 🔒

Settings ▸ Other apps, as JSON (AppNotesSetup.qml): whether this is a phone, the access and its steps, the switch, the times, what rang while held, then a row for each app, conversation and site seen.

sioul_appnotes_decide^⚠

decide, for Java (android/main.cpp); a panic answers “null”, and the notification comes as it was sent. Given back to sioul_string_free.

sioul_appnotes_review^⚠

review, for Java; “null” when it fails, and what is held keeps its time.

talk_then 🔒

Which row and which cells “Let them through then” sets for a held conversation (let_talk_then): the person’s own row by their card, else by their number, else the conversation’s; under do-not-disturb that layer, in a slot of time for you that one, during work Work and Admin together, else the time now.

talks_path 🔒

times_in_words 🔒

“09:00, 13:00 and 18:00”.

who_of 🔒

Who wrote, as your address books and lists say (porch::Senders): none when nobody knows a name; and whether the Always through list holds them (by a number or an address, never a name, which anyone can take).

with_line 🔒

The Porch’s JSON with its line on other apps (apps_line), when there is one.