Compare commits

Author SHA1 Message Date
Blendman974 75bceb3b92 fix: support Android 16 KiB pages in native llama library 2026-11-06 04:21:43 +01:00
14 changed files with 142 additions and 378 deletions

No files matched your search

@@ -54,8 +54,7 @@ class FaceclawCalendarProvider private constructor() {
* boundaries the provider stores them as.
*/
@JvmStatic
@JvmOverloads
fun getUpcomingEventsJson(context: Context?, maxEvents: Int, windowMs: Long, selectedCalendarIdsJson: String = "null"): String {
fun getUpcomingEventsJson(context: Context?, maxEvents: Int, windowMs: Long): String {
if (context == null || maxEvents <= 0) {
return "[]"
}
@@ -74,21 +73,11 @@ class FaceclawCalendarProvider private constructor() {
val events = ArrayList<Event>()
var cursor: Cursor? = null
try {
// Filter instances before the cutoff/limit so excluded calendars
// cannot crowd out selected calendars, including recurrences.
val ids = if (selectedCalendarIdsJson == "null") null else JSONArray(selectedCalendarIdsJson)
if (ids != null && ids.length() == 0) return "[]"
val args = ids?.let { values -> Array(values.length()) { index ->
values.getString(index).also { require(it.matches(Regex("[0-9]+"))) }
} }
val selection = args?.let {
CalendarContract.Instances.CALENDAR_ID + " IN (" + it.joinToString(",") { "?" } + ")"
}
cursor = context.contentResolver.query(
uri,
PROJECTION,
selection,
args,
null,
null,
CalendarContract.Instances.BEGIN + " ASC")
if (cursor != null) {
val utc = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
@@ -129,33 +118,6 @@ class FaceclawCalendarProvider private constructor() {
return out.toString()
}
@JvmStatic
fun getCalendarsJson(context: Context?): String {
if (context == null) return "[]"
val out = JSONArray()
try {
context.contentResolver.query(
CalendarContract.Calendars.CONTENT_URI,
arrayOf(CalendarContract.Calendars._ID, CalendarContract.Calendars.CALENDAR_DISPLAY_NAME,
CalendarContract.Calendars.ACCOUNT_NAME, CalendarContract.Calendars.ACCOUNT_TYPE),
null, null, CalendarContract.Calendars.CALENDAR_DISPLAY_NAME + " ASC",
)?.use { cursor ->
while (cursor.moveToNext()) {
out.put(JSONObject().apply {
put("id", cursor.getLong(0).toString())
put("name", cursor.getString(1) ?: "")
put("accountName", cursor.getString(2) ?: "")
put("accountType", cursor.getString(3) ?: "")
})
}
}
} catch (t: Throwable) {
Log.w(TAG, "failed to read calendars", t)
return "[]"
}
return out.toString()
}
private fun readEvent(cursor: Cursor, utc: Calendar, local: Calendar): Event {
val allDay = cursor.getInt(4) != 0
var startMs = cursor.getLong(2)
@@ -29,3 +29,8 @@ add_subdirectory(${LLAMA_CPP_SOURCE_DIR} llama.cpp-build EXCLUDE_FROM_ALL)
add_library(faceclaw_llama SHARED faceclaw_llama.cpp)
target_link_libraries(faceclaw_llama PRIVATE llama android log)
# NDK r27 defaults to 4 KiB. Align both LOAD segments and RELRO boundaries
# for Android devices using 16 KiB pages, including debug APKs.
target_link_options(faceclaw_llama PRIVATE
"-Wl,-z,max-page-size=16384"
"-Wl,-z,common-page-size=16384")
-5
View File
@@ -3,7 +3,6 @@ import { invalidateCalendarCache, onCalendarChanged } from "../../native/calenda
import { makeImageWindowIcon, windowIcon } from "../../ui/shell/chrome-layer";
import { CalendarLayer } from "./calendar";
import { renderCalendarDateIcon } from "./calendar-icon";
import { calendarSelectionMenuItems } from "./calendar-filter";
import {
createInProcessWindow,
YieldAtRootLayer,
@@ -45,10 +44,6 @@ export function createCalendarAppWindow(options: InProcessAppOptions): InProcess
icon: "calendar",
drawIcon: makeImageWindowIcon(renderCalendarDateIcon, windowIcon("calendar", "Ca")),
closeable: true,
menuItems: () => calendarSelectionMenuItems().map(item => ({ ...item, onSelect: (ctx, menu) => {
ctx.stack.pop();
return item.onSelect(ctx, menu);
} })),
actions: options.actions,
baseLayer: new YieldAtRootLayer(new CalendarLayer(requestPermission)),
submitFrame: options.submitFrame,
-94
View File
@@ -1,94 +0,0 @@
import { getDefaultSmallFont } from "../../graphics/ui-fonts";
import { type GrayImage } from "../../graphics/image";
import { truncateText } from "../../graphics/textwrap";
import { readCalendarSelection, setCalendarSelection } from "../../native/calendar-selection";
import { readAvailableCalendars } from "../../native/calendar-sources";
import { hasCalendarPermission } from "../../native/calendar-permissions";
import { type InputEvent } from "../../ui/gestures";
import { type Layer, type LayerContext, type PaintBelow } from "../../ui/layers";
import { drawToggleMenuItem, MenuLayer, type MenuItem } from "../../ui/menu";
/** Shared preference for every Android calendar reader. */
export class CalendarFilterLayer implements Layer {
private menu: MenuLayer | null = null;
private width = 0;
private keys: string[] = [];
private currentMenu(ctx: LayerContext): MenuLayer {
const calendars = readAvailableCalendars().sort((a, b) =>
a.name.localeCompare(b.name) || a.accountName.localeCompare(b.accountName) || a.id.localeCompare(b.id));
const selection = readCalendarSelection();
const known = new Set(calendars.map(calendar => calendar.id));
const keys = ["all", "none"];
const toggle = (id: string) => {
// Leaving all mode snapshots the current calendars. Newly added calendars
// then stay excluded until selected individually or all mode is restored.
const ids = new Set(readCalendarSelection() ?? calendars.map(calendar => calendar.id));
if (ids.has(id)) ids.delete(id); else ids.add(id);
setCalendarSelection(Array.from(ids));
};
const items: MenuItem[] = [{
label: "All calendars",
description: "Include all calendars, including calendars added later.",
onSelect: () => setCalendarSelection(null),
render: ({ image, x, y, width, selected }) => drawToggleMenuItem(image, getDefaultSmallFont(), x, y, width,
"All calendars", readCalendarSelection() === null, selected),
}, {
label: "No calendars",
onSelect: () => setCalendarSelection([]),
render: ({ image, x, y, width, selected }) => drawToggleMenuItem(image, getDefaultSmallFont(), x, y, width,
"No calendars", readCalendarSelection()?.length === 0, selected),
}];
const rows = [
...calendars.map(calendar => ({ id: calendar.id,
label: `${calendar.name || "(unnamed)"} / ${calendar.accountName || "Local"} (${calendar.accountType || "local"}) #${calendar.id}` })),
...(selection ?? []).filter(id => !known.has(id)).map(id => ({ id, label: `Unavailable calendar #${id}` })),
];
for (const row of rows) {
keys.push(`calendar:${row.id}`);
items.push({
label: row.label,
description: row.label,
onSelect: () => toggle(row.id),
render: ({ image, x, y, width, selected }) => {
const font = getDefaultSmallFont();
const ids = readCalendarSelection();
drawToggleMenuItem(image, font, x, y, width, truncateText(font, row.label, width - 48),
ids === null || ids.includes(row.id), selected);
},
});
}
if (!calendars.length) items.push({
label: hasCalendarPermission() ? "No calendars available" : "Grant calendar permission on your phone",
disabled: true, onSelect: () => {},
});
const key = this.menu?.selectedIndex != null ? this.keys[this.menu.selectedIndex] : "all";
const index = Math.max(0, keys.indexOf(key ?? "all"));
this.keys = keys;
const width = ctx.stack.getBaseSize().width;
if (!this.menu || this.width !== width) {
this.width = width;
this.menu = new MenuLayer("Calendars displayed", items, {
x: 8, y: 8, width: width - 16, opaque: true, showBorder: false,
footer: "Shared by Calendar and Glanceboard",
}).selectItem(index);
} else this.menu.setItems(items, index);
return this.menu;
}
paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage {
return this.currentMenu(ctx).paint(ctx, paintBelow);
}
async handleInput(event: InputEvent, ctx: LayerContext): Promise<void> {
await this.currentMenu(ctx).handleInput(event, ctx);
}
}
export function calendarSelectionMenuItems(): MenuItem[] {
return global.isAndroid ? [{
label: "Calendars displayed",
description: "Choose the calendars used by Calendar, Glanceboard and other calendar views.",
onSelect: ctx => ctx.stack.push(new CalendarFilterLayer()),
}] : [];
}
+1 -2
View File
@@ -1,6 +1,5 @@
import { type GlanceWidgetDefinition, type GlanceWidgetId } from "../widget";
import { CalendarWidget } from "./calendar-widget";
import { calendarSelectionMenuItems } from "../../calendar/calendar-filter";
import { CompassWidget } from "./compass-widget";
import { MusicWidget, musicSettingsMenuItems } from "./music-widget";
import { NightscoutWidget } from "./nightscout-widget";
@@ -12,7 +11,7 @@ import { HealthWidget } from "./health-widget";
/** Every widget a board slot can hold. */
export const GLANCE_WIDGETS: readonly GlanceWidgetDefinition[] = [
{ id: "system-card", label: "System card", settingsMenuItems: systemCardSettingsMenuItems, create: () => new SystemCardWidget() },
{ id: "calendar", label: "Calendar", tall: true, settingsMenuItems: calendarSelectionMenuItems, create: () => new CalendarWidget() },
{ id: "calendar", label: "Calendar", tall: true, create: () => new CalendarWidget() },
{ id: "terminal", label: "Terminal", tall: true, create: () => new TerminalWidget() },
{ id: "t3code", label: "T3 Code", tall: true, create: () => new T3CodeWidget() },
{ id: "nightscout", label: "Nightscout", create: () => new NightscoutWidget() },
-19
View File
@@ -1,19 +0,0 @@
import { getStringSetting, setStringSetting } from "./settings-store";
export const CALENDAR_SELECTION_KEY = "calendar.selectedIds";
/** null means all calendars (including future ones); [] explicitly means none. */
export function readCalendarSelection(): string[] | null {
try {
const value = JSON.parse(getStringSetting(CALENDAR_SELECTION_KEY, "null"));
if (value === null) return null;
if (!Array.isArray(value) || !value.every(id => typeof id === "string" && /^\d+$/.test(id))) return null;
return Array.from(new Set<string>(value));
} catch {
return null;
}
}
export function setCalendarSelection(ids: readonly string[] | null): void {
if (ids !== null && !ids.every(id => /^\d+$/.test(id))) throw new Error("Invalid calendar ID");
setStringSetting(CALENDAR_SELECTION_KEY, JSON.stringify(ids === null ? null : Array.from(new Set(ids))));
}
-22
View File
@@ -1,22 +0,0 @@
import { Utils } from "@nativescript/core";
import { hasCalendarPermission } from "./calendar-permissions";
declare const com: any;
export type CalendarSource = { id: string; name: string; accountName: string; accountType: string };
/** Android calendar IDs survive renames and distinguish equal display names. */
export function readAvailableCalendars(): CalendarSource[] {
if (!global.isAndroid || !hasCalendarPermission()) return [];
try {
const context = Utils.android.getApplicationContext();
if (!context) return [];
const parsed = JSON.parse(String(com.faceclaw.app.FaceclawCalendarProvider.getCalendarsJson(context)));
if (!Array.isArray(parsed)) return [];
return parsed.filter(row => row && typeof row.id === "string" && /^\d+$/.test(row.id))
.map(row => ({ id: row.id, name: String(row.name ?? ""),
accountName: String(row.accountName ?? ""), accountType: String(row.accountType ?? "") }));
} catch {
return [];
}
}
+3 -15
View File
@@ -2,8 +2,6 @@ import { Utils } from "@nativescript/core";
import { hasCalendarPermission } from "../g2/android-permissions";
import { spanCurrent } from "./frame-timings";
import { type CalendarEvent, type CalendarReadState } from "./calendar-types";
import { CALENDAR_SELECTION_KEY, readCalendarSelection } from "./calendar-selection";
import { onSettingsStoreChanged } from "./settings-store";
export type { CalendarEvent } from "./calendar-types";
declare const com: any;
@@ -15,21 +13,14 @@ declare const com: any;
*/
// Android reads synchronously; iOS notifies subscribers after background reads.
export function onCalendarChanged(listener: () => void): () => void {
return onSettingsStoreChanged(key => {
if (key === CALENDAR_SELECTION_KEY || key == null) {
invalidateCalendarCache();
listener();
}
});
}
export function onCalendarChanged(_listener: () => void): () => void { return () => {}; }
export function getCalendarReadState(): CalendarReadState { return "ready"; }
const DEFAULT_MAX_EVENTS = 50;
const DEFAULT_WINDOW_MS = 14 * 24 * 60 * 60 * 1000;
const CACHE_MS = 30_000;
let cache: { events: CalendarEvent[]; atMs: number; maxEvents: number; windowMs: number; selection: string } | null = null;
let cache: { events: CalendarEvent[]; atMs: number; maxEvents: number; windowMs: number } | null = null;
/**
* Upcoming events from now through the given window, ordered by start time.
@@ -44,11 +35,9 @@ export function readUpcomingEvents(
if (!global.isAndroid || !hasCalendarPermission()) return [];
const now = Date.now();
const selection = JSON.stringify(readCalendarSelection());
if (
!forceRefresh &&
cache &&
cache.selection === selection &&
cache.maxEvents === maxEvents &&
cache.windowMs === windowMs &&
now - cache.atMs < CACHE_MS
@@ -66,7 +55,6 @@ export function readUpcomingEvents(
context,
Math.max(0, Math.round(maxEvents)),
Math.max(0, Math.round(windowMs)),
selection,
),
),
);
@@ -74,7 +62,7 @@ export function readUpcomingEvents(
const events = Array.isArray(parsed)
? parsed.map(normalizeEvent).filter((event): event is CalendarEvent => Boolean(event))
: [];
cache = { events, atMs: now, maxEvents, windowMs, selection };
cache = { events, atMs: now, maxEvents, windowMs };
return events;
} catch {
return [];
+33
View File
@@ -0,0 +1,33 @@
# Android 16 KiB page compatibility
The initial debug APK triggered Android's page-size compatibility warning.
Its `libfaceclaw_llama.so` LOAD segments were aligned to 4096 bytes. The other
six packaged arm64 libraries were aligned to 16384 bytes, and APK ZIP alignment
already passed `zipalign -c -P 16 4`.
The llama JNI shared library now links with both `max-page-size=16384` and
`common-page-size=16384`, matching the LC3 JNI library. This changes the native
binary layout rather than hiding the compatibility warning or disabling debug.
Gradle already tracks CMakeLists.txt as an input, and Ninja reconfigures and
relinks existing builds after this change.
Reproduce the regression and artifact checks inside `devenv shell`:
```sh
python3 -m unittest discover -s tests -p test_apk_pages.py
bash build.sh
python3 scripts/check-apk-pages.py platforms/android/app/build/outputs/apk/debug/app-debug.apk
"$ANDROID_HOME/build-tools/35.0.1/zipalign" -c -P 16 4 platforms/android/app/build/outputs/apk/debug/app-debug.apk
```
The checker rejects the initial APK and reports its misaligned llama library.
Five unit tests cover 4 KiB rejection, 16 KiB acceptance, RELRO boundaries and
invalid ELF program headers. APK checks inspect all arm64/x86_64 shared libraries.
Reference: [Android's 16 KiB guidance](https://developer.android.com/guide/practices/page-sizes).
Static alignment and successful installation do not prove every native code
path works on-device; voice/LLM features still require functional testing.
The rebuilt APK passes all seven native-library checks, ZIP alignment and APK
signature verification. The connected Pixel 10 Pro Fold reports `getconf
PAGE_SIZE` = 4096; actual execution with 16 KiB pages remains untested.
-29
View File
@@ -1,29 +0,0 @@
# Android calendar selection validation
Software: `npm test` and `bash lint.sh` for changed TypeScript files.
`tests/calendar-selection.test.cjs` covers preference reloads, all versus none,
duplicate names/accounts, selection changes with cached readers, deleted IDs,
recurrence occurrences and forwarding the selection to the provider before its
limit. Provider SQL structure is checked statically; the mocked bridge does not
replace an Android CalendarContract integration test.
On an Android device (pending):
1. With no saved preference, compare events with the current release.
2. Open Calendar's window menu > Calendars displayed (also available through
Glanceboard's Calendar widget settings). Select between two equal-named
calendars belonging to different accounts. Check ID/account labels.
3. Create more than 50 early events in an excluded calendar and later recurring
events in a selected calendar. Check those later occurrences still appear.
4. Select “No calendars”: Calendar, Glanceboard and any other readers must be
empty immediately. Restart and confirm the selection persists.
5. Select individual calendars, rename one, then delete one. Remaining selections
must stay unchanged. A missing selected ID is shown as unavailable and may be
removed; it never causes a fallback to all calendars.
6. Select “All calendars”, add a calendar, and check it is included. In individual
mode, newly added calendars stay excluded. Check all-day and timed recurring
events in both Calendar and Glanceboard, including timezone/DST boundaries.
IDs are Android CalendarContract IDs, stable across display-name changes within
an installation. Removing/re-adding an account can create new calendar IDs.
The iOS calendar reader and its behavior are unchanged; iOS selection is deferred.
+57
View File
@@ -0,0 +1,57 @@
#!/usr/bin/env python3
"""Check ELF64 LOAD/RELRO alignment in an APK; pair with zipalign -c -P 16 4."""
import argparse
import struct
import zipfile
PAGE = 16384
def alignment_errors(data):
if len(data) < 64 or data[:4] != b"\x7fELF" or data[4] != 2 or data[5] not in (1, 2):
return ["expected an ELF64 library"]
endian = "<" if data[5] == 1 else ">"
offset = struct.unpack_from(endian + "Q", data, 32)[0]
size, count = struct.unpack_from(endian + "HH", data, 54)
if size < 56 or offset + size * count > len(data):
return ["invalid program headers"]
headers = [struct.unpack_from(endian + "IIQQQQQQ", data, offset + i * size) for i in range(count)]
errors = []
loads = [h for h in headers if h[0] == 1]
if not loads:
errors.append("no LOAD segments")
for h in loads:
if h[7] < PAGE or h[7] % PAGE or (h[3] - h[2]) % PAGE:
errors.append(f"LOAD alignment {h[7]} is incompatible with 16 KiB pages")
for h in headers:
if h[0] != 0x6474E552:
continue
end = h[3] + h[6]
# A RELRO ending within a writable LOAD may protect unrelated writable
# data on a 16 KiB device. A separate LOAD after RELRO is also safe.
if end % PAGE and any(p[1] & 2 and p[3] <= h[3] and end < p[3] + p[6] for p in loads):
errors.append("RELRO ends inside writable LOAD without 16 KiB alignment")
return errors
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("apk")
args = parser.parse_args()
checked = 0
failed = False
with zipfile.ZipFile(args.apk) as archive:
for name in archive.namelist():
if not name.startswith(("lib/arm64-v8a/", "lib/x86_64/")) or not name.endswith(".so"):
continue
checked += 1
errors = alignment_errors(archive.read(name))
failed |= bool(errors)
print(f"{'FAIL' if errors else 'OK'} {name}" + (": " + "; ".join(errors) if errors else ""))
if not checked:
parser.error("no 64-bit native libraries found")
return int(failed)
if __name__ == "__main__":
raise SystemExit(main())
-150
View File
@@ -1,150 +0,0 @@
const test = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');
const vm = require('node:vm');
const ts = require('typescript');
const source = file => fs.readFileSync(path.join(__dirname, '..', file), 'utf8');
function load(file, modules, globals = {}) {
const context = { exports: {}, require: name => {
assert.ok(name in modules, `Unexpected import ${name}`);
return modules[name];
}, ...globals };
vm.runInNewContext(ts.transpileModule(source(file), {
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
}).outputText, context);
return context.exports;
}
function fixture(settings = new Map()) {
const listeners = new Set();
const storage = {
getStringSetting: (key, fallback) => settings.get(key) ?? fallback,
setStringSetting: (key, value) => { settings.set(key, value); for (const fn of listeners) fn(key); },
onSettingsStoreChanged: fn => { listeners.add(fn); return () => listeners.delete(fn); },
};
const prefs = load('app/native/calendar-selection.ts', { './settings-store': storage });
let permitted = true;
const calls = [];
const calendars = [
{ id: '1', name: 'Work', accountName: 'one@example.com', accountType: 'google' },
{ id: '2', name: 'Work', accountName: 'two@example.com', accountType: 'google' },
];
const events = [
{ id: 1, calendarId: '1', startMs: 10000, endMs: 20000, title: 'Excluded early' },
{ id: 9, calendarId: '2', startMs: 30000, endMs: 40000, title: 'Recurrence one' },
{ id: 9, calendarId: '2', startMs: 50000, endMs: 60000, title: 'Recurrence two' },
];
const modules = {
'@nativescript/core': { Utils: { android: { getApplicationContext: () => ({}) } } },
'../g2/android-permissions': { hasCalendarPermission: () => permitted },
'./calendar-permissions': { hasCalendarPermission: () => permitted },
'./frame-timings': { spanCurrent: (_name, fn) => fn() },
'./calendar-selection': prefs,
'./settings-store': storage,
};
const globals = { global: { isAndroid: true }, com: { faceclaw: { app: { FaceclawCalendarProvider: {
getCalendarsJson: () => JSON.stringify(calendars),
getUpcomingEventsJson: (_ctx, max, window, selection) => {
calls.push({ max, window, selection });
const ids = JSON.parse(selection);
return JSON.stringify(events.filter(event => ids === null || ids.includes(event.calendarId)).slice(0, max));
},
} } } } };
const api = load('app/native/calendar.ts', modules, globals);
const sources = load('app/native/calendar-sources.ts', modules, globals);
return { api, prefs, sources, modules, globals, settings, calls, calendars,
permissions: value => { permitted = value; } };
}
test('calendar selection distinguishes all and none, survives restart and rejects invalid data', () => {
const f = fixture();
assert.equal(f.prefs.readCalendarSelection(), null);
f.prefs.setCalendarSelection([]);
assert.deepEqual(Array.from(fixture(f.settings).prefs.readCalendarSelection()), []);
f.prefs.setCalendarSelection(['2', '2', '1']);
assert.deepEqual(Array.from(fixture(f.settings).prefs.readCalendarSelection()), ['2', '1']);
f.prefs.setCalendarSelection(null);
assert.equal(fixture(f.settings).prefs.readCalendarSelection(), null);
assert.throws(() => f.prefs.setCalendarSelection(['1 OR 1=1']));
for (const value of ['oops', '{}', '[false]', '["bad"]']) {
f.settings.set(f.prefs.CALENDAR_SELECTION_KEY, value);
assert.equal(f.prefs.readCalendarSelection(), null);
}
});
test('shared reader forwards IDs before limiting, preserves recurrence occurrences and invalidates all cached query variants', async () => {
const f = fixture();
assert.equal(f.api.readUpcomingEvents(1)[0].title, 'Excluded early');
f.api.readUpcomingEvents(1);
assert.equal(f.calls.length, 1);
let notifications = 0;
const off = f.api.onCalendarChanged(() => notifications++);
f.prefs.setCalendarSelection(['2']);
const rows = f.api.readUpcomingEvents(2);
assert.deepEqual(Array.from(rows, event => event.id), [9, 9]);
assert.equal(f.calls.at(-1).selection, '["2"]');
assert.equal(notifications, 1);
assert.equal((await f.api.readUpcomingEventsAsync(1))[0].title, 'Recurrence one');
off();
f.prefs.setCalendarSelection([]);
assert.equal(notifications, 1);
assert.equal(f.api.readUpcomingEvents(1).length, 0, 'selection cache key works even without subscriptions');
assert.equal(fixture(f.settings).api.readUpcomingEvents().length, 0);
f.prefs.setCalendarSelection(['999']);
assert.equal(f.api.readUpcomingEvents().length, 0, 'deleted calendar does not revert to all');
f.permissions(false);
assert.equal(f.api.readUpcomingEvents().length, 0);
assert.equal(f.sources.readAvailableCalendars().length, 0);
});
test('calendar menu distinguishes equal names by account and ID; all, none, deleted and individual selections share preferences', () => {
const f = fixture();
const { CalendarFilterLayer } = load('app/apps/calendar/calendar-filter.ts', {
'../../graphics/ui-fonts': { getDefaultSmallFont: () => ({}) },
'../../graphics/textwrap': { truncateText: (_font, text) => text },
'../../native/calendar-selection': f.prefs,
'../../native/calendar-sources': f.sources,
'../../native/calendar-permissions': { hasCalendarPermission: () => true },
'../../ui/menu': {
drawToggleMenuItem: () => {},
MenuLayer: class {
constructor(_title, items) { this.items = items; this.selectedIndex = 0; }
selectItem(index) { this.selectedIndex = index; return this; }
setItems(items, index) { this.items = items; this.selectedIndex = index; }
paint() { return this.items; }
},
},
}, f.globals);
const layer = new CalendarFilterLayer();
const ctx = { stack: { getBaseSize: () => ({ width: 576 }) } };
const rows = () => layer.paint(ctx, () => {});
assert.ok(rows()[2].label.includes('one@example.com'));
assert.ok(rows()[3].label.includes('two@example.com'));
rows()[2].onSelect();
assert.deepEqual(Array.from(f.prefs.readCalendarSelection()), ['2']);
rows()[1].onSelect();
assert.equal(f.api.readUpcomingEvents().length, 0);
rows()[3].onSelect();
assert.deepEqual(Array.from(f.prefs.readCalendarSelection()), ['2']);
f.calendars.pop();
const missing = rows().find(row => row.label === 'Unavailable calendar #2');
assert.ok(missing);
missing.onSelect();
assert.equal(f.prefs.readCalendarSelection().length, 0);
rows()[0].onSelect();
assert.equal(f.prefs.readCalendarSelection(), null);
});
test('Android provider restricts Instances with bound calendar IDs before cutoff and limit', () => {
const kotlin = source('App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawCalendarProvider.kt');
assert.match(kotlin, /Instances\.CALENDAR_ID/);
assert.match(kotlin, /if \(ids != null && ids.length\(\) == 0\) return "\[\]"/);
assert.match(kotlin, /PROJECTION,\s+selection,\s+args,/);
assert.ok(kotlin.indexOf('selection,\n args,') < kotlin.indexOf('events.take(limit)'));
assert.match(kotlin, /CalendarContract\.Calendars\._ID/);
assert.match(kotlin, /CalendarContract\.Calendars\.ACCOUNT_NAME/);
for (const file of ['app/apps/calendar/calendar.ts', 'app/apps/glanceboard/widgets/calendar-widget.ts']) {
assert.match(source(file), /readUpcomingEvents/);
assert.match(source(file), /native\/calendar"/);
}
});
-1
View File
@@ -199,7 +199,6 @@ test('Calendar window subscribes, refreshes periodically, and cleans up on close
'../../native/calendar': { onCalendarChanged: fn => { listener = fn; return () => unsubscribed++; } },
'../../ui/shell/chrome-layer': { makeImageWindowIcon() {}, windowIcon() {} },
'./calendar': { CalendarLayer: class {} }, './calendar-icon': {},
'./calendar-filter': { calendarSelectionMenuItems: () => [] },
'../../ui/shell/in-process-window': { YieldAtRootLayer: class {}, createInProcessWindow: value => { options = value; return app; } },
}, { setInterval: fn => { tick = fn; return 1; }, clearInterval: () => cleared++ });
createCalendarAppWindow({ onClosed: () => closed++ });
+40
View File
@@ -0,0 +1,40 @@
import importlib.util
from pathlib import Path
import struct
import unittest
spec = importlib.util.spec_from_file_location("apk_pages", Path(__file__).parents[1] / "scripts/check-apk-pages.py")
checker = importlib.util.module_from_spec(spec)
spec.loader.exec_module(checker)
def elf(alignment=16384, relro_end=16384, writable_end=32768):
data = bytearray(64 + 2 * 56)
data[:6] = b"\x7fELF\x02\x01"
struct.pack_into("<Q", data, 32, 64)
struct.pack_into("<HH", data, 54, 56, 2)
struct.pack_into("<IIQQQQQQ", data, 64, 1, 6, 0, 0, 0, writable_end, writable_end, alignment)
struct.pack_into("<IIQQQQQQ", data, 120, 0x6474E552, 4, 0, 0, 0, relro_end, relro_end, 1)
return data
class AlignmentTests(unittest.TestCase):
def test_rejects_4k_loads(self):
self.assertTrue(checker.alignment_errors(elf(alignment=4096)))
def test_accepts_16k_loads_and_relro(self):
self.assertEqual([], checker.alignment_errors(elf()))
def test_rejects_relro_protecting_writable_data(self):
self.assertTrue(checker.alignment_errors(elf(relro_end=4096)))
def test_accepts_relro_at_end_of_writable_load(self):
self.assertEqual([], checker.alignment_errors(elf(relro_end=4096, writable_end=4096)))
def test_rejects_invalid_headers(self):
self.assertTrue(checker.alignment_errors(b"not ELF"))
self.assertTrue(checker.alignment_errors(elf()[:70]))
if __name__ == "__main__":
unittest.main()