Module calls 

Calls screened on a phone, as this device writes and says them (docs/android.md, “Calls”; the rules are sioul_core::calls, the decision Java’s: android/…/Calls.java).

• The table Java decides from (refresh): written again when what it is made of changed (the settings, the lists, the do-not-disturb list, “Let every call through”, the pauses and the times, Health), and at least every ten minutes while something of Sioul’s runs: the window’s minute and each do-not-disturb applied (everywhere::apply), the background service’s step, Android’s daily look for the events’ reminders. Its frames reach four days ahead: Sioul closed that long, the calls ring.
• Let every call through (press), from the window on any device, or from the phone’s notification (Java keeps that press; it is carried into the shared switch here, carry); said in the status line (moment) and the notification (step).
• The log: on a phone, Java’s calls copied into this phone’s own log, which the sharing carries to your other devices (before_exchange); on every device, its own lines taken out after their month.
• The list of calls declined, on the Porch of every device (view): this phone’s own, and every phone’s while [porch] calls says so (the default); with the voicemail Free mails linked to its call and played on demand; Seen on any device, gone from all (act).
• A person’s calls of the month, on their sheet (history).
• Settings ▸ Calls (setup, setup_change).

Constants

REMAKE_EVERY 🔒

The table is made again at least this often while something runs (seconds), nothing changed.

SOUNDS_KEPT 🔒

The voicemails’ sounds kept to play, the newest.

STATE_KEPT 🔒

Java’s answer about the role, kept this long (seconds): the status line asks it each minute.

Statics

BUSY 🔒

COPIED 🔒

Java’s file as last copied in this process: its size and time.

MADE 🔒

What was made last in this process: its inputs, when (seconds), what it said.

STATE 🔒

TRIMMED 🔒

When this device last took its old lines out (ms, its clock): once a day.

Functions

a_day_since 🔒

Whether a day went by since last (ms); when it did, last becomes now, so that the next comes a day after this one.

act 🔒

An action of the list (CallsSection.qml): “seen” {ids}, “unseen” {at} (Seen undone, within its ten seconds), “add-contact” {number} (Android’s form; a computer opens Sioul’s own), “block” {number}, “listen” {path, sound}, “open-blocked”. Answers {said, url, shared, at} (shared: what travels changed, to share now; at: the Seen to undo).

before_exchange 🔒

Before an exchange (the window’s, a quick one: the background step, a dose’s alarm) and before the list is read: on a phone, Java’s new calls copied into its own log, which the sharing carries (calls::carry_into); on every device, once a day, its own lines taken out after their month, and the others’ long after theirs (a phone gone for good never takes its own out), and a phone’s older seen file made a line of its seen log. Cheap when nothing changed: Java’s file is read again only when it changed.

carry 🔒

This phone’s press on its notification (Java’s file) carried into the shared switch once, and whether it screens calls said there, for your other devices: their window offers “Let every call through” then.

changed 🔒

for_card 🔒

The calls declined as the phone’s home card lists them (homecard.rs): the Porch’s lines (view’s) at a moment and a time, each shown as that moment lets its caller through, its day said as seen from that time; without the voicemails, which the card does not say. Read once, for every frame of the card. None where no phone ever shared a call.

forget_state 🔒

The role asked or changed: Android’s answer read again next time.

here_id 🔒

This device’s name in the sharing (share/here.toml), made once.

history 🔒

A person’s calls of the last month (numbers: theirs, as written), for their sheet (reaches::person): a sentence each, newest first, from every phone, rang or declined; none where no phone shares its calls, and never a blocked caller’s (their calls never leave their phone).

inputs 🔒

layers 🔒

What holds on top of the times, ahead: today’s slots of time for you (state/slots.toml), and do-not-disturb from its switch or a focus session, from when, until when (none: until turned off; the table is written again at each change, everywhere::apply).

link_apps 🔒

Whether this device has apps for tel: and sms: links: a phone always; a computer when its system names one (Linux: xdg-mime, KDE Connect, which hands them to your phone, or a softphone). Looked up once.

listed 🔒

The calls a device lists, every phone’s of the month (everywhere: [porch] calls, the default), or this device’s own alone.

listen 🔒

A voicemail’s sound written where the player reads it: its address (“file://…”). Only one found among your mail: never another file.

make 🔒

The table: who each number is (the Always through list’s as rows of their own, never a blocked one), the floors, “Let every call through”, and the frames from today’s midnight, four days on (from midnight, so that a table made a minute later says the same and is not written again), with the matrix’s layers: today’s slots of time for you, do-not-disturb.

moment 🔒

The status line’s part (main.qml, CallsApplet.qml): {shown (a phone of yours screens calls), through, line, until_at}.

named 🔒

This device’s own table in the switch’s file, its kind and name set.

path 🔒

phone 🔒

Whether this device has calls to screen: a phone. SIOUL_CALLS makes a computer write its table and read its list too, to look at them.

phone_names 🔒

Your phones in the sharing, each with its name (a phone’s model), for the list’s words (“your phone (GS290)”); read again five minutes on at most.

press 🔒

Pressed in the window, on any device: every call rings for minutes (0: until turned off), or calls are screened again; on every device once the sharing carries it. The caller writes the phone’s table next (refresh, off the window’s thread).

read_voicemail 🔒

refresh 🔒

The table written again when what it is made of changed, ten minutes went by, or now says so (a press, a number blocked, the role given). On a phone only; never two at once (one asked meanwhile, unforced, is let go: the next look makes it).

screens_here 🔒

Whether this phone screens calls now: Sioul holds the role.

setup 🔒

Settings ▸ Calls (CallsSetup.qml): {android, state, moment}; the table made at once when the role was just given. Who rings when is What reaches you’s (its Calls rows, Always through).

setup_change 🔒

An action of Settings ▸ Calls: “ask-role” (Android’s question), “open-roles” (its default apps, to change or stop), “allow-contacts”, “open-blocked”, “dial” {number} (the phone app with a code typed in, never called). The tab again.

state 🔒

What Android allows this phone (Calls.state): {api, available, held, contacts, table, emergency_at}; null elsewhere. Kept half a minute.

step 🔒

At each step of the background service: the table made again if need be (at once after a press on the notification), and the notification’s words for the calls (StepService): {screening, through, line, hour, off, again}; nothing while this phone does not screen calls.

through_now 🔒

“Let every call through” as this device knows it: the shared switch, and on the phone its notification’s own press, the later of the two.

view 🔒

The Porch’s list of calls declined (CallsSection.qml): {lines, phone (this device is one), links: {tel, sms}}; each line shown at the times its caller’s Calls row lets them through (a row that rings at no time at all, in work and admin time: Attention::listed), on every device: this phone’s own calls, and every phone’s while [porch] calls says so.

voicemails 🔒

The voicemails your operators mailed lately ([words.voicemail]: their domains, none until you name yours), from every account’s inbox: each folder listed again only when it changed (a letter came, or was read), each letter read once (by its file’s name) while the words stay the same; never the sound itself, kept in memory.

who_now 🔒

Who a call’s caller is now, as your lists and address books say (a number only in the phone’s contacts: neutral); none for a hidden number.

words 🔒

The background service’s notification’s words for the calls, the table left as it is (steps::note, after each apply in Sioul’s own process): {screening, through, line, hour, off, again}; nothing while this phone does not screen calls.

words_at 🔒

“15:30”, “tomorrow at 09:31”.

Type Aliases

CardCalls 🔒

What a moment lets through, and the time a list is seen from: the lines then.

Inputs 🔒

What the table is made of, as the files’ times say it, with the day: the same, nothing to make again before ten minutes.