Module appnotes 

Other apps’ notifications on a phone (docs/android.md, “Notifications from other apps”; research: docs/research/android-chats.md, 7 and 8). Android hands Sioul’s listener every notification the person lets it see; Sioul decides, notification by notification, whether it comes now or waits, and Android holds it (it is snoozed: Android brings it back at its time, whole, with its own tap and actions; Sioul never cancels one).

Two kinds, decided per notification, not per app:

• between people: SMS, chats, mail, a missed call. Who wrote, as far as the app says it (a number, an address, a contact of the phone’s address book, else a name), then what reaches you when (the matrix of attention, its Messages rows; a mail app’s, its Mail rows; a missed call, its Calls rows). A group is judged as the conversation, on its own row, never by a member’s name; “always through” goes by conversation, which the app identifies, never by a name, which anyone can take (research 9.3); the blocked never, whatever a conversation says.
• from an automaton: everything else (shops, news, social networks, a browser’s sites). Gathered: it comes at the next of the times set for that, [reminders] gathered (three a day unless set otherwise, as the sites’ notifications on a computer), never while you sleep, pause or take free time.

When each kind may come is the matrix of what reaches you’s to say (attention: its people’s rows, the rows of automatons and of the apps you set to come at once); the times above are its usual values.

Never held: calls, alarms, what runs (music, a call in progress, a download), the reminders you set, Sioul’s own; codes and sign-ins or payments to approve (codes::detect on the notification’s words, the approval phrases below, and Android 15’s redaction, which says the phone’s own assistant judged it a code).

What is kept, on the phone alone and never shared: the person’s choices (Choices, app-notes.toml in the configuration), and what Sioul held, by a hash of Android’s key, with the apps’ and conversations’ names it saw in the last weeks, so that the person can choose for them (Ledger, app-notes-seen.toml in the state). Never what a notification says.

Structs

AppChoice

Ask

What a decision asks of the moment.

Back

What came back at its time, for the Porch.

Choices

The person’s choices, this phone’s own ($XDG_CONFIG_HOME/sioul/app-notes.toml): never shared, like what the listener sees.

Conversation

A conversation, as the app identifies it.

Decision

Now, or held until then.

Gate

Do-not-disturb’s switch or a focus session, holding now: a layer of the matrix (as usual, only Always through’s messages come, docs/attention.md).

Held

What a held notification waits for, to work its time out again when something changes (a pause ends, the hours or the choices change: review).

Ledger

What Sioul held and saw, on this phone ($XDG_STATE_HOME/sioul/app-notes-seen.toml).

Live

The clock as it stands now (reach::Clock): what a decision asks of it.

Message

One message of a conversation (Notification.MessagingStyle); no sender: the person themselves.

Person

A person as an app names them in its notification (android.app.Person), with what the phone’s address book says of them when Java could ask it.

Posted

A notification as the listener hands it (AppNotes.java): what Android says of it, its words included. Read in memory to decide, never kept.

Rang

SeenApp

An app as Sioul saw it last: its name, when, what came of it, the channels that rang while held.

SeenSite

A browser’s site seen: to choose for it.

SeenTalk

A conversation seen: to choose for it.

SiteChoice

Talk

Between people.

TalkChoice

Enums

AppKind

What an app is, as the person says.

Kind

What a notification is, for whether it may come now.

Sender

Who wrote, as the notification identifies them.

Through

When a conversation comes, as the person says.

Why

Why a notification comes now or waits.

Constants

AGAIN_MAX

…this many times in a row, it is let through rather than held again and again: the times worked out disagree with the time it is. A long hold (a pause, the night) is no such loop and never counts.

AGAIN_SHORT

Held again on its return for less than this (seconds)…

BACK_SAID 🔒

What came back is said on the Porch this long after.

BOOK_APPS 🔒

Apps that name people as the phone’s address book does: their names say who.

FIREFOX_SITES 🔒

Firefox’s browsers post every site’s notification on this one channel, the site in the sub-text.

FOR_GOOD

Held for good (a blocked sender, a conversation set to never): looked at again weekly.

GATE_RECHECK

Do-not-disturb’s switch or a focus session without a known end: asked again this soon.

GRACE

A gathered time still counts this long after it (seconds): what arrives in the very minute of a gathering comes with it.

HORIZON_DAYS

How far ahead a moment is looked for (days).

MAIL_APPS 🔒

Mail apps: their notifications are mail, judged on the Mail row.

OWN

Sioul’s own package: its notifications are never touched.

RECHECK

Held with no moment found in the coming days (a pause, which lasts until you come back): asked again this late (seconds). Sioul brings it back sooner when what moves its time changes (the pause ends: review).

SEEN_KEPT 🔒

Apps and sites seen are forgotten this long after (seconds), unless chosen for.

SMS_APPS 🔒

SMS apps, besides the phone’s default one (Posted::sms_app).

TALKS_MAX 🔒

At most so many conversations kept seen.

TALK_KEPT 🔒

Conversations seen, the same.

UNTOUCHED 🔒

Categories never held: what runs or shows a state, what the person set.

Traits

TimeSource

What time it is at any moment (reach::Clock, through Live): sleep, a pause, free time, the hours, as they stand now.

Functions

address_in 🔒

An e-mail address as an app writes a sender: “alice@example.org”, “Alice alice@example.org”.

