Compare commits

..
Author SHA1 Message Date
Blendman974 1b2095aa5b build: add reproducible Nix Android and Wear OS environment 2026-11-06 04:21:21 +01:00
18 changed files with 184 additions and 378 deletions

No files matched your search

+3
View File
@@ -0,0 +1,3 @@
watch_file devenv.nix devenv.yaml devenv.lock
eval "$(devenv direnvrc)"
use devenv
+5
View File
@@ -49,6 +49,11 @@ faceclaw_settings.xml
faceclaw_settings*.json faceclaw_settings*.json
# Developer configs # Developer configs
.devenv*
.direnv/
.android/
devenv.local.nix
local.properties
build_paths.sh build_paths.sh
**/xcuserdata/ **/xcuserdata/
+8
View File
@@ -162,6 +162,14 @@ tasks.register("prepareFaceclawNativeLibs") {
def faceclawLlamaCppTag = "b10333" def faceclawLlamaCppTag = "b10333"
def faceclawFindSdkCmakeDir = { def faceclawFindSdkCmakeDir = {
// NixOS and other managed environments can provide patched host tools.
def explicitCmake = System.getenv("ANDROID_CMAKE_HOME")
if (explicitCmake != null) {
def explicitDir = file(explicitCmake)
if (faceclawHostExecutable(file("$explicitDir/bin"), "cmake").exists()
&& faceclawHostExecutable(file("$explicitDir/bin"), "ninja").exists()) return explicitDir
throw new GradleException("ANDROID_CMAKE_HOME must contain bin/cmake and bin/ninja: $explicitDir")
}
def sdkRoot = System.getenv("ANDROID_HOME") ?: System.getenv("ANDROID_SDK_ROOT") def sdkRoot = System.getenv("ANDROID_HOME") ?: System.getenv("ANDROID_SDK_ROOT")
if (sdkRoot == null) return null if (sdkRoot == null) return null
def cmakeRoot = file("$sdkRoot/cmake") def cmakeRoot = file("$sdkRoot/cmake")
@@ -54,8 +54,7 @@ class FaceclawCalendarProvider private constructor() {
* boundaries the provider stores them as. * boundaries the provider stores them as.
*/ */
@JvmStatic @JvmStatic
@JvmOverloads fun getUpcomingEventsJson(context: Context?, maxEvents: Int, windowMs: Long): String {
fun getUpcomingEventsJson(context: Context?, maxEvents: Int, windowMs: Long, selectedCalendarIdsJson: String = "null"): String {
if (context == null || maxEvents <= 0) { if (context == null || maxEvents <= 0) {
return "[]" return "[]"
} }
@@ -74,21 +73,11 @@ class FaceclawCalendarProvider private constructor() {
val events = ArrayList<Event>() val events = ArrayList<Event>()
var cursor: Cursor? = null var cursor: Cursor? = null
try { 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( cursor = context.contentResolver.query(
uri, uri,
PROJECTION, PROJECTION,
selection, null,
args, null,
CalendarContract.Instances.BEGIN + " ASC") CalendarContract.Instances.BEGIN + " ASC")
if (cursor != null) { if (cursor != null) {
val utc = Calendar.getInstance(TimeZone.getTimeZone("UTC")) val utc = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
@@ -129,33 +118,6 @@ class FaceclawCalendarProvider private constructor() {
return out.toString() 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 { private fun readEvent(cursor: Cursor, utc: Calendar, local: Calendar): Event {
val allDay = cursor.getInt(4) != 0 val allDay = cursor.getInt(4) != 0
var startMs = cursor.getLong(2) var startMs = cursor.getLong(2)
-5
View File
@@ -3,7 +3,6 @@ import { invalidateCalendarCache, onCalendarChanged } from "../../native/calenda
import { makeImageWindowIcon, windowIcon } from "../../ui/shell/chrome-layer"; import { makeImageWindowIcon, windowIcon } from "../../ui/shell/chrome-layer";
import { CalendarLayer } from "./calendar"; import { CalendarLayer } from "./calendar";
import { renderCalendarDateIcon } from "./calendar-icon"; import { renderCalendarDateIcon } from "./calendar-icon";
import { calendarSelectionMenuItems } from "./calendar-filter";
import { import {
createInProcessWindow, createInProcessWindow,
YieldAtRootLayer, YieldAtRootLayer,
@@ -45,10 +44,6 @@ export function createCalendarAppWindow(options: InProcessAppOptions): InProcess
icon: "calendar", icon: "calendar",
drawIcon: makeImageWindowIcon(renderCalendarDateIcon, windowIcon("calendar", "Ca")), drawIcon: makeImageWindowIcon(renderCalendarDateIcon, windowIcon("calendar", "Ca")),
closeable: true, closeable: true,
menuItems: () => calendarSelectionMenuItems().map(item => ({ ...item, onSelect: (ctx, menu) => {
ctx.stack.pop();
return item.onSelect(ctx, menu);
} })),
actions: options.actions, actions: options.actions,
baseLayer: new YieldAtRootLayer(new CalendarLayer(requestPermission)), baseLayer: new YieldAtRootLayer(new CalendarLayer(requestPermission)),
submitFrame: options.submitFrame, 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 { type GlanceWidgetDefinition, type GlanceWidgetId } from "../widget";
import { CalendarWidget } from "./calendar-widget"; import { CalendarWidget } from "./calendar-widget";
import { calendarSelectionMenuItems } from "../../calendar/calendar-filter";
import { CompassWidget } from "./compass-widget"; import { CompassWidget } from "./compass-widget";
import { MusicWidget, musicSettingsMenuItems } from "./music-widget"; import { MusicWidget, musicSettingsMenuItems } from "./music-widget";
import { NightscoutWidget } from "./nightscout-widget"; import { NightscoutWidget } from "./nightscout-widget";
@@ -12,7 +11,7 @@ import { HealthWidget } from "./health-widget";
/** Every widget a board slot can hold. */ /** Every widget a board slot can hold. */
export const GLANCE_WIDGETS: readonly GlanceWidgetDefinition[] = [ export const GLANCE_WIDGETS: readonly GlanceWidgetDefinition[] = [
{ id: "system-card", label: "System card", settingsMenuItems: systemCardSettingsMenuItems, create: () => new SystemCardWidget() }, { 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: "terminal", label: "Terminal", tall: true, create: () => new TerminalWidget() },
{ id: "t3code", label: "T3 Code", tall: true, create: () => new T3CodeWidget() }, { id: "t3code", label: "T3 Code", tall: true, create: () => new T3CodeWidget() },
{ id: "nightscout", label: "Nightscout", create: () => new NightscoutWidget() }, { 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 { hasCalendarPermission } from "../g2/android-permissions";
import { spanCurrent } from "./frame-timings"; import { spanCurrent } from "./frame-timings";
import { type CalendarEvent, type CalendarReadState } from "./calendar-types"; 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"; export type { CalendarEvent } from "./calendar-types";
declare const com: any; declare const com: any;
@@ -15,21 +13,14 @@ declare const com: any;
*/ */
// Android reads synchronously; iOS notifies subscribers after background reads. // Android reads synchronously; iOS notifies subscribers after background reads.
export function onCalendarChanged(listener: () => void): () => void { export function onCalendarChanged(_listener: () => void): () => void { return () => {}; }
return onSettingsStoreChanged(key => {
if (key === CALENDAR_SELECTION_KEY || key == null) {
invalidateCalendarCache();
listener();
}
});
}
export function getCalendarReadState(): CalendarReadState { return "ready"; } export function getCalendarReadState(): CalendarReadState { return "ready"; }
const DEFAULT_MAX_EVENTS = 50; const DEFAULT_MAX_EVENTS = 50;
const DEFAULT_WINDOW_MS = 14 * 24 * 60 * 60 * 1000; const DEFAULT_WINDOW_MS = 14 * 24 * 60 * 60 * 1000;
const CACHE_MS = 30_000; 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. * Upcoming events from now through the given window, ordered by start time.
@@ -44,11 +35,9 @@ export function readUpcomingEvents(
if (!global.isAndroid || !hasCalendarPermission()) return []; if (!global.isAndroid || !hasCalendarPermission()) return [];
const now = Date.now(); const now = Date.now();
const selection = JSON.stringify(readCalendarSelection());
if ( if (
!forceRefresh && !forceRefresh &&
cache && cache &&
cache.selection === selection &&
cache.maxEvents === maxEvents && cache.maxEvents === maxEvents &&
cache.windowMs === windowMs && cache.windowMs === windowMs &&
now - cache.atMs < CACHE_MS now - cache.atMs < CACHE_MS
@@ -66,7 +55,6 @@ export function readUpcomingEvents(
context, context,
Math.max(0, Math.round(maxEvents)), Math.max(0, Math.round(maxEvents)),
Math.max(0, Math.round(windowMs)), Math.max(0, Math.round(windowMs)),
selection,
), ),
), ),
); );
@@ -74,7 +62,7 @@ export function readUpcomingEvents(
const events = Array.isArray(parsed) const events = Array.isArray(parsed)
? parsed.map(normalizeEvent).filter((event): event is CalendarEvent => Boolean(event)) ? 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; return events;
} catch { } catch {
return []; return [];
+65
View File
@@ -0,0 +1,65 @@
{
"nodes": {
"devenv": {
"locked": {
"dir": "src/modules",
"lastModified": 1793731702,
"narHash": "sha256-WlVNaWXVTYaGBNey2Z+20sY1lT7BvzJEECb+VlDDdk0=",
"owner": "cachix",
"repo": "devenv",
"rev": "9655d320b8f9df74dbecf681f52a7334574606c3",
"type": "github"
},
"original": {
"dir": "src/modules",
"owner": "cachix",
"repo": "devenv",
"type": "github"
}
},
"nixpkgs": {
"inputs": {
"nixpkgs-src": "nixpkgs-src"
},
"locked": {
"lastModified": 1793043970,
"narHash": "sha256-m14odYTdkBUEkJOiEYs2zjGjn8fcjvdCJsm45+k084U=",
"owner": "cachix",
"repo": "devenv-nixpkgs",
"rev": "d97234e58d4e90e3bf77c082fc3b546e51200938",
"type": "github"
},
"original": {
"owner": "cachix",
"ref": "rolling",
"repo": "devenv-nixpkgs",
"type": "github"
}
},
"nixpkgs-src": {
"flake": false,
"locked": {
"lastModified": 1792812153,
"narHash": "sha256-T2+XBfNbf9pecLUWS4+RtuVNZ3W8K5taG5QdV71mWlk=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "674a2028661e550a97400c1cc992b9cca9a668a1",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixpkgs-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"root": {
"inputs": {
"devenv": "devenv",
"nixpkgs": "nixpkgs"
}
}
},
"root": "root",
"version": 7
}
+42
View File
@@ -0,0 +1,42 @@
{ pkgs, config, lib, ... }:
{
languages.javascript = {
enable = true;
package = pkgs.nodejs_22;
};
languages.java = {
enable = true;
jdk.package = pkgs.jdk21;
lsp.enable = false;
};
android = {
enable = true;
platforms.version = [ "35" ];
buildTools.version = [ "34.0.0" "35.0.0" "35.0.1" ];
ndk.enable = true;
ndk.version = [ "27.2.12479018" ];
cmake.version = [ ];
emulator.enable = false;
systemImages.enable = false;
sources.enable = false;
};
packages = with pkgs; [ git gh curl jq ripgrep python3 pkg-config gnumake gcc unzip zip ];
# Gradle's downloaded aapt2 cannot run directly on NixOS.
# Keep API 35 aapt2 for phone builds even with Wear's older tools installed.
env.GRADLE_OPTS = lib.mkForce "-Dorg.gradle.project.android.aapt2FromMavenOverride=${config.env.ANDROID_HOME}/build-tools/35.0.0/aapt2";
# NativeScript's doctor rejects a valid build-only SDK without an emulator.
# enterTest below checks the actual tools used by our local builds.
env.NS_SKIP_ENV_CHECK = "1";
env.ANDROID_CMAKE_HOME = "${pkgs.symlinkJoin {
name = "faceclaw-cmake";
paths = [ pkgs.cmake pkgs.ninja ];
}}";
scripts.faceclaw-setup.exec = "npm ci";
scripts.faceclaw-test.exec = "npm test";
enterShell = ''
export PATH="$DEVENV_ROOT/node_modules/.bin:$PATH"
'';
enterTest = ''
bash "$DEVENV_ROOT/scripts/check-devenv.sh"
'';
}
+7
View File
@@ -0,0 +1,7 @@
inputs:
nixpkgs:
url: github:cachix/devenv-nixpkgs/rolling
nixpkgs:
allow_unfree: true
android_sdk:
accept_license: true
+29
View File
@@ -0,0 +1,29 @@
# Nix development environment
Install Nix with flakes and devenv, then run `devenv shell` in this directory
(or `nix run nixpkgs#devenv -- shell`). With direnv, `direnv allow` loads `.envrc`.
The committed `devenv.lock` pins the environment inputs.
The environment provides Node 22/npm, Java 21, Android SDK/platform 35,
build-tools 34.0.0 (Wear OS) and 35.0.0/35.0.1 (phone and NativeScript plugins), NDK 27, CMake,
Git/GitHub CLI, Python and build utilities. `ANDROID_CMAKE_HOME` selects the
Nix-patched CMake/Ninja pair for the native Android libraries (the SDK's bundled
Ninja can crash on NixOS). Other environments keep using the SDK's CMake.
Android SDK licenses are accepted through `devenv.yaml`. Gradle uses the
Nix-patched SDK aapt2. Gradle itself comes from the repository's wrapper.
The emulator and system images are omitted. `NS_SKIP_ENV_CHECK=1` bypasses
NativeScript doctor's mandatory emulator check; `devenv test` checks the actual
SDK/JDK build prerequisites instead.
Run `faceclaw-setup` (`npm ci`) once, then `faceclaw-test` (`npm test`),
`npm run lint` and `npm run test:kotlin`. `devenv test` checks the environment.
`bash build.sh` builds the Android app; it does not install it. On NixOS, any
additional downloaded native executables may require the host's nix-ld support.
iOS builds still require macOS/Xcode and are outside this Linux environment.
Keep machine-specific signing/device settings in the ignored `build_paths.sh`.
Use `gh auth login` separately if GitHub CLI is not already authenticated.
Software tests do not validate Bluetooth behavior on physical glasses. Record
device/firmware versions and manual results separately for hardware checks.
Do not flash firmware during development without explicit permission.
-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.
+18
View File
@@ -0,0 +1,18 @@
#!/usr/bin/env bash
set -euo pipefail
node --version
java -version
test -f "$ANDROID_HOME/platforms/android-35/android.jar"
for version in 34.0.0 35.0.0 35.0.1; do
"$ANDROID_HOME/build-tools/$version/aapt2" version
done
"$ANDROID_HOME/platform-tools/adb" version
"$ANDROID_CMAKE_HOME/bin/cmake" --version
"$ANDROID_CMAKE_HOME/bin/ninja" --version
case "$(uname -s)" in
Darwin) ndk_host=darwin-x86_64 ;;
*) ndk_host=linux-x86_64 ;;
esac
test -x "$ANDROID_HOME/ndk/27.2.12479018/toolchains/llvm/prebuilt/$ndk_host/bin/clang"
echo "Faceclaw development tools verified."
-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++; } }, '../../native/calendar': { onCalendarChanged: fn => { listener = fn; return () => unsubscribed++; } },
'../../ui/shell/chrome-layer': { makeImageWindowIcon() {}, windowIcon() {} }, '../../ui/shell/chrome-layer': { makeImageWindowIcon() {}, windowIcon() {} },
'./calendar': { CalendarLayer: class {} }, './calendar-icon': {}, './calendar': { CalendarLayer: class {} }, './calendar-icon': {},
'./calendar-filter': { calendarSelectionMenuItems: () => [] },
'../../ui/shell/in-process-window': { YieldAtRootLayer: class {}, createInProcessWindow: value => { options = value; return app; } }, '../../ui/shell/in-process-window': { YieldAtRootLayer: class {}, createInProcessWindow: value => { options = value; return app; } },
}, { setInterval: fn => { tick = fn; return 1; }, clearInterval: () => cleared++ }); }, { setInterval: fn => { tick = fn; return 1; }, clearInterval: () => cleared++ });
createCalendarAppWindow({ onClosed: () => closed++ }); createCalendarAppWindow({ onClosed: () => closed++ });