diff --git a/mobile/App.js b/mobile/App.js
index cf70493..8202d2c 100644
--- a/mobile/App.js
+++ b/mobile/App.js
@@ -2,7 +2,7 @@
// browser behind it keeps its tabs of WebViews, address bar, and the shared
// suggestion engine from core/.
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { ActivityIndicator, BackHandler, Keyboard, PanResponder, Platform, Pressable, Text, TextInput, View, useWindowDimensions } from "react-native";
+import { AccessibilityInfo, ActivityIndicator, BackHandler, Keyboard, PanResponder, Platform, Pressable, Text, TextInput, View, useWindowDimensions } from "react-native";
import { StatusBar } from "expo-status-bar";
import { SafeAreaProvider, SafeAreaView } from "react-native-safe-area-context";
@@ -17,6 +17,7 @@ import TabsSheet from "./src/components/TabsSheet";
import AddressSuggestions from "./src/components/AddressSuggestions";
import AskSheet from "./src/components/AskSheet";
import TrailHome from "./src/components/TrailHome";
+import FullTextSheet from "./src/components/FullTextSheet";
import { captureRef } from "react-native-view-shot";
import { Directory, File, Paths } from "expo-file-system";
import SettingsSheet from "./src/components/SettingsSheet";
@@ -155,6 +156,12 @@ function Browser({ services }) {
} catch {
return;
}
+ if (msg.type === "capinfo" && String(msg.id).startsWith("ft:")) {
+ // M19: the page's DOI or PMID, found on the phone; nothing is sent.
+ const ids = Capture.findIds(msg);
+ updateTab(tabId, { doi: ids.doi || "", pmid: ids.pmid || "" });
+ return;
+ }
if (msg.type === "capinfo") {
const p = pending.current.get(msg.id);
if (!p) return;
@@ -206,6 +213,7 @@ function Browser({ services }) {
// new load, so onLoadEnd does not run: start the new page's media here.
if (before && !nav.loading && before.url && nav.url !== before.url) {
if (lastSelection.current.tabId === tabId) lastSelection.current = { tabId: null, url: "", text: "" };
+ updateTab(tabId, { doi: "", pmid: "" });
services.history.record(nav.url, nav.title);
const tab = withRule({ ...before, url: nav.url });
refs.current.get(tabId)?.injectJavaScript(autoplayCall(tab.rule.autoplay));
@@ -217,6 +225,7 @@ function Browser({ services }) {
// recorded as a capture card. No screen change; a note with Undo shows.
const showToast = (t) => {
clearTimeout(toastTimer.current);
+ AccessibilityInfo.announceForAccessibility?.(t.text); // VoiceOver reads the note; TalkBack uses the live region
setToast(t);
toastTimer.current = setTimeout(() => setToast(null), 6000);
};
@@ -278,6 +287,7 @@ function Browser({ services }) {
playback.navigated(tabId); // media of the previous page will not resume
view.injectJavaScript(autoplayCall(tab.rule.autoplay));
if (tab.rule.center !== false) view.injectJavaScript(CENTER_ON_TAP);
+ view.injectJavaScript(Capture.captureInfoCall(`ft:${tabId}`)); // DOI for the Full text button
if (tabId !== activeRef.current) {
if (!soundAllRef.current) view.injectJavaScript(MUTE_ALL); // only the active tab plays sound
return;
@@ -397,8 +407,8 @@ function Browser({ services }) {
{/* Address bar, with suggestions from history and Wikipedia while typing */}
-
{editing ? (
{showMosaic && !isActive ? (
// Tap an inactive tile to make it the active tab; then it takes touches.
- switchTo(t.id)} />
+ switchTo(t.id)}
+ accessibilityRole="button"
+ accessibilityLabel={`Mosaic tile ${tile + 1}: ${t.title || t.url || "new tab"}`}
+ accessibilityHint="Makes this the active tab"
+ />
) : null}
);
@@ -494,10 +510,10 @@ function Browser({ services }) {
{/* Bottom bar */}
{list.length > 1 ? (
{list.slice(0, MAX_DOTS).map((t) => (
- show(t.id)} hitSlop={6}>
+ show(t.id)} hitSlop={6} accessibilityRole="button" accessibilityLabel={`Trail: ${t.name}`} accessibilityState={{ selected: t.id === id }}>
))}
@@ -170,7 +184,7 @@ export default function TrailHome({ services, controller, onBrowse, onOpenUrl, o
{tabs.map(([k, label]) => (
- setTab(k)} style={{ flex: 1, paddingVertical: 7, alignItems: "center", backgroundColor: tab === k ? colors.bg3 : "transparent" }}>
+ setTab(k)} accessibilityRole="tab" accessibilityState={{ selected: tab === k }} accessibilityLabel={label} style={{ flex: 1, paddingVertical: 7, alignItems: "center", backgroundColor: tab === k ? colors.bg3 : "transparent" }}>
{label}
))}
diff --git a/mobile/src/components/TrailTimeline.js b/mobile/src/components/TrailTimeline.js
index 8aa7231..440dace 100644
--- a/mobile/src/components/TrailTimeline.js
+++ b/mobile/src/components/TrailTimeline.js
@@ -21,11 +21,14 @@ export default function TrailTimeline({ snap, header, onItem }) {
}
renderItem={({ item }) => {
- if (item.head) return {item.head};
+ if (item.head) return {item.head};
const face = item.card ? M.cardFace(item.card) : null;
return (
onItem(item)}
+ accessibilityRole="button"
+ accessibilityLabel={[item.time, face ? `${face.kicker}: ${face.title}` : item.title, face?.text || item.sub].filter(Boolean).join(". ")}
+ accessibilityHint={item.card ? "Opens the card's preview" : "Opens the page"}
style={({ pressed }) => ({ flexDirection: "row", gap: 10, paddingVertical: 10, borderTopWidth: 1, borderColor: colors.line, opacity: pressed ? 0.6 : 1 })}
>
{item.time}
diff --git a/mobile/src/fulltext.js b/mobile/src/fulltext.js
new file mode 100644
index 0000000..53e7644
--- /dev/null
+++ b/mobile/src/fulltext.js
@@ -0,0 +1,106 @@
+// M19 full-text chip: find a free, legal copy of a paper from its DOI.
+// Unpaywall first (needs the person's email), then OpenAlex (needs their
+// free API key), and always a link through the person's library (LibKey) and
+// doi.org. Lookups happen only when the person taps Full text, and send only
+// the DOI with their email or key. No React Native imports (tested in Node).
+
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
+
+// What can run with these settings: { unpaywall, openalex, reason }.
+function sources(ft = {}) {
+ const unpaywall = Boolean(ft.enabled && EMAIL_RE.test(String(ft.email || "").trim()));
+ const openalex = Boolean(ft.enabled && String(ft.openalexKey || "").trim());
+ let reason = "";
+ if (!ft.enabled) reason = "off";
+ else if (!unpaywall && !openalex) reason = ft.email ? "bad-email" : "no-email";
+ return { unpaywall, openalex, reason };
+}
+
+const enc = (doi) => encodeURIComponent(doi).replace(/%2F/gi, "/");
+
+function unpaywallUrl(doi, email) {
+ return `https://api.unpaywall.org/v2/${enc(doi)}?email=${encodeURIComponent(String(email).trim())}`;
+}
+function openalexUrl(doi, key) {
+ return `https://api.openalex.org/works/doi:${enc(doi)}?select=id,doi,title,open_access,best_oa_location,locations&api_key=${encodeURIComponent(String(key).trim())}`;
+}
+
+const VERSION = { publishedVersion: "published version", acceptedVersion: "accepted manuscript", submittedVersion: "preprint" };
+const licenceText = (l) => (l ? String(l).toUpperCase().replace(/^CC-/, "CC ").replace(/-/g, " ") : "");
+
+// One copy: { url, pdf, where, version, licence, from }.
+function copyFrom(loc, from) {
+ if (!loc) return null;
+ const pdf = loc.url_for_pdf || loc.pdf_url || "";
+ const page = loc.url_for_landing_page || loc.landing_page_url || loc.url || "";
+ const url = pdf || page;
+ if (!/^https?:\/\//i.test(url)) return null;
+ const where = loc.repository_institution || loc.source?.display_name || (loc.host_type === "publisher" ? "Publisher" : loc.host_type === "repository" ? "Repository" : "") || hostOf(url);
+ return { url, pdf: Boolean(pdf), where, version: VERSION[loc.version] || "", licence: licenceText(loc.license), from };
+}
+
+function hostOf(url) {
+ const m = /^[a-z]+:\/\/([^/?#:]+)/i.exec(String(url || ""));
+ return m ? m[1].replace(/^www\./, "") : "";
+}
+
+function parseUnpaywall(text) {
+ const j = JSON.parse(text);
+ const all = [j.best_oa_location, ...(j.oa_locations || [])].map((l) => copyFrom(l, "Unpaywall")).filter(Boolean);
+ return { isOa: Boolean(j.is_oa), status: j.oa_status || "", title: j.title || "", copies: all };
+}
+
+function parseOpenAlex(text) {
+ const j = JSON.parse(text);
+ const all = [j.best_oa_location, ...(j.locations || []).filter((l) => l.is_oa)].map((l) => copyFrom(l, "OpenAlex")).filter(Boolean);
+ if (!all.length && j.open_access?.oa_url) all.push({ url: j.open_access.oa_url, pdf: /\.pdf($|\?)/i.test(j.open_access.oa_url), where: hostOf(j.open_access.oa_url), version: "", licence: "", from: "OpenAlex" });
+ return { isOa: Boolean(j.open_access?.is_oa), status: j.open_access?.oa_status || "", title: j.title || "", copies: all };
+}
+
+// Looks the DOI up. getText is core/net's (cached, rate limited, identified).
+// Returns { copies, status, title, notes, links }.
+async function lookUp(doi, ft, getText) {
+ const can = sources(ft);
+ const notes = [];
+ const found = [];
+ let status = "";
+ let title = "";
+ const run = async (name, url, parse) => {
+ try {
+ // The cache key leaves out the email and key.
+ const r = await getText(url, { cacheKey: `${name}:${doi}`, timeout: 10000 });
+ if (r.status === 404) return notes.push(`${name} doesn't know this DOI.`);
+ if (r.status === 401 || r.status === 403 || r.status === 409) return notes.push(name === "OpenAlex" ? "OpenAlex refused the API key. Check it in Settings." : `${name} refused the request. Check your email in Settings.`);
+ if (r.status === 422) return notes.push(`${name} wants a real email address. Check it in Settings.`);
+ if (r.status === 429) return notes.push(`${name} is busy (too many requests today). Try later.`);
+ if (!r.ok) return notes.push(`${name} didn't answer (${r.status}).`);
+ const out = parse(r.text);
+ found.push(...out.copies);
+ status = status || out.status;
+ title = title || out.title;
+ } catch (err) {
+ notes.push(`${name} couldn't be reached.`);
+ }
+ };
+ if (can.unpaywall) await run("Unpaywall", unpaywallUrl(doi, ft.email), parseUnpaywall);
+ if (can.openalex) await run("OpenAlex", openalexUrl(doi, ft.openalexKey), parseOpenAlex);
+ // One row per address, PDFs and published versions first.
+ const seen = new Set();
+ const rank = (c) => (c.pdf ? 0 : 1) + (c.version === "published version" ? 0 : c.version === "accepted manuscript" ? 1 : 2);
+ const copies = found.filter((c) => !seen.has(c.url) && seen.add(c.url)).sort((a, b) => rank(a) - rank(b));
+ return { copies, status, title, notes, links: links(doi) };
+}
+
+// Always shown, no lookup needed.
+function links(doi) {
+ return { doi: `https://doi.org/${enc(doi)}`, library: `https://libkey.io/${enc(doi)}` };
+}
+
+// "Free to read: published version, PDF · CC BY · Unpaywall"
+function copyLine(c) {
+ return [[c.version, c.pdf ? "PDF" : "web page"].filter(Boolean).join(", "), c.licence, c.where, c.from].filter(Boolean).join(" · ");
+}
+
+const STATUS_TEXT = { gold: "Open access from the publisher", hybrid: "Open access from the publisher (hybrid journal)", bronze: "Free to read at the publisher, no open licence", green: "Free copy in a repository", diamond: "Open access, no fees", closed: "No free copy found" };
+
+module.exports = { sources, unpaywallUrl, openalexUrl, parseUnpaywall, parseOpenAlex, lookUp, links, copyLine, STATUS_TEXT, EMAIL_RE };
diff --git a/mobile/src/services.js b/mobile/src/services.js
index 6492d34..e7e510c 100644
--- a/mobile/src/services.js
+++ b/mobile/src/services.js
@@ -8,7 +8,7 @@ const { TrailStore, migrateSessions, sessionStorageOver } = require("../../core/
const appConfig = require("../app.json");
const PREFIX = "scout:";
-const SECRET_KEYS = { brave: "scout.brave.key", grok: "scout.grok.key" };
+const SECRET_KEYS = { brave: "scout.brave.key", grok: "scout.grok.key", unpaywallEmail: "node.unpaywall.email", openalex: "node.openalex.key" };
// Load every saved file into memory first, so core stores can read
// synchronously; each write is persisted to AsyncStorage in the background.
@@ -72,6 +72,10 @@ export async function createServices() {
} catch (_) {}
settings.providers.brave.key = (await SecureStore.getItemAsync(SECRET_KEYS.brave)) || "";
settings.ai.grok.key = (await SecureStore.getItemAsync(SECRET_KEYS.grok)) || "";
+ // M19 full text: off until the person turns it on; email and key in the keychain.
+ settings.fulltext = { enabled: false, tutorialSeen: false, ...(safeParse(storage.read("settings.json")).fulltext || {}) };
+ settings.fulltext.email = (await SecureStore.getItemAsync(SECRET_KEYS.unpaywallEmail)) || "";
+ settings.fulltext.openalexKey = (await SecureStore.getItemAsync(SECRET_KEYS.openalex)) || "";
// Identify NODE to the sites it calls in the background (Wikipedia limits
// unidentified apps to 10 requests a minute). Same contact URL as desktop.
@@ -96,9 +100,14 @@ export async function createServices() {
}
await SecureStore.setItemAsync(SECRET_KEYS.brave, settings.providers.brave.key || "");
await SecureStore.setItemAsync(SECRET_KEYS.grok, settings.ai.grok.key || "");
+ if (next.fulltext) settings.fulltext = { ...settings.fulltext, ...next.fulltext };
+ await SecureStore.setItemAsync(SECRET_KEYS.unpaywallEmail, String(settings.fulltext.email || "").trim());
+ await SecureStore.setItemAsync(SECRET_KEYS.openalex, String(settings.fulltext.openalexKey || "").trim());
const disk = JSON.parse(JSON.stringify(settings));
delete disk.providers.brave.key;
delete disk.ai.grok.key;
+ delete disk.fulltext.email;
+ delete disk.fulltext.openalexKey;
storage.write("settings.json", JSON.stringify(disk));
}
@@ -118,3 +127,11 @@ export async function createServices() {
ruleFor: (url) => core.resolve(rules, url),
};
}
+
+function safeParse(text) {
+ try {
+ return JSON.parse(text || "{}");
+ } catch (_) {
+ return {};
+ }
+}
diff --git a/mobile/test/fulltext.test.js b/mobile/test/fulltext.test.js
new file mode 100644
index 0000000..ae5e34b
--- /dev/null
+++ b/mobile/test/fulltext.test.js
@@ -0,0 +1,104 @@
+// M19 full-text chip: the lookup, with a fake network. Run: npm test (in mobile/).
+const assert = require("assert");
+const F = require("../src/fulltext");
+
+let passed = 0;
+const test = async (name, fn) => {
+ await fn();
+ passed++;
+ console.log(`ok ${passed} - ${name}`);
+};
+
+const UNPAYWALL = JSON.stringify({
+ doi: "10.1038/nature12373",
+ title: "Nanometre-scale thermometry in a living cell",
+ is_oa: true,
+ oa_status: "green",
+ best_oa_location: { url: "https://europepmc.org/articles/pmc4221854", url_for_landing_page: "https://europepmc.org/articles/pmc4221854", url_for_pdf: null, license: null, version: "acceptedVersion", host_type: "repository" },
+ oa_locations: [
+ { url: "https://europepmc.org/articles/pmc4221854", url_for_landing_page: "https://europepmc.org/articles/pmc4221854", version: "acceptedVersion", host_type: "repository" },
+ { url: "https://dash.harvard.edu/x.pdf", url_for_pdf: "https://dash.harvard.edu/x.pdf", version: "acceptedVersion", license: "cc-by", host_type: "repository", repository_institution: "Harvard University" },
+ ],
+});
+const OPENALEX = JSON.stringify({
+ id: "https://openalex.org/W1",
+ title: "Nanometre-scale thermometry in a living cell",
+ open_access: { is_oa: true, oa_status: "green", oa_url: "https://europepmc.org/articles/pmc4221854" },
+ best_oa_location: { is_oa: true, landing_page_url: "https://europepmc.org/articles/pmc4221854", pdf_url: null, version: "acceptedVersion", license: null, source: { display_name: "Europe PMC" } },
+ locations: [{ is_oa: false, landing_page_url: "https://www.nature.com/articles/nature12373" }],
+});
+
+function fakeNet(answers) {
+ const calls = [];
+ const getText = async (url, opts) => {
+ calls.push({ url, opts });
+ for (const [prefix, r] of answers) if (url.startsWith(prefix)) return typeof r === "function" ? r() : r;
+ return { ok: false, status: 500, text: "" };
+ };
+ return { getText, calls };
+}
+
+(async () => {
+ await test("what can run depends on the settings", () => {
+ assert.deepStrictEqual(F.sources({}), { unpaywall: false, openalex: false, reason: "off" });
+ assert.deepStrictEqual(F.sources({ enabled: true }), { unpaywall: false, openalex: false, reason: "no-email" });
+ assert.strictEqual(F.sources({ enabled: true, email: "nope" }).reason, "bad-email");
+ assert.deepStrictEqual(F.sources({ enabled: true, email: "sven@example.org" }), { unpaywall: true, openalex: false, reason: "" });
+ assert.deepStrictEqual(F.sources({ enabled: true, email: "", openalexKey: "k" }), { unpaywall: false, openalex: true, reason: "" });
+ });
+
+ await test("only the DOI and the email or key are sent; cache keys leave them out", async () => {
+ const { getText, calls } = fakeNet([
+ ["https://api.unpaywall.org/", { ok: true, status: 200, text: UNPAYWALL }],
+ ["https://api.openalex.org/", { ok: true, status: 200, text: OPENALEX }],
+ ]);
+ await F.lookUp("10.1038/nature12373", { enabled: true, email: " sven@example.org ", openalexKey: "KEY1" }, getText);
+ assert.strictEqual(calls[0].url, "https://api.unpaywall.org/v2/10.1038/nature12373?email=sven%40example.org");
+ assert.ok(calls[1].url.startsWith("https://api.openalex.org/works/doi:10.1038/nature12373?select="));
+ assert.ok(calls[1].url.endsWith("&api_key=KEY1"));
+ assert.deepStrictEqual(calls.map((c) => c.opts.cacheKey), ["Unpaywall:10.1038/nature12373", "OpenAlex:10.1038/nature12373"]);
+ });
+
+ await test("copies merged, one per address, PDFs first; links always there", async () => {
+ const { getText } = fakeNet([
+ ["https://api.unpaywall.org/", { ok: true, status: 200, text: UNPAYWALL }],
+ ["https://api.openalex.org/", { ok: true, status: 200, text: OPENALEX }],
+ ]);
+ const r = await F.lookUp("10.1038/nature12373", { enabled: true, email: "a@b.org", openalexKey: "k" }, getText);
+ assert.strictEqual(r.copies.length, 2);
+ assert.strictEqual(r.copies[0].url, "https://dash.harvard.edu/x.pdf");
+ assert.strictEqual(F.copyLine(r.copies[0]), "accepted manuscript, PDF · CC BY · Harvard University · Unpaywall");
+ assert.strictEqual(r.status, "green");
+ assert.strictEqual(r.links.library, "https://libkey.io/10.1038/nature12373");
+ assert.strictEqual(r.links.doi, "https://doi.org/10.1038/nature12373");
+ assert.deepStrictEqual(r.notes, []);
+ });
+
+ await test("errors say what to do", async () => {
+ const { getText } = fakeNet([
+ ["https://api.unpaywall.org/", { ok: false, status: 422, text: "" }],
+ ["https://api.openalex.org/", { ok: false, status: 409, text: "" }],
+ ]);
+ const r = await F.lookUp("10.1/x", { enabled: true, email: "a@b.org", openalexKey: "bad" }, getText);
+ assert.deepStrictEqual(r.copies, []);
+ assert.match(r.notes[0], /real email/);
+ assert.match(r.notes[1], /refused the API key/);
+ const down = fakeNet([["https://api.unpaywall.org/", () => Promise.reject(new Error("offline"))]]);
+ const r2 = await F.lookUp("10.1/x", { enabled: true, email: "a@b.org" }, down.getText);
+ assert.match(r2.notes[0], /couldn't be reached/);
+ const none = fakeNet([["https://api.unpaywall.org/", { ok: false, status: 404, text: "" }]]);
+ assert.match((await F.lookUp("10.1/x", { enabled: true, email: "a@b.org" }, none.getText)).notes[0], /doesn't know/);
+ });
+
+ await test("nothing is looked up when it is off", async () => {
+ const { getText, calls } = fakeNet([]);
+ const r = await F.lookUp("10.1/x", { enabled: false, email: "a@b.org", openalexKey: "k" }, getText);
+ assert.strictEqual(calls.length, 0);
+ assert.ok(r.links.library);
+ });
+
+ console.log(`\n${passed} passed`);
+})().catch((e) => {
+ console.error(e);
+ process.exit(1);
+});