1635 lines
75 KiB
C
1635 lines
75 KiB
C
/* meow_bootmenu.c — R3 Pro II MeowOS/HibyOS 开机引导选单（阶段0 · M0 二进制自检版）
|
||
*
|
||
* M2.14 热键一次触发修复（2026-08-29，MEOW_BOOTMENU_VER 0.1.0-m2.14）：
|
||
* 开机武装延迟(ARM_DELAY_MS) + 播放器忙判门(proc_is_busy) 不再「静默丢弃」热键——
|
||
* 命中即置 hotkey_pending，待条件满足（延迟结束/播放器不忙）后自动弹确认框
|
||
* （用户只按一次，不需第二下）。新增 --sim-hotkey-strict 让 sim 走该门（测 pending）。
|
||
*
|
||
* M2.26 触摸确认迁移（2026-08-29，MEOW_BOOTMENU_VER 0.1.0-m2.26）：选单触摸 + 热键
|
||
* 确认框触摸从各自 t_last_x/y + t_down_x/y 解析迁到 meow_touch 统一接口（mt_reset/
|
||
* mt_abs/mt_down/mt_up；goodix 时序免疫：BTN_TOUCH=1 不锁原点，等按下后首个有效 ABS
|
||
* 才锁，位移>=65 判滑动不命中）——修「触摸确认要点两下」（电源键一下即可确认）。
|
||
* 绘制/选单逻辑/超时倒计时/fork 播放器/supervisor/热键触发核心路径不动。
|
||
*
|
||
* M2 诊断 · 信号记录 hook（仅记录，不改行为；排查「HibyOS 播放器 UI 触发关机/升级 →
|
||
* 卡最后一帧但系统没真关机/SSH 能连」第一步）：supervisor 加 bm_log() 写 TF 卡
|
||
* MeowOS/logs/meow_boot_<bootts>.log（卡不可用降级 stderr），记录 supervisor
|
||
* **收到**的信号（SIGTERM/SIGINT/SIGQUIT/SIGHUP——handler 只置标志，主循环 log 后
|
||
* signal(s,SIG_DFL)+raise(s) 恢复默认重抛，与未加 hook 一致终止）、**发出**给播放器的
|
||
* 信号（SIGSTOP/SIGCONT/SIGTERM/SIGKILL）、以及**播放器退出原因**（WTERMSIG/WEXITSTATUS）。
|
||
* 不转发信号、不善后、不 SHOW 关机画面、不截断。
|
||
*
|
||
* M2.29 supervisor 接管关机/升级（2026-08-29，MEOW_BOOTMENU_VER 0.1.0-m2.29-takeover）：
|
||
* 基于 M2 诊断 hook 抓到的两条真机信号，让 supervisor 把「播放器 UI 触发关机/升级 →
|
||
* 卡最后一帧但系统没真关机（SSH 能连）」收束掉：
|
||
* - 播放器**自然退出态 0**（UI 关机，非热键 SIGTERM 杀）：waitpid 识别 WIFEXITED&&0
|
||
* → supervisor 执行真关机（sync + reboot(2) POWER_OFF），不卡最后一帧。
|
||
* 区分：热键切 MeowOS 的 SIGTERM 杀仍在 confirm 分支内 waitpid，不进自然退出检测。
|
||
* - mtd5(ota 标记分区) 变 ota:kernel2（播放器 UI 升级 → nandwrite 写 mtd5）：supervisor
|
||
* 主循环每 500ms 读一次 /dev/mtd5 头字节（nandwrite 在 offset 0 写 256B 定长标记，
|
||
* 只读 ~15B，IO 极低），命中即判升级 → reboot(2) RESTART → uboot 读 mtd5=ota:kernel2
|
||
* 引导 kernel2（升级模式，自动刷 TF 卡 r3proii.upt）。不卡最后一帧。
|
||
* 说明：/proc/mtd 只反映分区表不变读，无法观察内容变化，故用轻量读 /dev/mtd5 轮询。
|
||
* 两根都写 bm_log（supervisor 接管 shutdown/upgrade）。
|
||
*
|
||
* ============================================================================
|
||
* WHY (设计见 BOOT_SELECTOR_DESIGN.md §3)
|
||
* ============================================================================
|
||
* - 开机最先显示选单（HibyOS / MeowOS），选择后 fork 播放器（HibyOS）或
|
||
* exec MeowOS 主屏（MeowOS）；HibyOS 模式热键（电源+音量减）杀播放器接管。
|
||
* - 本二进制 = 选单本体（M0）。M0 只做二进制自检：SSH 推 /data 独立跑，
|
||
* **不进启动链**（不碰 S90/S92/播放器/SSH 顺序）。
|
||
*
|
||
* M0 自检目标（BOOT_SELECTOR_DESIGN.md §9 M0）：
|
||
* --dumpkeys N / --sim-select H|M / --boot-only / --version 验证
|
||
* fb0 初始化、绘制、选择/超时决策、CLI 钩子。**默认不 fork 播放器**——
|
||
* M0 严禁触碰到正在运行的 hiby_player（设备上它正由 init 拉起）。
|
||
*
|
||
* ⚠️ M0 记号（BOOT_SELECTOR_DESIGN.md §2.3 播放器 fork 契约已按 §3.6 写好，
|
||
* 但本阶段默认关闭）：fork_hiby_player() 实现了「env -i 复刻 11 变量 +
|
||
* chdir("/") + stdio 重定向 + execve /usr/bin/hiby_player」的完整契约，
|
||
* 仅在传 --fork 时才会真正 exec。M2 接管 HibyOS 时由 S90 传 --fork 打开。
|
||
*
|
||
* ⚠️ 字体限制：本设备的 5x7 点阵字体（与 meow_launcherd/hello 相同）只含
|
||
* ASCII（0-9 A-Z a-z 空格 . ! - _），**无 CJK 字形**。设计稿中的中文标签
|
||
* （如「[HIBYOS 官方播放器]」）无法用该字体渲染，故本版用 ASCII 标签
|
||
* （[HIBYOS PLAYER] / [MEOWOS HOME]），CJK 渲染留待后续引入 TTF 渲染器。
|
||
*
|
||
* fb0 要点（ANALYSIS.md §18.18，勿写反）：
|
||
* FBIOGET_VSCREENINFO=0x4600 / FBIOGET_FSCREENINFO=0x4602 / FBIOPAN_DISPLAY=0x4606
|
||
* 本机 xres=480 yres=720 bpp=16 line=960 yres_virtual=1440（双缓冲）ypanstep=1
|
||
* mmap 整个虚拟帧缓冲（含两帧）；画前 FBIOPAN_DISPLAY pan 到 yoffset=0（buffer0）。
|
||
* 显示哪个缓冲由 fb_var.yoffset 决定——播放器电源/息屏重绘可能把 yoffset 留在
|
||
* buffer1，选单画在 buffer0 而面板显示 buffer1 会「选单不可见/屏幕冻结」（v6.5 bug）。
|
||
*
|
||
* 静态 MIPS32r2 musl（soft-float）编译：
|
||
* ~/Project/R3ProII/.tools/zig-mipsel-cc -Os -static meow_bootmenu.c -o meow_bootmenu
|
||
*/
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <stdarg.h>
|
||
#include <unistd.h>
|
||
#include <fcntl.h>
|
||
#include <errno.h>
|
||
#include <signal.h>
|
||
#include <stdint.h>
|
||
#include <time.h>
|
||
#include <sys/ioctl.h>
|
||
#include <sys/mman.h>
|
||
#include <sys/poll.h>
|
||
#include <sys/wait.h>
|
||
#include <sys/stat.h>
|
||
#include <sys/syscall.h> /* M2.29：supervisor 接管关机/升级，直连 reboot(2) syscall */
|
||
#include <linux/input.h>
|
||
#include "meow_touch.h"
|
||
|
||
/* ---- 本设备 fb ioctl 号（实测，勿写反）---- */
|
||
#define FBIOGET_VSCREENINFO 0x4600
|
||
#define FBIOGET_FSCREENINFO 0x4602
|
||
#define FBIOPAN_DISPLAY 0x4606
|
||
|
||
/* ---- 路径 ---- */
|
||
#define DEV_POWER "/dev/input/event0" /* md-gpio-keys: KEY_POWER(116) */
|
||
#define DEV_KEYS "/dev/input/event2" /* jz adc keyboard: VOL(114/115) PLAY(164) */
|
||
#define DEV_TOUCH "/dev/input/event1" /* goodix-ts（未 grab，可共享读） */
|
||
#define FB_DEV "/dev/fb0"
|
||
#define MEOWAPPS "/usr/data/mnt/sd_0/MeowAPPs"
|
||
#define CONF_FILE MEOWAPPS "/meow.conf" /* TF 卡配置：boot_timeout_ms/boot_menu/bg_color；boot_default 权威在板载 /data/meow_boot_default */
|
||
#define MODE_FILE "/tmp/meow_boot_mode" /* 开机模式标记（tmpfs，开机清空） */
|
||
#define PLAYER_BIN "/usr/bin/hiby_player"
|
||
#define PLAYER_LOG "/usr/data/meow_player.log"
|
||
#define LAUNCHER_BIN "/usr/bin/meow_launcherd" /* MeowOS 基础主屏（M2 接管） */
|
||
|
||
/* ---- 面板/背光（与 meow_launcherd 相同路径，§18.21/§红线）---- */
|
||
#ifndef FBIOBLANK
|
||
#define FBIOBLANK 0x4611
|
||
#endif
|
||
#define BACKLIGHT "/sys/class/backlight/backlight_pwm0/brightness"
|
||
#define BACKLIGHT_POWER "/sys/class/backlight/backlight_pwm0/bl_power"
|
||
|
||
/* ---- 热键切换（HibyOS→MeowOS）：按住电源 + 窗口内单击音量减 ---- */
|
||
#define HK_PWRWIN_MIN 60 /* 电源按下后 60ms 起 */
|
||
#define HK_PWRWIN_MAX 2500 /* 至 2500ms 止 */
|
||
#define KILL_GRACE_MS 3000 /* SIGTERM 后等待退出，超时 SIGKILL */
|
||
#define ARM_DELAY_MS 20000 /* 开机武装延迟（§18.23）：播放器拉起后 N ms 内热键不触发，避媒体扫描期冻结 */
|
||
#define BUSY_STATE_CHAR 'D' /* 播放器忙判门：/proc/<pid>/stat 态为 D（不可中断 IO=扫描）则暂不热键 */
|
||
#define SCAN_KEEP_MS 90000 /* Bug 4：HibyOS 开机媒体扫描窗（90s）内亮度保底，防黑屏几分钟（只写亮度不碰 blank） */
|
||
|
||
/* ---- key codes ---- */
|
||
#ifndef KEY_POWER
|
||
#define KEY_POWER 116
|
||
#endif
|
||
#ifndef KEY_VOLUMEDOWN
|
||
#define KEY_VOLUMEDOWN 114
|
||
#endif
|
||
#ifndef KEY_VOLUMEUP
|
||
#define KEY_VOLUMEUP 115
|
||
#endif
|
||
#ifndef KEY_PLAYPAUSE
|
||
#define KEY_PLAYPAUSE 164
|
||
#endif
|
||
|
||
/* ---- 事件号 / ioctl ---- */
|
||
#define BTN_TOUCH 0x14a
|
||
#define ABS_X 0x00
|
||
#define ABS_Y 0x01
|
||
#define ABS_MT_POSITION_X 0x35 /* goodix 走 MT 协议 B，仅 ABS_X/Y 收不到坐标（M2.1 bug） */
|
||
#define ABS_MT_POSITION_Y 0x36
|
||
#ifndef EV_KEY
|
||
#define EV_KEY 1
|
||
#endif
|
||
#ifndef EV_ABS
|
||
#define EV_ABS 3
|
||
#endif
|
||
#ifndef EVIOCGKEY
|
||
#define EVIOCGKEY(len) _IOC(_IOC_READ, 'E', 0x18, len)
|
||
#endif
|
||
#define KEYBUF_WORDS 32 /* 1024 bits, 覆盖 KEY_MAX 767 */
|
||
|
||
/* ---- 编译默认值（可被 /usr/data/mnt/sd_0/MeowAPPs/meow.conf 覆写）---- */
|
||
#define DEF_BOOT_DEFAULT 1 /* 1=HibyOS 0=MeowOS */
|
||
#define DEF_BOOT_TIMEOUT_MS 5000
|
||
#define DEF_BOOT_MENU 1
|
||
#define DEF_BG 0x000000
|
||
|
||
#define POLL_MS 10
|
||
#define SIM_SELECT_DELAY_MS 2000 /* --sim-select 延迟后模拟选 */
|
||
#define GHOST_COOLDOWN_MS 800 /* 入口 drain + 短暂冷却防幽灵触摸（M2.1：缩短，不吞首次有效输入） */
|
||
#define MEOW_BOOTMENU_VER "0.1.0-m2.29-takeover" /* M2.29：supervisor 接管关机(poweroff)/升级(reboot) */
|
||
|
||
/* ---- 版式 ---- */
|
||
#define STATUS_H 40
|
||
#define ROW_H 52
|
||
#define ENTRY0_Y 176
|
||
#define ENTRY1_Y 228
|
||
#define FOOTER_Y 700
|
||
#define BOOTMENU_OS_VER_FILE "/etc/meowos_version" /* 版本号单点：与 launcher 同源读 /etc/meowos_version */
|
||
#define BOOTMENU_OS_VER "dev" /* 兜底：文件缺失/读失败时用（与 launcher MEOWOS_VERSION=dev 对齐） */
|
||
|
||
/* 右下角显示的 MeowOS 版本：启动时读 /etc/meowos_version（与 launcher 同一数据源），
|
||
* 不再硬编码 0.7.x。读到的值存 g_boot_ver；缺失/读失败保留兜底默认。 */
|
||
static char g_boot_ver[32] = BOOTMENU_OS_VER;
|
||
static void load_boot_ver(void)
|
||
{
|
||
FILE *f = fopen(BOOTMENU_OS_VER_FILE, "r");
|
||
if (!f) return; /* 缺失：保留兜底 default */
|
||
char buf[32];
|
||
if (fgets(buf, sizeof buf, f)) {
|
||
char *e = buf + strlen(buf);
|
||
while (e > buf && (e[-1] == '\n' || e[-1] == '\r' || e[-1] == ' ')) e--;
|
||
*e = 0;
|
||
if (buf[0]) snprintf(g_boot_ver, sizeof g_boot_ver, "%s", buf);
|
||
}
|
||
fclose(f);
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* fb0 状态 */
|
||
/* ================================================================== */
|
||
static unsigned char *fb = NULL;
|
||
static int fb_fd = -1;
|
||
static int fb_xres = 480, fb_yres = 720, fb_line = 960, fb_bpp = 16;
|
||
static unsigned int fb_yres_virtual = 0;
|
||
static unsigned int fb_active_yoffset = 0;
|
||
static unsigned char *fb_snapshot = NULL; /* 进入选单前快照（恢复播放器帧用） */
|
||
static size_t fb_snapshot_len = 0;
|
||
static int fb_orig_yoffset = -1;
|
||
|
||
/* 触摸状态（选单/确认框/--dumpkeys 共用；M2.26 迁到 meow_touch 统一接口：
|
||
* goodix 时序免疫——BTN_TOUCH=1 不锁原点，等按下后首个有效 ABS 才锁，位移>=65 判滑动）。 */
|
||
static meow_touch mt_touch;
|
||
static int touch_fd = -1;
|
||
|
||
static inline void put_px(int x, int y, uint32_t color)
|
||
{
|
||
if (x < 0 || x >= fb_xres || y < 0 || y >= fb_yres) return;
|
||
unsigned char *p = fb + (size_t)y * fb_line + x * (fb_bpp / 8);
|
||
if (fb_bpp == 16) {
|
||
uint16_t c = ((color >> 8) & 0xF800) | ((color >> 5) & 0x07E0) |
|
||
((color >> 3) & 0x001F);
|
||
*(uint16_t *)p = c;
|
||
} else {
|
||
*(uint32_t *)p = (color << 8) | 0xFF;
|
||
}
|
||
}
|
||
|
||
static void fill_rect(int x0, int y0, int w, int h, uint32_t color)
|
||
{
|
||
for (int y = y0; y < y0 + h; y++)
|
||
for (int x = x0; x < x0 + w; x++)
|
||
put_px(x, y, color);
|
||
}
|
||
|
||
/* 5x7 点阵（与 meow_launcherd/hello 相同；仅 ASCII） */
|
||
static const unsigned char font[][8] = {
|
||
{0x0E,0x11,0x13,0x15,0x19,0x11,0x0E,0x00},
|
||
{0x04,0x0C,0x04,0x04,0x04,0x04,0x0E,0x00},
|
||
{0x0E,0x11,0x01,0x02,0x04,0x08,0x1F,0x00},
|
||
{0x1F,0x02,0x04,0x02,0x01,0x11,0x0E,0x00},
|
||
{0x02,0x06,0x0A,0x12,0x1F,0x02,0x02,0x00},
|
||
{0x1F,0x10,0x1E,0x01,0x01,0x11,0x0E,0x00},
|
||
{0x06,0x08,0x10,0x1E,0x11,0x11,0x0E,0x00},
|
||
{0x1F,0x01,0x02,0x04,0x08,0x08,0x08,0x00},
|
||
{0x0E,0x11,0x11,0x0E,0x11,0x11,0x0E,0x00},
|
||
{0x0E,0x11,0x11,0x0F,0x01,0x02,0x0C,0x00},
|
||
{0x0E,0x11,0x11,0x1F,0x11,0x11,0x11,0x00},
|
||
{0x1E,0x11,0x11,0x1E,0x11,0x11,0x1E,0x00},
|
||
{0x0E,0x11,0x10,0x10,0x10,0x11,0x0E,0x00},
|
||
{0x1C,0x12,0x11,0x11,0x11,0x12,0x1C,0x00},
|
||
{0x1F,0x10,0x10,0x1E,0x10,0x10,0x1F,0x00},
|
||
{0x1F,0x10,0x10,0x1E,0x10,0x10,0x10,0x00},
|
||
{0x0E,0x11,0x10,0x17,0x11,0x11,0x0F,0x00},
|
||
{0x11,0x11,0x11,0x1F,0x11,0x11,0x11,0x00},
|
||
{0x0E,0x04,0x04,0x04,0x04,0x04,0x0E,0x00},
|
||
{0x07,0x02,0x02,0x02,0x02,0x12,0x0C,0x00},
|
||
{0x11,0x12,0x14,0x18,0x14,0x12,0x11,0x00},
|
||
{0x10,0x10,0x10,0x10,0x10,0x10,0x1F,0x00},
|
||
{0x11,0x1B,0x15,0x15,0x11,0x11,0x11,0x00},
|
||
{0x11,0x19,0x15,0x13,0x11,0x11,0x11,0x00},
|
||
{0x0E,0x11,0x11,0x11,0x11,0x11,0x0E,0x00},
|
||
{0x1E,0x11,0x11,0x1E,0x10,0x10,0x10,0x00},
|
||
{0x0E,0x11,0x11,0x11,0x15,0x12,0x0D,0x00},
|
||
{0x1E,0x11,0x11,0x1E,0x14,0x12,0x11,0x00},
|
||
{0x0F,0x10,0x10,0x0E,0x01,0x01,0x1E,0x00},
|
||
{0x1F,0x04,0x04,0x04,0x04,0x04,0x04,0x00},
|
||
{0x11,0x11,0x11,0x11,0x11,0x11,0x0E,0x00},
|
||
{0x11,0x11,0x11,0x11,0x11,0x0A,0x04,0x00},
|
||
{0x11,0x11,0x11,0x15,0x15,0x1B,0x11,0x00},
|
||
{0x11,0x11,0x0A,0x04,0x0A,0x11,0x11,0x00},
|
||
{0x11,0x11,0x11,0x0A,0x04,0x04,0x04,0x00},
|
||
{0x1F,0x01,0x02,0x04,0x08,0x10,0x1F,0x00},
|
||
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
|
||
{0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00},
|
||
{0x04,0x04,0x04,0x04,0x04,0x00,0x04,0x00},
|
||
{0x00,0x00,0x00,0x1F,0x00,0x00,0x00,0x00},
|
||
{0x00,0x00,0x00,0x1F,0x00,0x00,0x00,0x00},
|
||
};
|
||
|
||
static int glyph_index(char c)
|
||
{
|
||
if (c >= '0' && c <= '9') return c - '0';
|
||
if (c >= 'A' && c <= 'Z') return 10 + (c - 'A');
|
||
if (c >= 'a' && c <= 'z') return 10 + (c - 'a');
|
||
if (c == ' ') return 36;
|
||
if (c == '.') return 37;
|
||
if (c == '!') return 38;
|
||
if (c == '-' || c == '_') return 39;
|
||
return 36;
|
||
}
|
||
|
||
static void draw_glyph(int x, int y, char c, int scale, uint32_t color)
|
||
{
|
||
const unsigned char *g = font[glyph_index(c)];
|
||
for (int row = 0; row < 7; row++) {
|
||
unsigned char bits = g[row];
|
||
for (int col = 0; col < 5; col++) {
|
||
if (bits & (0x10 >> col)) {
|
||
for (int dy = 0; dy < scale; dy++)
|
||
for (int dx = 0; dx < scale; dx++)
|
||
put_px(x + col * scale + dx, y + row * scale + dy, color);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
static void draw_text(int x, int y, const char *s, int scale, uint32_t color)
|
||
{
|
||
while (*s) {
|
||
draw_glyph(x, y, *s, scale, color);
|
||
x += 6 * scale;
|
||
s++;
|
||
}
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* fb0 初始化 / 双缓冲 pan（§18.18） */
|
||
/* ================================================================== */
|
||
static int fb_open(void)
|
||
{
|
||
int fd = open(FB_DEV, O_RDWR);
|
||
if (fd < 0) { fprintf(stderr, "fb open failed: %s\n", strerror(errno)); return -1; }
|
||
unsigned char vinfo[160], finfo[68];
|
||
memset(vinfo, 0, sizeof vinfo);
|
||
memset(finfo, 0, sizeof finfo);
|
||
if (ioctl(fd, FBIOGET_VSCREENINFO, vinfo) < 0 ||
|
||
ioctl(fd, FBIOGET_FSCREENINFO, finfo) < 0) {
|
||
fprintf(stderr, "fb ioctl failed\n");
|
||
close(fd); return -1;
|
||
}
|
||
fb_xres = *(uint32_t *)(vinfo + 0);
|
||
fb_yres = *(uint32_t *)(vinfo + 4);
|
||
fb_yres_virtual = *(uint32_t *)(vinfo + 12);
|
||
fb_active_yoffset = *(uint32_t *)(vinfo + 20);
|
||
fb_bpp = *(uint32_t *)(vinfo + 24);
|
||
fb_line = *(uint32_t *)(finfo + 44);
|
||
if (!fb_line) fb_line = fb_xres * (fb_bpp / 8);
|
||
if (fb_yres_virtual < fb_yres) fb_yres_virtual = fb_yres; /* 单缓冲兜底 */
|
||
fb = mmap(NULL, (size_t)fb_line * fb_yres_virtual,
|
||
PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
||
if (fb == MAP_FAILED) {
|
||
fprintf(stderr, "fb mmap failed: %s\n", strerror(errno));
|
||
close(fd); return -1;
|
||
}
|
||
fb_fd = fd;
|
||
fprintf(stderr, "fb: %dx%d bpp=%d line=%d vres=%u yoffset=%u\n",
|
||
fb_xres, fb_yres, fb_bpp, fb_line, fb_yres_virtual, fb_active_yoffset);
|
||
return 0;
|
||
}
|
||
|
||
/* 选单进入前快照「当前显示缓冲」一帧（播放器事件驱动不主动重绘，须恢复） */
|
||
static void fb_snapshot_player(void)
|
||
{
|
||
if (fb_yres_virtual <= fb_yres) { fb_orig_yoffset = -1; return; }
|
||
if (fb_active_yoffset >= fb_yres_virtual) fb_active_yoffset = 0;
|
||
fb_orig_yoffset = (int)fb_active_yoffset;
|
||
fb_snapshot_len = (size_t)fb_line * fb_yres;
|
||
fb_snapshot = malloc(fb_snapshot_len);
|
||
if (!fb_snapshot) { fb_orig_yoffset = -1; fb_snapshot_len = 0; return; }
|
||
memcpy(fb_snapshot, fb + (size_t)fb_active_yoffset * fb_line, fb_snapshot_len);
|
||
}
|
||
|
||
/* 画前 FBIOPAN_DISPLAY pan 到 yoffset=0（buffer0，选单/app 共同绘制目标） */
|
||
static void fb_pan_buf0(void)
|
||
{
|
||
if (fb_fd < 0 || fb_yres_virtual <= fb_yres) { fb_active_yoffset = 0; return; }
|
||
if (fb_active_yoffset == 0) return; /* 已显示 buffer0 */
|
||
unsigned char v[160];
|
||
memset(v, 0, sizeof v);
|
||
if (ioctl(fb_fd, FBIOGET_VSCREENINFO, v) < 0) return;
|
||
*(uint32_t *)(v + 16) = 0; /* xoffset */
|
||
*(uint32_t *)(v + 20) = 0; /* yoffset -> buffer0 */
|
||
ioctl(fb_fd, FBIOPAN_DISPLAY, v);
|
||
fb_active_yoffset = 0;
|
||
}
|
||
|
||
/* 选单退出：把快照拷回原缓冲并 pan 回原 yoffset（播放器帧保持不动） */
|
||
static void fb_restore_player_frame(void)
|
||
{
|
||
int restore_y = fb_orig_yoffset;
|
||
if (fb_fd >= 0 && restore_y >= 0 && fb_snapshot) {
|
||
memcpy(fb + (size_t)restore_y * fb_line, fb_snapshot, fb_snapshot_len);
|
||
unsigned char v[160];
|
||
memset(v, 0, sizeof v);
|
||
if (ioctl(fb_fd, FBIOGET_VSCREENINFO, v) == 0) {
|
||
*(uint32_t *)(v + 16) = 0;
|
||
*(uint32_t *)(v + 20) = (uint32_t)restore_y;
|
||
ioctl(fb_fd, FBIOPAN_DISPLAY, v);
|
||
}
|
||
fprintf(stderr, "bootmenu: fb restore -> yoffset=%d\n", restore_y);
|
||
}
|
||
if (fb_snapshot) { free(fb_snapshot); fb_snapshot = NULL; }
|
||
fb_orig_yoffset = -1;
|
||
fb_snapshot_len = 0;
|
||
}
|
||
|
||
static void fb_close(void)
|
||
{
|
||
if (fb && fb != MAP_FAILED)
|
||
munmap(fb, (size_t)fb_line * fb_yres_virtual);
|
||
if (fb_fd >= 0) close(fb_fd);
|
||
fb = NULL; fb_fd = -1;
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* 状态栏数据源（与 meow_launcherd 相同：电量/WIFI/BT/音量） */
|
||
/* ================================================================== */
|
||
static int read_file_int(const char *path)
|
||
{
|
||
int fd = open(path, O_RDONLY);
|
||
if (fd < 0) return -1;
|
||
char buf[16];
|
||
int n = read(fd, buf, sizeof buf - 1);
|
||
close(fd);
|
||
if (n <= 0) return -1;
|
||
buf[n] = 0;
|
||
return atoi(buf);
|
||
}
|
||
|
||
static int bluetooth_present(void)
|
||
{
|
||
return access("/sys/class/bluetooth/hci0", F_OK) == 0;
|
||
}
|
||
|
||
/* 音量：CS43198 ALSA control（实测死镜像，可能恒 0%，见 §18.13） */
|
||
static int amixer_vol(int numid)
|
||
{
|
||
char cmd[96];
|
||
snprintf(cmd, sizeof cmd, "amixer -c 0 cget numid=%d 2>/dev/null", numid);
|
||
FILE *p = popen(cmd, "r");
|
||
if (!p) return -1;
|
||
char buf[128];
|
||
int v = -1;
|
||
while (fgets(buf, sizeof buf, p)) {
|
||
char *s = strstr(buf, ": values=");
|
||
if (s) { v = atoi(s + 9); break; }
|
||
}
|
||
pclose(p);
|
||
return v;
|
||
}
|
||
|
||
/* 28px 状态栏：行1=时钟(左) 电量% WIFI BT(右)，行2=VOL nn%(左)，y=28 分隔线（40→28，用户定） */
|
||
static void draw_statusbar(uint32_t bg)
|
||
{
|
||
char timebuf[16], right[48];
|
||
time_t now = time(NULL);
|
||
struct tm tm;
|
||
localtime_r(&now, &tm);
|
||
snprintf(timebuf, sizeof timebuf, "%02d:%02d:%02d",
|
||
tm.tm_hour, tm.tm_min, tm.tm_sec);
|
||
right[0] = 0;
|
||
|
||
char batt[8] = "";
|
||
int b = read_file_int("/sys/class/power_supply/battery/capacity");
|
||
if (b >= 0) snprintf(batt, sizeof batt, "%d%%", b);
|
||
|
||
char wifi[8] = "";
|
||
int wf = open("/sys/class/net/wlan0/operstate", O_RDONLY);
|
||
if (wf >= 0) {
|
||
char x[8];
|
||
int n = read(wf, x, sizeof x - 1);
|
||
close(wf);
|
||
if (n > 0) { x[n] = 0; if (!strncmp(x, "up", 2)) snprintf(wifi, sizeof wifi, "WIFI"); }
|
||
}
|
||
|
||
char vol[16] = "";
|
||
int v = amixer_vol(1);
|
||
if (v >= 0) snprintf(vol, sizeof vol, "VOL %d%%", v * 100 / 255);
|
||
|
||
char bt[8] = "";
|
||
if (bluetooth_present()) snprintf(bt, sizeof bt, "BT");
|
||
|
||
draw_text(8, 2, timebuf, 1, 0x9FB8D9);
|
||
if (batt[0]) strcat(right, batt);
|
||
if (wifi[0]) { if (right[0]) strcat(right, " "); strcat(right, wifi); }
|
||
if (bt[0]) { if (right[0]) strcat(right, " "); strcat(right, bt); }
|
||
if (right[0]) {
|
||
int rx = fb_xres - 8 - (int)strlen(right) * 6;
|
||
draw_text(rx, 2, right, 1, 0x9FB8D9);
|
||
}
|
||
if (vol[0]) draw_text(8, 14, vol, 1, 0x9FB8D9);
|
||
fill_rect(0, 28, fb_xres, 1, 0x333355); /* 分隔线（移至 y=28） */
|
||
}
|
||
|
||
/* 只刷时钟数字（每秒一次，不弹 amixer/不碰菜单体） */
|
||
static void draw_clock(uint32_t bg)
|
||
{
|
||
char timebuf[16];
|
||
time_t now = time(NULL);
|
||
struct tm tm;
|
||
localtime_r(&now, &tm);
|
||
snprintf(timebuf, sizeof timebuf, "%02d:%02d:%02d",
|
||
tm.tm_hour, tm.tm_min, tm.tm_sec);
|
||
int w = (int)strlen(timebuf) * 6;
|
||
fill_rect(4, 0, 8 + w, 12, bg);
|
||
draw_text(8, 2, timebuf, 1, 0x9FB8D9);
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* 配置：boot_default / boot_timeout_ms / boot_menu / bg_color */
|
||
/* boot_default：权威 = 板载 /data/meow_boot_default（O_TRUNC 单值、不写 TF 卡）；
|
||
* meow.conf 的 boot_default= 仅作无板载标记时的兜底（不新增写入，见 set_boot_default_meow）。 */
|
||
/* ================================================================== */
|
||
static int cfg_boot_default = DEF_BOOT_DEFAULT;
|
||
static long cfg_boot_timeout_ms = DEF_BOOT_TIMEOUT_MS;
|
||
static int cfg_boot_menu = DEF_BOOT_MENU;
|
||
static uint32_t cfg_bg = DEF_BG;
|
||
|
||
/* 读板载 /data/meow_boot_default（开机默认权威标记）。返回 0/1；-1=不存在/非法。 */
|
||
static int read_boot_default_onboard(void)
|
||
{
|
||
int fd = open("/data/meow_boot_default", O_RDONLY);
|
||
if (fd < 0) return -1;
|
||
char buf[8];
|
||
int n = read(fd, buf, sizeof buf - 1);
|
||
close(fd);
|
||
if (n <= 0) return -1;
|
||
buf[n] = 0;
|
||
int v = atoi(buf);
|
||
return (v == 0 || v == 1) ? v : -1;
|
||
}
|
||
|
||
static void load_config(void)
|
||
{
|
||
cfg_boot_default = DEF_BOOT_DEFAULT;
|
||
cfg_boot_timeout_ms = DEF_BOOT_TIMEOUT_MS;
|
||
cfg_boot_menu = DEF_BOOT_MENU;
|
||
cfg_bg = DEF_BG;
|
||
int has_conf = 1;
|
||
FILE *f = fopen(CONF_FILE, "r");
|
||
if (!f) { fprintf(stderr, "bootmenu: no %s, using defaults\n", CONF_FILE); has_conf = 0; }
|
||
if (has_conf) {
|
||
char buf[128];
|
||
while (fgets(buf, sizeof buf, f)) {
|
||
if (!strncmp(buf, "boot_default=", 13)) {
|
||
/* 板载 /data/meow_boot_default 为权威；此处仅作无板载标记时的兜底（不再新增写入）。 */
|
||
cfg_boot_default = atoi(buf + 13);
|
||
if (cfg_boot_default != 0 && cfg_boot_default != 1) cfg_boot_default = DEF_BOOT_DEFAULT;
|
||
} else if (!strncmp(buf, "boot_timeout_ms=", 16)) {
|
||
long t = atol(buf + 16);
|
||
if (t >= 500 && t <= 60000) cfg_boot_timeout_ms = t;
|
||
} else if (!strncmp(buf, "boot_menu=", 10)) {
|
||
int m = atoi(buf + 10);
|
||
if (m == 0 || m == 1) cfg_boot_menu = m;
|
||
} else if (!strncmp(buf, "bg_color=", 9)) {
|
||
unsigned int v;
|
||
if (sscanf(buf + 9, "%x", &v) == 1) cfg_bg = v & 0xFFFFFF;
|
||
}
|
||
}
|
||
fclose(f);
|
||
}
|
||
/* 板载标记优先（权威）：覆盖 meow.conf 兜底/编译默认。 */
|
||
int ob = read_boot_default_onboard();
|
||
if (ob == 0 || ob == 1) {
|
||
if (ob != cfg_boot_default)
|
||
fprintf(stderr, "bootmenu: boot_default onboard=%d (override %d)\n", ob, cfg_boot_default);
|
||
cfg_boot_default = ob;
|
||
}
|
||
fprintf(stderr, "bootmenu: cfg boot_default=%d timeout_ms=%ld boot_menu=%d bg=%06x\n",
|
||
cfg_boot_default, cfg_boot_timeout_ms, cfg_boot_menu, cfg_bg);
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* 时钟（单调，强收敛） */
|
||
/* ================================================================== */
|
||
static unsigned long long now_ms(void)
|
||
{
|
||
struct timespec ts;
|
||
clock_gettime(CLOCK_MONOTONIC, &ts);
|
||
return (unsigned long long)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* TF 卡日志（bm_log）——诊断留存：supervisor 收到/发出信号、播放器退出原因。
|
||
* - 借鉴 launcher log_open_card/logmsg 思路，但**不共享 /tmp/meow_bootts**
|
||
* （launcher 缓存的是完整基名 meow_<ts>，直接复读会拼成 meow_boot_meow_…）；
|
||
* 每次自行按 /proc/uptime 推开机时间戳，同一 boot 内文件名恒定。
|
||
* - 写 /usr/data/mnt/sd_0/MeowOS/logs/meow_boot_<bootts>.log（O_APPEND|O_CREAT 0644）。
|
||
* - 卡不可用（未挂载/不可写）→ 降级 stderr。**只记录，不改任何行为。**
|
||
* ================================================================== */
|
||
#define BM_LOG_DIR "/usr/data/mnt/sd_0/MeowOS/logs"
|
||
static int bm_log_fd = -1;
|
||
static char bm_log_file[256] = "";
|
||
|
||
static void bm_boot_ts(char *out, size_t n)
|
||
{
|
||
time_t now = time(NULL), up = 0;
|
||
int fd = open("/proc/uptime", O_RDONLY);
|
||
if (fd >= 0) {
|
||
char buf[64];
|
||
int r = read(fd, buf, sizeof buf - 1);
|
||
close(fd);
|
||
if (r > 0) {
|
||
buf[r] = 0;
|
||
char *p = strchr(buf, ' ');
|
||
if (p) *p = 0;
|
||
up = (time_t)atof(buf);
|
||
}
|
||
}
|
||
time_t boot = (time_t)((double)now - (double)up + 0.5);
|
||
struct tm tm;
|
||
localtime_r(&boot, &tm);
|
||
strftime(out, n, "%Y%m%d_%H%M%S", &tm);
|
||
}
|
||
|
||
static void bm_log_open(void)
|
||
{
|
||
if (bm_log_fd >= 0) return;
|
||
mkdir(BM_LOG_DIR, 0755);
|
||
char ts[64];
|
||
bm_boot_ts(ts, sizeof ts);
|
||
snprintf(bm_log_file, sizeof bm_log_file, "%s/meow_boot_%s.log", BM_LOG_DIR, ts);
|
||
bm_log_fd = open(bm_log_file, O_WRONLY | O_APPEND | O_CREAT, 0644);
|
||
if (bm_log_fd < 0) bm_log_file[0] = 0; /* 卡不可用 → 降级 stderr */
|
||
}
|
||
|
||
/* 带时间戳写 TF 卡日志；卡不可用则降级 stderr。仅记录，不改行为。 */
|
||
static void bm_log(const char *fmt, ...)
|
||
{
|
||
char buf[512];
|
||
va_list ap;
|
||
va_start(ap, fmt);
|
||
vsnprintf(buf, sizeof buf, fmt, ap);
|
||
va_end(ap);
|
||
char line[576];
|
||
int l = snprintf(line, sizeof line, "%llu %s\n", now_ms(), buf);
|
||
if (bm_log_fd < 0) bm_log_open();
|
||
if (bm_log_fd >= 0) {
|
||
if (write(bm_log_fd, line, l) < 0) bm_log_fd = -1; /* 卡拔出 → 回退 stderr */
|
||
}
|
||
fprintf(stderr, "%llu %s\n", now_ms(), buf);
|
||
}
|
||
|
||
/* ---- supervisor 信号记录（只记录，不改行为）----
|
||
* 注册 SIGTERM/SIGINT/SIGQUIT/SIGHUP，handler 只置标志；主循环顶部先 bm_log
|
||
* 「收到信号 N」，再 signal(s, SIG_DFL) + raise(s) 重抛——**恢复默认动作**，
|
||
* 使 supervisor 仍按今日方式终止（不转发、不善后、不截断，与未加 hook 一致）。 */
|
||
static volatile sig_atomic_t bm_sig_flag[64];
|
||
|
||
static const char *bm_sig_name(int sig)
|
||
{
|
||
switch (sig) {
|
||
case SIGTERM: return "SIGTERM";
|
||
case SIGKILL: return "SIGKILL";
|
||
case SIGSTOP: return "SIGSTOP";
|
||
case SIGCONT: return "SIGCONT";
|
||
case SIGINT: return "SIGINT";
|
||
case SIGQUIT: return "SIGQUIT";
|
||
case SIGHUP: return "SIGHUP";
|
||
default: return "?";
|
||
}
|
||
}
|
||
|
||
static void bm_sig_catch(int sig)
|
||
{
|
||
if (sig > 0 && sig < 64) bm_sig_flag[sig] = 1;
|
||
}
|
||
|
||
static void bm_sig_install(void)
|
||
{
|
||
signal(SIGTERM, bm_sig_catch);
|
||
signal(SIGINT, bm_sig_catch);
|
||
signal(SIGQUIT, bm_sig_catch);
|
||
signal(SIGHUP, bm_sig_catch);
|
||
}
|
||
|
||
/* 主循环顶部调用：记录已收到的信号，并恢复默认动作重抛（保行为不变）。 */
|
||
static void bm_sig_poll(void)
|
||
{
|
||
for (int s = 1; s < 64; s++) {
|
||
if (bm_sig_flag[s]) {
|
||
bm_sig_flag[s] = 0;
|
||
bm_log("supervisor: received signal %d (%s)", s, bm_sig_name(s));
|
||
signal(s, SIG_DFL); /* 恢复默认动作（== 未加 hook 时） */
|
||
raise(s); /* 重抛：已登记即按原方式终止 */
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* ---- M2.29 supervisor 接管：直连 reboot(2) syscall + mtd5(ota) 侦测 ----
|
||
* 借鉴 meow_launcherd sys_do_reboot（BusyBox reboot 非 PID1 不完成握手，故直接 syscall）。
|
||
* sync() 落盘后调用 reboot(2)，内核立即重启/关机；正常不返回，防御性死循环。 */
|
||
#define LINUX_REBOOT_MAGIC1 0xfee1dead
|
||
#define LINUX_REBOOT_MAGIC2 672274793 /* 0x28121969 */
|
||
#define LINUX_REBOOT_CMD_RESTART 0x01234567
|
||
#define LINUX_REBOOT_CMD_POWER_OFF 0x4321fedc
|
||
static void bm_do_reboot(int cmd)
|
||
{
|
||
sync();
|
||
bm_log("supervisor: bm_do_reboot cmd=0x%x", cmd);
|
||
syscall(SYS_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, NULL);
|
||
bm_log("supervisor: bm_do_reboot returned: %s", strerror(errno));
|
||
for (;;) usleep(1000); /* 防御：永不返回 */
|
||
}
|
||
|
||
/* mtd5 是 ota 标记分区（8M）。bootmode.sh Recovery 用 nandwrite 在 offset 0 写 256B
|
||
* 定长标记。这里每 500ms 读一次 mtd5 头 ~15B（单页一小读，IO 极低），命中
|
||
* "ota:kernel2" 即判「播放器触发升级」。open/close 每次都关，避免长期占 mtd 设备。 */
|
||
#define MTD_OTA "/dev/mtd5"
|
||
static int mtd_ota_is_upgrade(void)
|
||
{
|
||
int fd = open(MTD_OTA, O_RDONLY);
|
||
if (fd < 0) return 0; /* 读不到 → 无升级迹象 */
|
||
char buf[16];
|
||
memset(buf, 0, sizeof buf);
|
||
ssize_t n = read(fd, buf, sizeof buf - 1);
|
||
close(fd);
|
||
if (n <= 0) return 0;
|
||
return strstr(buf, "ota:kernel2") != NULL;
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* 按键状态轮询（EVIOCGKEY） */
|
||
/* ================================================================== */
|
||
struct keypoll {
|
||
int fd;
|
||
unsigned long cur[KEYBUF_WORDS];
|
||
unsigned long prev[KEYBUF_WORDS];
|
||
int ok;
|
||
};
|
||
|
||
static int kp_open(struct keypoll *kp, const char *dev)
|
||
{
|
||
memset(kp, 0, sizeof *kp);
|
||
kp->fd = open(dev, O_RDONLY | O_NONBLOCK);
|
||
if (kp->fd < 0) { fprintf(stderr, "open %s: %s\n", dev, strerror(errno)); return -1; }
|
||
if (ioctl(kp->fd, EVIOCGKEY(sizeof kp->cur), kp->cur) < 0) {
|
||
fprintf(stderr, "EVIOCGKEY %s: %s\n", dev, strerror(errno));
|
||
close(kp->fd); return -1;
|
||
}
|
||
memcpy(kp->prev, kp->cur, sizeof kp->cur);
|
||
kp->ok = 1;
|
||
return 0;
|
||
}
|
||
|
||
/* 轮询设备键状态；对每个「按下边沿/抬起边沿」调 cb(code, down, ctx)。
|
||
* 返回是否有边沿。 */
|
||
static int kp_poll(struct keypoll *kp, int (*cb)(int code, int down, void *ctx),
|
||
void *ctx)
|
||
{
|
||
if (!kp->ok) return 0;
|
||
if (ioctl(kp->fd, EVIOCGKEY(sizeof kp->cur), kp->cur) < 0) return 0;
|
||
int changed = 0;
|
||
for (int w = 0; w < KEYBUF_WORDS; w++) {
|
||
if (kp->cur[w] == kp->prev[w]) continue;
|
||
for (int b = 0; b < 32; b++) {
|
||
int c = (kp->cur[w] >> b) & 1;
|
||
int p = (kp->prev[w] >> b) & 1;
|
||
if (c != p) {
|
||
int code = w * 32 + b;
|
||
changed = 1;
|
||
if (cb) cb(code, c, ctx);
|
||
}
|
||
}
|
||
kp->prev[w] = kp->cur[w];
|
||
}
|
||
return changed;
|
||
}
|
||
|
||
static int kp_is_down(const struct keypoll *k, int code)
|
||
{
|
||
return (k->cur[code / 32] >> (code % 32)) & 1;
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* 选单绘制 */
|
||
/* ================================================================== */
|
||
static void draw_countdown(uint32_t bg, long remaining_ms)
|
||
{
|
||
/* 右侧倒计时 'AUTO N S'（scale2） */
|
||
int sec = (int)((remaining_ms + 999) / 1000);
|
||
char s[16];
|
||
snprintf(s, sizeof s, "AUTO %dS", sec);
|
||
int w = (int)strlen(s) * 12; /* scale2 = 12px/字 */
|
||
int x = fb_xres - 8 - w;
|
||
/* 清一下原区域（含右边距）再画 */
|
||
fill_rect(x - 4, 92, w + 12, 16, bg);
|
||
draw_text(x, 94, s, 2, 0xFFE066);
|
||
}
|
||
|
||
static void draw_entry(int y, const char *label, int selected)
|
||
{
|
||
if (selected) {
|
||
fill_rect(8, y - 4, fb_xres - 16, ROW_H - 8, 0x2A3A6A);
|
||
draw_text(24, y, label, 2, 0xFFFFFF);
|
||
} else {
|
||
draw_text(24, y, label, 2, 0xC8D0E8);
|
||
}
|
||
}
|
||
|
||
static void draw_menu(int cursor, long remaining_ms)
|
||
{
|
||
fill_rect(0, 0, fb_xres, fb_yres, cfg_bg);
|
||
|
||
/* 状态栏 + 标题 + 分隔线 */
|
||
draw_statusbar(cfg_bg);
|
||
draw_text(20, 64, "MEOWOS", 3, 0xFFE066);
|
||
draw_text(22, 96, "BOOT SELECTOR", 2, 0x9FB8D9);
|
||
fill_rect(0, 122, fb_xres, 2, 0x3A3A5C);
|
||
|
||
/* 两个入口 */
|
||
draw_entry(ENTRY0_Y, "[HIBYOS PLAYER]", cursor == 0);
|
||
draw_entry(ENTRY1_Y, "[MEOWOS HOME]", cursor == 1);
|
||
|
||
/* 右侧倒计时 */
|
||
draw_countdown(cfg_bg, remaining_ms);
|
||
|
||
/* 底部按键提示 */
|
||
draw_text(20, FOOTER_Y,
|
||
"VOLUP UP VOLDN DOWN PLAY OK POWER OK", 1, 0x666688);
|
||
/* 右下角开发版本 */
|
||
{
|
||
char ver[40];
|
||
snprintf(ver, sizeof ver, "MeowOS v%s boot", g_boot_ver);
|
||
draw_text(fb_xres - 8 - (int)strlen(ver) * 6, FOOTER_Y, ver, 1, 0x666688);
|
||
}
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* 面板/背光 helper（复用 meow_launcherd 语义，§18.21.5 / §红线） */
|
||
/* ================================================================== */
|
||
static int read_brightness(void)
|
||
{
|
||
int fd = open(BACKLIGHT, O_RDONLY);
|
||
if (fd < 0) return -1;
|
||
char buf[16];
|
||
int n = read(fd, buf, sizeof buf - 1);
|
||
close(fd);
|
||
if (n <= 0) return -1;
|
||
buf[n] = 0;
|
||
return atoi(buf);
|
||
}
|
||
|
||
static void write_file_str(const char *path, const char *val)
|
||
{
|
||
int fd = open(path, O_WRONLY);
|
||
if (fd < 0) return;
|
||
if (write(fd, val, strlen(val)) < 0)
|
||
fprintf(stderr, "bootmenu: write %s <- %s: %s\n", path, val, strerror(errno));
|
||
close(fd);
|
||
}
|
||
|
||
static void write_brightness(int val)
|
||
{
|
||
char buf[8];
|
||
int l = snprintf(buf, sizeof buf, "%d\n", val);
|
||
int fd = open(BACKLIGHT, O_WRONLY);
|
||
if (fd < 0) { fprintf(stderr, "bootmenu: backlight open fail: %s\n", strerror(errno)); return; }
|
||
if (write(fd, buf, l) < 0) fprintf(stderr, "bootmenu: backlight write %d: %s\n", val, strerror(errno));
|
||
close(fd);
|
||
}
|
||
|
||
/* 面板 unblank（FBIOBLANK 0）。仅用于杀播放器后把屏点亮，以便 MeowOS 接管；
|
||
* 播放器已死，故不涉及「播放器 state machine」一致性（§18.11 关注点）。
|
||
* bootmenu 选单/自检阶段绝不调用本函数（§18.24 纪律：不碰 panel blank）。 */
|
||
static void unblank_panel(void)
|
||
{
|
||
int fbfd = open(FB_DEV, O_RDWR);
|
||
if (fbfd >= 0) { ioctl(fbfd, FBIOBLANK, 0); close(fbfd); }
|
||
fprintf(stderr, "bootmenu: panel unblanked\n");
|
||
}
|
||
|
||
/* 读取 /proc/<pid>/stat 状态字符（'S'/'T'/'D'...），失败返回 '\0'。 */
|
||
static char proc_state(int pid)
|
||
{
|
||
char path[64], line[512];
|
||
snprintf(path, sizeof path, "/proc/%d/stat", pid);
|
||
int fd = open(path, O_RDONLY);
|
||
if (fd < 0) return '\0';
|
||
ssize_t n = read(fd, line, sizeof line - 1);
|
||
close(fd);
|
||
if (n <= 0) return '\0';
|
||
line[n] = 0;
|
||
char *p = strrchr(line, ')');
|
||
if (!p || p + 2 >= line + n) return '\0';
|
||
return p[2];
|
||
}
|
||
|
||
/* 读取 /proc/<pid>/stat 状态是否为 T（stopped）。T 态 SIGTERM 不投递，
|
||
* 须先 SIGCONT（§18.21.3）。 */
|
||
static int proc_is_stopped(int pid)
|
||
{
|
||
return proc_state(pid) == 'T';
|
||
}
|
||
|
||
/* 播放器忙判门（§18.23）：D（不可中断 IO = 开机媒体库扫描）视为忙。
|
||
* 忙期热键暂不触发，避免扫描期 SIGSTOP 冻结拉长卡顿。 */
|
||
static int proc_is_busy(int pid)
|
||
{
|
||
return proc_state(pid) == BUSY_STATE_CHAR;
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* 播放器 fork 契约（顺序：先 munmap+close fb0，再 fork） */
|
||
/* ⚠️ M0 记号：完整契约已按 BOOT_SELECTOR_DESIGN.md §3.6 实现，但仅在 */
|
||
/* 显式 --fork 时执行。M0 自检不传 --fork，故绝不 fork 正在运行的 */
|
||
/* hiby_player。M2 接管 HibyOS 时由 S90meow_bootmenu 传 --fork 开启。 */
|
||
/* ================================================================== */
|
||
extern char **environ;
|
||
|
||
static void write_mode(int choice); /* 定义在下方；supervisor 使用 */
|
||
static void bootmenu_supervisor(int player_pid); /* 定义在下方；fork 函数调用 */
|
||
|
||
/* ---- 真机 verif sim 钩子（M2）：--sim-hotkey N / --sim-confirm Y|N ---- */
|
||
static long sim_hotkey_ms = 0; /* supervisor 启动后 N ms 模拟热键（电源按住+音量减） */
|
||
static int sim_confirm = 0; /* confirm 框打开后 2s 自动回答：'Y'=是 'N'=否 */
|
||
static int sim_confirm_done = 0;
|
||
static int sim_hk_done = 0;
|
||
static int sim_hotkey_strict = 0; /* M2.14：--sim-hotkey-strict = 让 sim 热键走武装延迟/忙判门（测 pending） */
|
||
|
||
static void fork_hiby_player(void)
|
||
{
|
||
pid_t pid = fork();
|
||
if (pid < 0) { fprintf(stderr, "fork player failed: %s\n", strerror(errno)); return; }
|
||
if (pid == 0) {
|
||
/* child：完全复刻 init 拉起时的环境（§18.21.5 最小启动契约） */
|
||
chdir("/"); /* 必须：播放器有相对路径读（充电态等） */
|
||
clearenv();
|
||
setenv("USER", "root", 1);
|
||
setenv("SHLVL", "3", 1);
|
||
setenv("HOME", "/", 1);
|
||
setenv("PS1", "#", 1);
|
||
setenv("TERM", "vt102", 1);
|
||
setenv("PATH", "/bin:/sbin:/usr/bin:/usr/sbin", 1);
|
||
setenv("env_adb_device_name_prefix", "ingenic", 1);
|
||
setenv("env_adb_device_use_diffrent_name", "y", 1);
|
||
setenv("SHELL", "/bin/sh", 1);
|
||
setenv("PWD", "/", 1);
|
||
setenv("EDITOR", "/bin/vi", 1);
|
||
/* 无 LD_LIBRARY_PATH / 无 TZ（与开机一致） */
|
||
int dn = open("/dev/null", O_RDONLY);
|
||
if (dn >= 0) { dup2(dn, 0); close(dn); }
|
||
int lf = open(PLAYER_LOG, O_WRONLY | O_CREAT | O_APPEND, 0644);
|
||
if (lf >= 0) { dup2(lf, 1); dup2(lf, 2); close(lf); }
|
||
execve(PLAYER_BIN, (char *[]){ "hiby_player", NULL }, environ);
|
||
_exit(127);
|
||
}
|
||
/* parent（M2）：退居监督者/热键守护——poll(10ms) 检测热键（按住电源 +
|
||
* 窗口 60-2500ms 内单击音量减）→ SIGTERM 播放器 → 3s 未退 SIGKILL
|
||
* （T 态先 SIGCONT）→ waitpid 收割 → unblank+亮度恢复 → 写
|
||
* /tmp/meow_boot_mode=meow → exec meow_launcherd（MeowOS 基础主屏）。
|
||
* 播放器异常退出（waitpid WNOHANG）→ 记日志，阶段 0 不自动重启（HGL）。
|
||
* 本函数在父进程永不返回（阻塞 rcS 直到整机重启或热键切换）。 */
|
||
bootmenu_supervisor(pid);
|
||
/* fork 失败已在上面 return；此处不可达（supervisor 永不返回），
|
||
* 仅防御：若 supervisor 异常返回则让 rcS 推进（S92 兜底）。 */
|
||
return;
|
||
}
|
||
|
||
/* ---- 热键确认框（M2 用户定案：热键后先确认，是才杀播放器）---- */
|
||
#define CONF_DEFAULT_CURSOR 1 /* 默认 NO（更安全：不误杀） */
|
||
#define CONF_COOLDOWN_MS 800 /* 防 goodix 幽灵触摸（§18.16）；M2.1 缩短，不吞首次有效输入 */
|
||
#define CONF_ROW0_Y 280
|
||
#define CONF_ROW1_Y 330
|
||
#define CONF_ROW_H 44
|
||
#define CONF_ROW_LEFT 60
|
||
#define CONF_ROW_RIGHT (fb_xres - 60)
|
||
|
||
/* 简单绘制：压暗底 + 外框 + 标题 + [YES][NO] + 按键提示。
|
||
* 字体仅 ASCII（无 CJK），故用 ENTER MEOWOS? / STOP HIBYOS PLAYER。 */
|
||
static void draw_confirm_box(int cursor)
|
||
{
|
||
fill_rect(0, 0, fb_xres, fb_yres, 0x0D0D14); /* 压暗背景 */
|
||
fill_rect(36, 180, fb_xres - 72, 230, 0x3A3A5C); /* 外框 */
|
||
fill_rect(40, 184, fb_xres - 80, 222, 0x1A1A2A); /* 内底 */
|
||
draw_text(56, 200, "STOP HIBYOS PLAYER", 2, 0xFFE066);
|
||
draw_text(56, 232, "AND ENTER MEOWOS?", 2, 0x9FB8D9);
|
||
/* YES / NO 两行 */
|
||
if (cursor == 0) {
|
||
fill_rect(CONF_ROW_LEFT, CONF_ROW0_Y, CONF_ROW_RIGHT - CONF_ROW_LEFT, CONF_ROW_H, 0x2A3A6A);
|
||
draw_text(CONF_ROW_LEFT + 30, CONF_ROW0_Y + 12, "YES", 2, 0xFFFFFF);
|
||
} else {
|
||
draw_text(CONF_ROW_LEFT + 30, CONF_ROW0_Y + 12, "YES", 2, 0x667088);
|
||
}
|
||
if (cursor == 1) {
|
||
fill_rect(CONF_ROW_LEFT, CONF_ROW1_Y, CONF_ROW_RIGHT - CONF_ROW_LEFT, CONF_ROW_H, 0x2A3A6A);
|
||
draw_text(CONF_ROW_LEFT + 30, CONF_ROW1_Y + 12, "NO", 2, 0xFFFFFF);
|
||
} else {
|
||
draw_text(CONF_ROW_LEFT + 30, CONF_ROW1_Y + 12, "NO", 2, 0x667088);
|
||
}
|
||
draw_text(56, CONF_ROW1_Y + CONF_ROW_H + 20,
|
||
"VOL^V NAV PLAY OK POWER EXIT", 1, 0x666688);
|
||
}
|
||
|
||
/* 弹确认框并等待选择。返回 0=否(留下) 1=是(杀播放器) -1=无法绘制/异常。
|
||
* 调用方负责：先 SIGSTOP 播放器（防其重绘覆盖）+ unblank/亮度点亮面板；
|
||
* 返回后调用方按结果处理面板/播放器。本函数只负责 fb0 叠框 + 输入。 */
|
||
static int confirm_switch(void)
|
||
{
|
||
if (fb_open() != 0) { fprintf(stderr, "confirm: fb open failed -> default NO\n"); return -1; }
|
||
fb_snapshot_player();
|
||
fb_pan_buf0();
|
||
|
||
/* touch drain + 短暂冷却（防 goodix 幽灵触摸；M2.1 缩短到 800ms 不吞首次有效输入） */
|
||
int tfd = open(DEV_TOUCH, O_RDONLY | O_NONBLOCK);
|
||
if (tfd >= 0) {
|
||
unsigned char ev[16];
|
||
while (read(tfd, ev, sizeof ev) == (ssize_t)sizeof ev) { /* discard */ }
|
||
}
|
||
unsigned long long cooldown_until = now_ms() + CONF_COOLDOWN_MS;
|
||
mt_reset(&mt_touch); /* 清触摸手势态（down/valid/origin/last），避免上次残留误派发 */
|
||
|
||
struct keypoll kp_keys, kp_power;
|
||
if (kp_open(&kp_keys, DEV_KEYS) != 0) fprintf(stderr, "confirm: WARN no keys dev\n");
|
||
if (kp_open(&kp_power, DEV_POWER) != 0) fprintf(stderr, "confirm: WARN no power dev\n");
|
||
|
||
int cursor = CONF_DEFAULT_CURSOR;
|
||
int prev_vold = 0, prev_volu = 0, prev_play = 0, prev_pwr = 0;
|
||
|
||
/* 键基线：把「当前已按住的键」写进 prev，避免热键残留的电源按住被误判为
|
||
* 新的下沿而立即取消（电源仍按住，kp.poll 的 prev 已同步，但本地 prev_pwr
|
||
* 未同步——launcher run_menu 同款处理，§18.17）。 */
|
||
if (kp_keys.ok) {
|
||
kp_poll(&kp_keys, NULL, NULL);
|
||
if (kp_is_down(&kp_keys, KEY_VOLUMEDOWN)) prev_vold = 1;
|
||
if (kp_is_down(&kp_keys, KEY_VOLUMEUP)) prev_volu = 1;
|
||
if (kp_is_down(&kp_keys, KEY_PLAYPAUSE)) prev_play = 1;
|
||
}
|
||
if (kp_power.ok) {
|
||
kp_poll(&kp_power, NULL, NULL);
|
||
if (kp_is_down(&kp_power, KEY_POWER)) prev_pwr = 1;
|
||
}
|
||
|
||
draw_confirm_box(cursor);
|
||
fprintf(stderr, "confirm: box shown (default cursor %d)\n", cursor);
|
||
|
||
int result = -1;
|
||
unsigned long long box_t0 = now_ms();
|
||
for (;;) {
|
||
/* --sim-confirm Y|N：框打开 2s 后自动回答 */
|
||
if (sim_confirm && !sim_confirm_done && now_ms() - box_t0 >= 2000) {
|
||
sim_confirm_done = 1;
|
||
result = (sim_confirm == 'Y') ? 1 : 0;
|
||
fprintf(stderr, "confirm: SIM answer %c -> %s\n", sim_confirm,
|
||
result == 1 ? "YES" : "NO");
|
||
break;
|
||
}
|
||
|
||
int vold = 0, volu = 0, play = 0, pwr = 0;
|
||
if (kp_keys.ok) {
|
||
kp_poll(&kp_keys, NULL, NULL);
|
||
vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
|
||
volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
|
||
play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
|
||
}
|
||
if (kp_power.ok) { kp_poll(&kp_power, NULL, NULL); pwr = kp_is_down(&kp_power, KEY_POWER); }
|
||
|
||
if (vold && !prev_vold) { cursor = (cursor + 1) % 2; draw_confirm_box(cursor); }
|
||
if (volu && !prev_volu) { cursor = (cursor - 1 + 2) % 2; draw_confirm_box(cursor); }
|
||
if (play && !prev_play) { result = (cursor == 0) ? 1 : 0; break; }
|
||
if (pwr && !prev_pwr) { result = 0; break; } /* 电源=取消=否 */
|
||
prev_vold = vold; prev_volu = volu; prev_play = play; prev_pwr = pwr;
|
||
|
||
if (tfd >= 0) {
|
||
struct pollfd pfd = { tfd, POLLIN, 0 };
|
||
if (poll(&pfd, 1, 0) > 0) {
|
||
unsigned char ev[16];
|
||
while (read(tfd, ev, sizeof ev) == (ssize_t)sizeof ev) {
|
||
uint16_t type = *(uint16_t *)(ev + 8);
|
||
uint16_t code = *(uint16_t *)(ev + 10);
|
||
int32_t val = *(int32_t *)(ev + 12);
|
||
if (type == EV_ABS) {
|
||
if (code == ABS_X || code == ABS_MT_POSITION_X) mt_abs(&mt_touch, val, mt_touch.last_y);
|
||
else if (code == ABS_Y || code == ABS_MT_POSITION_Y) mt_abs(&mt_touch, mt_touch.last_x, val);
|
||
} else if (type == EV_KEY && code == BTN_TOUCH) {
|
||
if (val) { /* 按压边沿：接受但**不锁原点**——等按下后首个有效 ABS 才锁（goodix 时序免疫） */
|
||
if (now_ms() < cooldown_until) mt_reset(&mt_touch); /* 幽灵/冷却：丢弃本次 */
|
||
else mt_down(&mt_touch);
|
||
} else { /* 抬起边沿：按按下原点派发；滑动/未锁到坐标 → mt_up 返回 0，不命中、不崩溃 */
|
||
int dx = 0, dy = 0;
|
||
if (mt_up(&mt_touch, &dx, &dy)) {
|
||
int ty = mt_touch.down_y;
|
||
if (ty >= CONF_ROW0_Y && ty < CONF_ROW0_Y + CONF_ROW_H) { result = 1; break; }
|
||
else if (ty >= CONF_ROW1_Y && ty < CONF_ROW1_Y + CONF_ROW_H) { result = 0; break; }
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (result >= 0) break;
|
||
}
|
||
}
|
||
usleep(POLL_MS * 1000);
|
||
}
|
||
|
||
if (tfd >= 0) close(tfd);
|
||
fb_restore_player_frame();
|
||
fb_close();
|
||
fprintf(stderr, "confirm: result %s\n", result == 1 ? "YES (kill player)" :
|
||
result == 0 ? "NO (stay HibyOS)" : "unknown");
|
||
return result;
|
||
}
|
||
|
||
/* ---- HibyOS 分支：父进程监督者/热键守护（M2）---- */
|
||
static void bootmenu_supervisor(int player_pid)
|
||
{
|
||
/* 记录开机后的正常亮度，供「杀播放器后亮度==0 则恢复 saved/60」。
|
||
* 此刻播放器刚拉起，可能已写入其背光值；过早读到 0 则回退默认 60。 */
|
||
int saved_brightness = read_brightness();
|
||
/* M2.9 Bug 3：开机初期播放器启动画面会把背光设为瞬时高值（本机 max=101），
|
||
* 若直接以其为「保底亮度」，会在扫描窗首次写回时跳一次最高亮度（开机瞬间闪一下）。
|
||
* 只信任稳定读数：读到 0 或异常高（>稳定上限 60，适中非最大）一律回退稳定值 60，
|
||
* 确保扫描期写回平滑（只写目标一次、不跳 max）。 */
|
||
if (saved_brightness <= 0 || saved_brightness > 60) saved_brightness = 60;
|
||
fprintf(stderr, "supervisor: player pid=%d, saved brightness=%d, monitoring...\n",
|
||
player_pid, saved_brightness);
|
||
/* 信号记录 hook（M2 诊断）：先装 handler、start 一行写入 TF 卡日志。
|
||
* 只记录，不改行为（handler 仅置标志，主循环 log 后恢复默认重抛）。 */
|
||
bm_sig_install();
|
||
bm_log("supervisor: start pid=%d saved_brightness=%d mode=hiby ver=%s",
|
||
player_pid, saved_brightness, MEOW_BOOTMENU_VER);
|
||
/* Bug 4：HibyOS 开机媒体扫描窗内做亮度保底。播放器忙（媒体扫描）时其背光
|
||
* 待机会把亮度降到 0、面板 blank → 黑屏几分钟。supervisor 在扫描窗内若读到
|
||
* 亮度 0，写回保底亮度（saved 或 60）。**只写 brightness、绝不碰 FBIOBLANK**
|
||
* （不抢播放器的面板归属语义，参考 §18.30 面板归属）。扫描窗结束即放手。 */
|
||
unsigned long long scan_keep_until = now_ms() + SCAN_KEEP_MS;
|
||
unsigned long long last_bri_floor_at = 0; /* 亮度保底节流：≥400ms 才再写一次 */
|
||
|
||
struct keypoll kp_power, kp_keys;
|
||
if (kp_open(&kp_power, DEV_POWER) != 0) fprintf(stderr, "supervisor: WARN no power dev\n");
|
||
if (kp_open(&kp_keys, DEV_KEYS) != 0) fprintf(stderr, "supervisor: WARN no keys dev\n");
|
||
|
||
int prev_pwr = 0, prev_vold = 0;
|
||
int pwr_hold_armed = 0;
|
||
unsigned long long pwr_down_at = 0;
|
||
int player_alive = 1;
|
||
int hotkey_pending = 0; /* M2.14：热键在武装延迟/播放器忙时置 pending，条件满足后自动弹框 */
|
||
unsigned long long sim_t0 = now_ms(); /* --sim-hotkey: supervisor 启动计时 */
|
||
unsigned long long last_mtd5_check = 0; /* T2 升级接管：mtd5 轮询节流 */
|
||
|
||
for (;;) {
|
||
unsigned long long t = now_ms();
|
||
|
||
/* 0) 记录 supervisor 收到的信号（SIGTERM/SIGINT/SIGQUIT/SIGHUP）。
|
||
* 只记录后恢复默认重抛——不改行为（仍按今日方式终止）。 */
|
||
bm_sig_poll();
|
||
|
||
/* 0b) T2 升级接管：每 500ms 读一次 mtd5 头字节，命中 ota:kernel2 即判
|
||
* 「播放器 UI 触发升级」（nandwrite 已写标记但 system 呆在最后一帧没 reboot）
|
||
* → supervisor 执行 reboot → uboot 引导 kernel2（升级模式，自动刷固件）。
|
||
* 只读 ~15B/500ms，IO 极低；/proc/mtd 只反映分区表不变读，观察不了内容。 */
|
||
if (now_ms() - last_mtd5_check >= 500) {
|
||
last_mtd5_check = now_ms();
|
||
if (mtd_ota_is_upgrade()) {
|
||
bm_log("supervisor 接管 upgrade: mtd5=ota:kernel2 -> reboot");
|
||
bm_do_reboot(LINUX_REBOOT_CMD_RESTART);
|
||
}
|
||
}
|
||
|
||
/* 1) waitpid(WNOHANG)：播放器退出 → 记日志；自然退出态 0（UI 关机）→ 真关机
|
||
* （M2.29 接管，避免「卡最后一帧但系统活着/SSH 能连」）；其余不自动重启（HGL）。 */
|
||
if (player_alive) {
|
||
int st = 0;
|
||
pid_t r = waitpid(player_pid, &st, WNOHANG);
|
||
if (r == player_pid) {
|
||
player_alive = 0;
|
||
if (WIFSIGNALED(st)) {
|
||
bm_log("player exited by signal %d (%s)", WTERMSIG(st), bm_sig_name(WTERMSIG(st)));
|
||
} else if (WIFEXITED(st) && WEXITSTATUS(st) == 0) {
|
||
/* T2 关机接管：播放器 **自然** exit(0)（非热键 SIGTERM 杀）——
|
||
* 热键杀仍在 confirm 分支内 waitpid，不会走到这里。 */
|
||
bm_log("supervisor 接管 shutdown: player exit 0 -> poweroff");
|
||
bm_do_reboot(LINUX_REBOOT_CMD_POWER_OFF);
|
||
} else {
|
||
bm_log("player exited status=%d", WEXITSTATUS(st));
|
||
/* 阶段 0：不自动重启（HGL 不可二次获取，§18.21.4）。 */
|
||
}
|
||
} else if (r < 0) {
|
||
player_alive = 0; /* 已被收割/错误 */
|
||
}
|
||
}
|
||
|
||
/* 2a) Bug 4 亮度保底：扫描窗内、播放器存活且亮度被降到 0 → 写回保底亮度。
|
||
* （播放器扫描忙时无法响应唤醒，我们只把背光拉回，画面仍为播放器最后帧，
|
||
* 不再黑屏数分钟；不碰 blank。） */
|
||
if (player_alive && now_ms() < scan_keep_until) {
|
||
int bri = read_brightness();
|
||
if (bri <= 0 && now_ms() - last_bri_floor_at >= 400) {
|
||
int floor = saved_brightness > 0 ? saved_brightness : 60;
|
||
write_brightness(floor);
|
||
last_bri_floor_at = now_ms();
|
||
fprintf(stderr, "supervisor: scan-window brightness floor -> %d\n", floor);
|
||
}
|
||
}
|
||
|
||
/* 2) EVIOCGKEY 采样（event0 电源 / event2 音量） */
|
||
int pwr = 0, vold = 0;
|
||
if (kp_power.ok) { kp_poll(&kp_power, NULL, NULL); pwr = kp_is_down(&kp_power, KEY_POWER); }
|
||
if (kp_keys.ok) { kp_poll(&kp_keys, NULL, NULL); vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN); }
|
||
|
||
/* --sim-hotkey N：supervisor 启动后 N ms 模拟「电源按住 3s + N+800 音量减点按」，
|
||
* 驱动同一套热键判定（与 launcher --sim-hotkey 同构，§18.17 注入不可投递）。 */
|
||
if (sim_hotkey_ms > 0 && !sim_hk_done) {
|
||
long se = (long)(now_ms() - sim_t0);
|
||
if (se >= sim_hotkey_ms && se < sim_hotkey_ms + 3000) pwr = 1;
|
||
if (se >= sim_hotkey_ms + 800 && se < sim_hotkey_ms + 950) vold = 1;
|
||
}
|
||
|
||
/* 3) 热键：电源按下边沿 arming，窗口内音量减按下边沿触发 */
|
||
if (pwr && !prev_pwr) { pwr_hold_armed = 1; pwr_down_at = t; }
|
||
if (!pwr && prev_pwr) pwr_hold_armed = 0; /* 松开：disarm */
|
||
if (pwr_hold_armed && pwr && (t - pwr_down_at) > HK_PWRWIN_MAX)
|
||
pwr_hold_armed = 0; /* 超窗：disarm */
|
||
|
||
int hotkey_fired = 0;
|
||
if (pwr_hold_armed && pwr && vold && !prev_vold) {
|
||
long since = (long)(t - pwr_down_at);
|
||
if (since >= HK_PWRWIN_MIN && since <= HK_PWRWIN_MAX) {
|
||
fprintf(stderr, "supervisor: HOTKEY power held + VOL_DOWN tap (%ldms) -> switch to MeowOS\n",
|
||
since);
|
||
hotkey_fired = 1;
|
||
} else {
|
||
fprintf(stderr, "supervisor: POWER+VOL_DOWN ignored (%ldms outside window)\n", since);
|
||
}
|
||
}
|
||
prev_pwr = pwr; prev_vold = vold;
|
||
|
||
/* 4) 热键触发 → 弹确认框 → 是：杀播放器进 MeowOS；否：留在 HibyOS。
|
||
* 「是/否」分支严格按用户定案：否不移交给 MeowOS，
|
||
* 恢复播放器息屏副作用并 SIGCONT；是才 kill。
|
||
* M2.14：开机武装延迟 + 播放器忙判门不再「静默丢弃」——热键一旦命中即置
|
||
* hotkey_pending，待条件满足（延迟结束 / 播放器不忙）后**自动**弹确认框，用户只按一次。 */
|
||
int in_armed_delay = (sim_hotkey_ms <= 0 || sim_hotkey_strict) && (now_ms() - sim_t0) < ARM_DELAY_MS;
|
||
int player_busy = (sim_hotkey_ms <= 0 || sim_hotkey_strict) && player_alive && proc_is_busy(player_pid);
|
||
if (hotkey_pending && !in_armed_delay && !player_busy) {
|
||
hotkey_fired = 1; hotkey_pending = 0;
|
||
fprintf(stderr, "supervisor: HOTKEY pending cleared -> fire confirm box\n");
|
||
}
|
||
if (hotkey_fired) {
|
||
sim_hk_done = 1; /* --sim-hotkey 触发一次后不再模拟 */
|
||
/* §18.23：开机武装延迟 / 播放器忙判门——不静默丢弃，置 pending 待条件满足后自动弹框
|
||
* （仅约束真实热键；--sim-hotkey 为显式测试钩子，直通）。 */
|
||
if (in_armed_delay || player_busy) {
|
||
hotkey_pending = 1;
|
||
fprintf(stderr, "supervisor: hotkey queued (armed delay=%d busy=%c) -> pending\n",
|
||
(int)in_armed_delay, player_busy ? proc_state(player_pid) : '-');
|
||
pwr_hold_armed = 0;
|
||
kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
|
||
prev_pwr = kp_is_down(&kp_power, KEY_POWER);
|
||
prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
|
||
continue;
|
||
}
|
||
/* 刷新 saved 亮度：若播放器当前亮度仍为正（如「背光常亮」设置），
|
||
* 以它为准；若电源按下已触发灭屏（亮度 0），保留此前 saved（≥60）。 */
|
||
int now_bri = read_brightness();
|
||
if (now_bri > 0) saved_brightness = now_bri;
|
||
/* 先冻结播放器（SIGSTOP→T），防止其在确认框上重绘覆盖；
|
||
* 同时捕获面板是否已因电源按下而灭屏（was_blank），供较后恢复。 */
|
||
if (player_alive && !proc_is_stopped(player_pid)) {
|
||
bm_log("supervisor -> player %d SIGSTOP (freeze for confirm)", player_pid);
|
||
kill(player_pid, SIGSTOP);
|
||
for (int i = 0; i < 100 && !proc_is_stopped(player_pid); i++) usleep(10000);
|
||
}
|
||
int raw_brightness = read_brightness();
|
||
int was_blank = (raw_brightness <= 0);
|
||
|
||
/* 点亮面板以便看清确认框（播放器已冻结，不会 re-blank）。 */
|
||
unblank_panel();
|
||
if (was_blank) write_brightness(saved_brightness);
|
||
if (read_file_int(BACKLIGHT_POWER) > 0) write_file_str(BACKLIGHT_POWER, "0\n");
|
||
|
||
int ans = confirm_switch();
|
||
|
||
if (ans == 1) {
|
||
/* ===== 是：杀播放器 → 进 MeowOS ===== */
|
||
if (player_alive) {
|
||
/* 帧冻结是 T 态：先 SIGCONT 让 SIGTERM 可投递（§18.21.3） */
|
||
if (proc_is_stopped(player_pid)) {
|
||
fprintf(stderr, "supervisor: player is T, SIGCONT first\n");
|
||
bm_log("supervisor -> player %d SIGCONT (resume from T)", player_pid);
|
||
kill(player_pid, SIGCONT);
|
||
}
|
||
fprintf(stderr, "supervisor: SIGTERM %d\n", player_pid);
|
||
bm_log("supervisor -> player %d SIGTERM (hotkey -> MeowOS)", player_pid);
|
||
kill(player_pid, SIGTERM);
|
||
unsigned long long kstart = now_ms();
|
||
int exited = 0;
|
||
while (now_ms() - kstart < KILL_GRACE_MS) {
|
||
int st = 0;
|
||
if (waitpid(player_pid, &st, WNOHANG) == player_pid) { exited = 1; break; }
|
||
usleep(POLL_MS * 1000);
|
||
}
|
||
if (!exited) {
|
||
fprintf(stderr, "supervisor: player not exiting in %dms, SIGKILL\n", KILL_GRACE_MS);
|
||
bm_log("supervisor -> player %d SIGKILL (grace %dms expired)", player_pid, KILL_GRACE_MS);
|
||
kill(player_pid, SIGKILL);
|
||
int st = 0;
|
||
waitpid(player_pid, &st, 0);
|
||
}
|
||
player_alive = 0;
|
||
}
|
||
/* 播放器已死：面板已在确认框点亮（brightness=saved）。写 mode=meow，
|
||
* 然后 exec MeowOS 基础主屏（接管 fb0 画 buffer0+pan0）。 */
|
||
write_mode(0);
|
||
fprintf(stderr, "supervisor: exec /usr/bin/meow_launcherd\n");
|
||
fflush(NULL);
|
||
execv(LAUNCHER_BIN, (char *[]){ "meow_launcherd", NULL });
|
||
fprintf(stderr, "supervisor: exec launcher failed: %s\n", strerror(errno));
|
||
_exit(127);
|
||
} else {
|
||
/* ===== 否 / -1：留在 HibyOS =====
|
||
* 恢复播放器息屏副作用：进框前已灭屏则 re-blank（0+FBIOBLANK 4）
|
||
* 使物理面板匹配播放器 state machine；否则仅当读回 0 才写回 saved。 */
|
||
if (was_blank) {
|
||
write_brightness(0);
|
||
int f = open(FB_DEV, O_RDWR);
|
||
if (f >= 0) { ioctl(f, FBIOBLANK, 4); close(f); }
|
||
} else if (read_brightness() <= 0) {
|
||
write_brightness(saved_brightness);
|
||
}
|
||
fprintf(stderr, "supervisor: hotkey cancelled (stay HibyOS)\n");
|
||
if (player_alive && proc_is_stopped(player_pid)) {
|
||
bm_log("supervisor -> player %d SIGCONT (hotkey cancelled)", player_pid);
|
||
kill(player_pid, SIGCONT);
|
||
}
|
||
/* 消化键边沿基线：把 prev 对齐到当前实际按下态（含电源仍按住），
|
||
* 并 disarm 热键，避免残留边沿立即重触发新热键（误弹确认框）。 */
|
||
pwr_hold_armed = 0;
|
||
kp_poll(&kp_power, NULL, NULL);
|
||
kp_poll(&kp_keys, NULL, NULL);
|
||
prev_pwr = kp_is_down(&kp_power, KEY_POWER);
|
||
prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
usleep(POLL_MS * 1000);
|
||
}
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* 模式标记 + 决策 */
|
||
/* ================================================================== */
|
||
static void write_mode(int choice)
|
||
{
|
||
/* choice: 1=HibyOS 0=MeowOS */
|
||
FILE *f = fopen(MODE_FILE, "w");
|
||
if (f) { fprintf(f, "%s\n", choice == 1 ? "hiby" : "meow"); fclose(f); }
|
||
fprintf(stdout, "bootmenu: DECISION -> %s (mode=%s)\n",
|
||
choice == 1 ? "HIBYOS 官方播放器" : "MEOWOS MeowOS 主屏",
|
||
choice == 1 ? "hiby" : "meow");
|
||
}
|
||
|
||
/* Bug 1：选 MeowOS → 把它持久为开机默认（写 spec 标记 + meow.conf boot_default=0），与 launcher
|
||
* «回到HibyOS»（set_boot_default_hiby 写 boot_default=1）对称。效果：本次选中即进 MeowOS 主屏，且
|
||
* 下一次开机选单默认 MeowOS（不再「选 MeowOS 仍落回 HibyOS」）。
|
||
* 权威标记 = 板载 /data/meow_boot_default（O_TRUNC 单值）；meow.conf 不再写/承载 boot_default。 */
|
||
static void set_boot_default_meow(void)
|
||
{
|
||
int fd = open("/data/meow_boot_default", O_WRONLY | O_CREAT | O_TRUNC, 0644);
|
||
if (fd >= 0) { write(fd, "0\n", 2); close(fd); fprintf(stderr, "bootmenu: /data/meow_boot_default=0\n"); }
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* --dumpkeys N：轮询 N ms，打印按键边沿（真机抓 key code 用） */
|
||
/* ================================================================== */
|
||
static int dump_cb(int code, int down, void *ctx)
|
||
{
|
||
unsigned long long start = *(unsigned long long *)ctx;
|
||
fprintf(stdout, "[%llums] key %d %s\n", now_ms() - start, code,
|
||
down ? "DOWN" : "UP");
|
||
return 0;
|
||
}
|
||
|
||
static int run_dumpkeys(long ms)
|
||
{
|
||
struct keypoll kp_power, kp_keys;
|
||
int p_ok = kp_open(&kp_power, DEV_POWER) == 0;
|
||
int k_ok = kp_open(&kp_keys, DEV_KEYS) == 0;
|
||
touch_fd = open(DEV_TOUCH, O_RDONLY | O_NONBLOCK);
|
||
if (touch_fd < 0) fprintf(stderr, "dumpkeys: open %s: %s\n", DEV_TOUCH, strerror(errno));
|
||
fprintf(stderr, "dumpkeys: polling %ld ms (power=%d keys=%d touch=%d)\n",
|
||
ms, p_ok, k_ok, touch_fd >= 0);
|
||
unsigned long long start = now_ms();
|
||
while ((long)(now_ms() - start) < ms) {
|
||
if (p_ok) kp_poll(&kp_power, dump_cb, &start);
|
||
if (k_ok) kp_poll(&kp_keys, dump_cb, &start);
|
||
if (touch_fd >= 0) {
|
||
struct pollfd pfd = { touch_fd, POLLIN, 0 };
|
||
if (poll(&pfd, 1, 0) > 0) {
|
||
unsigned char ev[16];
|
||
while (read(touch_fd, ev, sizeof ev) == (ssize_t)sizeof ev) {
|
||
uint16_t type = *(uint16_t *)(ev + 8);
|
||
uint16_t code = *(uint16_t *)(ev + 10);
|
||
int32_t val = *(int32_t *)(ev + 12);
|
||
if (type == EV_ABS) {
|
||
if (code == ABS_X || code == ABS_MT_POSITION_X) mt_abs(&mt_touch, val, mt_touch.last_y);
|
||
else if (code == ABS_Y || code == ABS_MT_POSITION_Y) mt_abs(&mt_touch, mt_touch.last_x, val);
|
||
} else if (type == EV_KEY && code == BTN_TOUCH) {
|
||
fprintf(stdout, "[%llums] touch BTN_TOUCH %d @ (%d,%d)\n",
|
||
now_ms() - start, val, mt_touch.last_x, mt_touch.last_y);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
usleep(POLL_MS * 1000);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* 选单守护模式主循环 */
|
||
/* ================================================================== */
|
||
static int run_menu(int sim_sel, int do_fork)
|
||
{
|
||
struct keypoll kp_power, kp_keys;
|
||
if (kp_open(&kp_power, DEV_POWER) != 0) fprintf(stderr, "bootmenu: WARN no power dev\n");
|
||
if (kp_open(&kp_keys, DEV_KEYS) != 0) fprintf(stderr, "bootmenu: WARN no keys dev\n");
|
||
touch_fd = open(DEV_TOUCH, O_RDONLY | O_NONBLOCK);
|
||
if (touch_fd < 0) fprintf(stderr, "bootmenu: WARN no touch dev\n");
|
||
|
||
/* 入口 drain + 短暂冷却（防 goodix 幽灵触摸，§18.16；M2.1 缩短到 800ms 不吞首次有效输入） */
|
||
if (touch_fd >= 0) {
|
||
unsigned char ev[16];
|
||
while (read(touch_fd, ev, sizeof ev) == (ssize_t)sizeof ev) { /* discard */ }
|
||
}
|
||
unsigned long long cooldown_until = now_ms() + GHOST_COOLDOWN_MS;
|
||
mt_reset(&mt_touch); /* 清触摸手势态，避免上次残留误派发（goodix 时序免疫：last 归 -1 起步） */
|
||
|
||
int cursor = (cfg_boot_default == 1) ? 0 : 1; /* 高亮随默认 */
|
||
unsigned long long start = now_ms();
|
||
unsigned long long deadline = start + (unsigned long long)cfg_boot_timeout_ms; /* 用户操作→重计（倒计时交互） */
|
||
int dirty = 1, last_cursor = -1;
|
||
long last_clock_tick = -10000, last_cd_tick = -10000;
|
||
int prev_vold = 0, prev_volu = 0, prev_play = 0, prev_pwr = 0;
|
||
int sim_done = 0;
|
||
int choice = -1;
|
||
|
||
for (;;) {
|
||
unsigned long long t = now_ms();
|
||
long el = (long)(t - start);
|
||
long remaining = (long)(deadline - t); /* 距 deadline：空闲才倒数，有输入则重计 */
|
||
|
||
if (remaining <= 0) { /* 空闲超时 → 单调强收敛到默认 */
|
||
choice = cfg_boot_default;
|
||
fprintf(stderr, "bootmenu: TIMEOUT -> default %s\n",
|
||
choice == 1 ? "hiby" : "meow");
|
||
break;
|
||
}
|
||
|
||
/* --sim-select H|M：在 SIM_SELECT_DELAY_MS 后模拟确认 */
|
||
if (sim_sel && !sim_done && el >= SIM_SELECT_DELAY_MS) {
|
||
sim_done = 1;
|
||
if (sim_sel == 'H') { cursor = 0; choice = 1; }
|
||
else { cursor = 1; choice = 0; }
|
||
fprintf(stderr, "bootmenu: SIM SELECT %c -> %s\n",
|
||
sim_sel, choice == 1 ? "hiby" : "meow");
|
||
break;
|
||
}
|
||
|
||
/* 按键边沿 */
|
||
int vold = 0, volu = 0, play = 0, pwr = 0;
|
||
if (kp_power.ok) { kp_poll(&kp_power, NULL, NULL); pwr = kp_is_down(&kp_power, KEY_POWER); }
|
||
if (kp_keys.ok) { kp_poll(&kp_keys, NULL, NULL);
|
||
vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
|
||
volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
|
||
play = kp_is_down(&kp_keys, KEY_PLAYPAUSE); }
|
||
|
||
if (vold && !prev_vold) { /* 音量下 = 下移 */
|
||
cursor = (cursor + 1) % 2;
|
||
deadline = now_ms() + (unsigned long long)cfg_boot_timeout_ms; /* 用户操作 → 倒计时重计 */
|
||
fprintf(stderr, "bootmenu: key VOL_DOWN -> cursor %d (cd reset)\n", cursor);
|
||
}
|
||
if (volu && !prev_volu) { /* 音量上 = 上移（2 项循环：-1 取模） */
|
||
cursor = (cursor - 1 + 2) % 2;
|
||
deadline = now_ms() + (unsigned long long)cfg_boot_timeout_ms; /* 用户操作 → 倒计时重计 */
|
||
fprintf(stderr, "bootmenu: key VOL_UP -> cursor %d (cd reset)\n", cursor);
|
||
}
|
||
if (play && !prev_play) { /* 播放 = 确认 */
|
||
choice = (cursor == 0) ? 1 : 0;
|
||
fprintf(stderr, "bootmenu: key PLAY -> select row %d (%s)\n",
|
||
cursor, choice == 1 ? "hiby" : "meow");
|
||
break;
|
||
}
|
||
if (pwr && !prev_pwr) { /* 电源 = 确认当前光标项（M2.9 Bug 1：不再固定取默认） */
|
||
choice = (cursor == 0) ? 1 : 0;
|
||
fprintf(stderr, "bootmenu: key POWER -> confirm row %d (%s)\n",
|
||
cursor, choice == 1 ? "hiby" : "meow");
|
||
break;
|
||
}
|
||
prev_vold = vold; prev_volu = volu; prev_play = play; prev_pwr = pwr;
|
||
|
||
/* 触摸（event1）：按压→抬起 tap（同 launcher，读 ABS_X/Y 与 ABS_MT_*，§18.20） */
|
||
if (touch_fd >= 0) {
|
||
struct pollfd pfd = { touch_fd, POLLIN, 0 };
|
||
if (poll(&pfd, 1, 0) > 0) {
|
||
unsigned char ev[16];
|
||
while (read(touch_fd, ev, sizeof ev) == (ssize_t)sizeof ev) {
|
||
uint16_t type = *(uint16_t *)(ev + 8);
|
||
uint16_t code = *(uint16_t *)(ev + 10);
|
||
int32_t val = *(int32_t *)(ev + 12);
|
||
if (type == EV_ABS) {
|
||
if (code == ABS_X || code == ABS_MT_POSITION_X) mt_abs(&mt_touch, val, mt_touch.last_y);
|
||
else if (code == ABS_Y || code == ABS_MT_POSITION_Y) mt_abs(&mt_touch, mt_touch.last_x, val);
|
||
} else if (type == EV_KEY && code == BTN_TOUCH) {
|
||
if (val) { /* 按压边沿：接受但**不锁原点**——等按下后首个有效 ABS 才锁（goodix 时序免疫，修“点两下”） */
|
||
if (now_ms() < cooldown_until) mt_reset(&mt_touch); /* 幽灵/冷却：丢弃本次 */
|
||
else mt_down(&mt_touch);
|
||
} else { /* 抬起边沿：按按下原点派发；滑动/未锁到坐标 → mt_up 返回 0，不命中、不崩溃 */
|
||
int dx = 0, dy = 0;
|
||
if (mt_up(&mt_touch, &dx, &dy)) {
|
||
int ty = mt_touch.down_y;
|
||
if (ty >= ENTRY0_Y - 4 && ty < ENTRY0_Y + ROW_H - 8) {
|
||
cursor = 0; choice = 1; deadline = now_ms() + (unsigned long long)cfg_boot_timeout_ms;
|
||
fprintf(stderr, "bootmenu: touch row 0 -> hiby\n");
|
||
} else if (ty >= ENTRY1_Y - 4 && ty < ENTRY1_Y + ROW_H - 8) {
|
||
cursor = 1; choice = 0; deadline = now_ms() + (unsigned long long)cfg_boot_timeout_ms;
|
||
fprintf(stderr, "bootmenu: touch row 1 -> meow\n");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (choice >= 0) break;
|
||
}
|
||
}
|
||
|
||
/* 光标变化 → 整屏重绘 */
|
||
if (cursor != last_cursor) dirty = 1;
|
||
if (dirty) {
|
||
draw_menu(cursor, remaining);
|
||
last_cursor = cursor;
|
||
dirty = 0;
|
||
}
|
||
|
||
/* 每秒刷时钟 */
|
||
if (el - last_clock_tick >= 1000) { last_clock_tick = el; draw_clock(cfg_bg); }
|
||
/* 每秒刷倒计时（秒值变化才刷） */
|
||
long cd = (remaining + 999) / 1000;
|
||
if (el - last_cd_tick >= 1000) { last_cd_tick = el; draw_countdown(cfg_bg, remaining); }
|
||
|
||
usleep(POLL_MS * 1000);
|
||
}
|
||
|
||
write_mode(choice >= 0 ? choice : cfg_boot_default);
|
||
if (touch_fd >= 0) close(touch_fd);
|
||
|
||
/* 顺序（§2.3）：先恢复 fb（选单不再占屏），再 munmap+close fb0，才 fork */
|
||
fb_restore_player_frame();
|
||
fb_close();
|
||
/* M2（--fork）：HibyOS→fork 播放器（父进程转监督者，阻塞 rcS）；
|
||
* MeowOS→exec meow_launcherd（MeowOS 基础主屏，接管 fb0）。 */
|
||
if (do_fork) {
|
||
if (choice == 1) {
|
||
fork_hiby_player(); /* 父进程陷入 supervisor，永不返回 */
|
||
} else {
|
||
set_boot_default_meow(); /* Bug 1：选 MeowOS → 持久为开机默认 */
|
||
execv(LAUNCHER_BIN, (char *[]){ "meow_launcherd", NULL });
|
||
fprintf(stderr, "bootmenu: exec launcher failed: %s\n", strerror(errno));
|
||
_exit(127);
|
||
}
|
||
}
|
||
return 0; /* M0/M1（无 --fork）：选单退出，rcS 推进 */
|
||
}
|
||
|
||
/* ================================================================== */
|
||
/* main */
|
||
/* ================================================================== */
|
||
static void usage(void)
|
||
{
|
||
fprintf(stderr,
|
||
"usage: meow_bootmenu [--dumpkeys N] [--sim-select H|M] [--boot-only]\n"
|
||
" [--timeout-ms N] [--fork] [--version]\n"
|
||
" (no args) 守护选单模式（显示菜单，等待选择/超时）\n"
|
||
" --dumpkeys N 轮询 N ms 打印按键边沿（抓 key code）\n"
|
||
" --sim-select H|M 显示菜单，%d ms 后模拟选 H=HibyOS / M=MeowOS\n"
|
||
" --boot-only 跳过选单，直接取默认（boot_default）\n"
|
||
" --timeout-ms N 覆写超时毫秒（测试钩子）\n"
|
||
" --fork M2 开启：选 HibyOS 时 fork 播放器并转监督者;\n"
|
||
" 选 MeowOS 时 exec /usr/bin/meow_launcherd（默认关）\n"
|
||
" --sim-hotkey N 监督者启动 N ms 后模拟热键（M2 真机 verif）\n"
|
||
" --sim-confirm Y|N 确认框打开 2s 后自动答 Y=是 / N=否\n"
|
||
" --version 打印版本并退出\n",
|
||
SIM_SELECT_DELAY_MS);
|
||
}
|
||
|
||
int main(int argc, char **argv)
|
||
{
|
||
long dumpkeys = 0, timeout_override = 0;
|
||
int sim_sel = 0;
|
||
int boot_only = 0;
|
||
int do_fork = 0;
|
||
int do_version = 0;
|
||
|
||
for (int i = 1; i < argc; i++) {
|
||
if (!strcmp(argv[i], "--dumpkeys") && i + 1 < argc) dumpkeys = atol(argv[++i]);
|
||
else if (!strcmp(argv[i], "--sim-select") && i + 1 < argc) {
|
||
char c = argv[++i][0];
|
||
if (c == 'h' || c == 'H') sim_sel = 'H';
|
||
else if (c == 'm' || c == 'M') sim_sel = 'M';
|
||
else { usage(); return 1; }
|
||
}
|
||
else if (!strcmp(argv[i], "--boot-only")) boot_only = 1;
|
||
else if (!strcmp(argv[i], "--timeout-ms") && i + 1 < argc) timeout_override = atol(argv[++i]);
|
||
else if (!strcmp(argv[i], "--fork")) do_fork = 1;
|
||
else if (!strcmp(argv[i], "--sim-hotkey") && i + 1 < argc) sim_hotkey_ms = atol(argv[++i]);
|
||
else if (!strcmp(argv[i], "--sim-hotkey-strict") && i + 1 < argc) { sim_hotkey_ms = atol(argv[++i]); sim_hotkey_strict = 1; }
|
||
else if (!strcmp(argv[i], "--sim-confirm") && i + 1 < argc) {
|
||
char c = argv[++i][0];
|
||
if (c == 'y' || c == 'Y') sim_confirm = 'Y';
|
||
else if (c == 'n' || c == 'N') sim_confirm = 'N';
|
||
else { usage(); return 1; }
|
||
}
|
||
else if (!strcmp(argv[i], "--version")) do_version = 1;
|
||
else { usage(); return 1; }
|
||
}
|
||
|
||
load_boot_ver(); /* 读 /etc/meowos_version（版本单点）；--version 与选单右下角共用 */
|
||
|
||
if (do_version) {
|
||
printf("meow_bootmenu %s (mipsel static musl)\n", MEOW_BOOTMENU_VER);
|
||
printf("MeowOS v%s\n", g_boot_ver);
|
||
return 0;
|
||
}
|
||
|
||
load_config();
|
||
if (timeout_override > 0) cfg_boot_timeout_ms = timeout_override;
|
||
|
||
if (dumpkeys > 0) return run_dumpkeys(dumpkeys);
|
||
|
||
/* 无菜单直进（boot_menu=0 或 --boot-only）：§3「直进默认锁 HGL」 */
|
||
if (boot_only || !cfg_boot_menu) {
|
||
int choice = cfg_boot_default;
|
||
fprintf(stderr, "bootmenu: boot-only -> default %s\n",
|
||
choice == 1 ? "hiby" : "meow");
|
||
write_mode(choice);
|
||
if (do_fork) {
|
||
if (choice == 1) fork_hiby_player();
|
||
else {
|
||
set_boot_default_meow(); /* Bug 1：选 MeowOS → 持久为开机默认 */
|
||
execv(LAUNCHER_BIN, (char *[]){ "meow_launcherd", NULL });
|
||
fprintf(stderr, "bootmenu: exec launcher failed: %s\n", strerror(errno));
|
||
_exit(127);
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
if (fb_open() != 0) return 1;
|
||
fb_snapshot_player(); /* 快照当前显示缓冲（恢复播放器帧用） */
|
||
fb_pan_buf0(); /* 画前 pan 到 yoffset=0（buffer0） */
|
||
draw_menu(cfg_boot_default == 1 ? 0 : 1, cfg_boot_timeout_ms); /* 预画一帧 */
|
||
run_menu(sim_sel, do_fork);
|
||
return 0;
|
||
}
|