again

A held notification’s time worked out again, as things stand now (a pause ended, the hours or the choices changed): its new time, none when it may come now. who, admitted and the rest as kept when it was held.

always 🔒

A conversation let through always: Always through’s row (at once at any time, as usual), read against who writes, or the group’s row.

apps_in_words

“Discord”, “Discord and Le Monde”, “Discord, Le Monde and WhatsApp”, “Discord, Le Monde, WhatsApp and two other apps”: numbers in words, “many other apps” past twelve.

at_once 🔒

At once, at the times the matrix lets these apps come (as usual, as Sioul’s own notifications come): else when it does. Its app’s own row read over it, when set.

by_matrix 🔒

When a notification comes, by what the matrix says of it at each moment (Attention::decide, its app’s and conversation’s own rows read over its usual one): through now, or held until its first time (first_time), the next event tried when one finds none (its area left aside: nothing waits for good). Why: now or later, or as you chose for this time (Why::Times) when a source’s own cell decides it now.

classify

What a notification is (Kind), as its app and Android say it, and as the person chose for its app and site (Choices).

conversation_of 🔒

The conversation a notification belongs to: its shortcut, else its title (a group), else, for a conversation between two, the one who writes; for an SMS app’s plain notification, its title (the address book’s name, or the number).

decide

Whether a notification comes now, or until when it waits. who: the sender as the address books and lists judge them (named for a name), none when nobody knows them; listed: the Always through list holds them. The blocked never, whatever their conversation says (blocked beats Always through, docs/attention.md, Q3).

first_moment

The first moment from now on, within the coming days, when fits holds: now itself, else where something changes (Ask::moments).

first_time

The first moment from now on, within the coming days, when what the matrix says of a notification lets it come (level_at): at once (●) now or where something changes; at the gathered times (◎) at a gathered time.

fnv 🔒

gathered 🔒

Gathered: held until the next gathered time the matrix gathers at (an automaton’s row, as usual three a day but not while you sleep, pause, take Free time or have do-not-disturb on), within the app’s area; through when it is this very one, or when the row says at once now (as the preset More reachable does at work). Its app’s own row read over it.

gatherings 🔒

The gathered times from now on, within the coming days, in order; one that began less than a minute ago among them.

host_of 🔒

https://Mail.Example.org:443/inbox → mail.example.org; "" when it is no host.

is_code

Whether a notification hands over a code or asks for an approval now: a code as mail gives one (codes::detect); words asking for an approval (a sign-in, a payment, an identity to confirm); “is this you?” beside what it is about (a friend’s “is this you on the photo?” is none); a channel named for codes or sign-ins (Proton Mail’s “login” channel). Read folded (case and accents aside), as whole words (words::Approvals).

is_user 🔒

Whether a message’s sender is the person themselves, as the conversation names them (some apps name them rather than leave the sender out).

is_zero 🔒

is_zero_i64 🔒

key_hash

A notification’s key as the ledger keeps it: hashed, Android’s own key naming the app and its tags (a site, a chat’s id).

named

Who wrote, from what the address books and lists say of a name (found: none when no card has it): an app that names people as the phone’s address book does is taken at its word; a name anyone can take may only hold more (restricted and blocked kept), never let through more than someone unknown.

next_gathering

The next gathering from now in which an automaton’s notification may come: one the notification matrix gathers at (as usual, not while you sleep, pause or take free time, nor in a slot of time for you or under do-not-disturb), within its app’s area. One that began less than a minute ago counts. None within the coming days.

number_in

A phone number as written in a notification: digits, at least seven (a short code has six at most), with spaces, dots, dashes, brackets and a leading “+” allowed (“+262 6 39 98 01 01”).

one_line 🔒

A name on one line: an app’s words never break Sioul’s.

percent_decoded 🔒

“%2B262639980101” → “+262639980101”: what a URI keeps encoded.

person 🔒

Someone’s message: now when the matrix lets them through (attention::Attention::decide: their row on its channel, a group’s own row, Always through’s, the time, its layers), the notification’s area fitting now for all but your safe people and Always through (as mail to an address for another time, docs/areas.md); else at their next time.

porch_line

The Porch’s line on other apps (docs/porch.md): what waits and until when, what came back lately. Names and words, never a count past twelve.

sender_of 🔒

What a person is, as the app identifies them: their numbers and addresses (the app’s URI, the phone’s address book), else their name.

short_code 🔒

A short code an SMS comes from (“38015”, “36179”): a business’s, an automaton.

site_of

A browser’s site the notification is from, as its host: Chromium’s browsers name it in the tag (“p#https://site#…”, “n#…”), the channel (“web:https://site;…”) and the group (“Web:site”); Firefox’s in the sub-text, on their one channel for sites (research 8.1).

talk_key

A conversation’s key: the app and its own id for it, hashed.

times_of

The gathered times as times of day, in order; “8:30” reads as 08:30. None that reads: 09:00, 13:00 and 18:00.

unknown_importance 🔒

when_text 🔒

“13:00”, “tomorrow at 09:00”, “Monday 12 October at 09:00”.

why_text

Why an app’s last notification came or waits, in a sentence (the setup page).

write_whole 🔒

Written whole under another name, then renamed: never half a file.

yes 🔒