把吃灰 Kindle 改成独立名言屏：越狱、帧渲染、时钟叠加与触摸翻页全记录

sudo apt install python3-pil gcc-arm-linux-gnueabihf sshpass
pip install fonttools          # 字体子集化用

eips -i

# 先插线，找到 Kindle 对应的网卡接口名（ip link 看，形如 enx…）
sudo nmcli con add type ethernet con-name kindle-usb \
  ifname enxee4900000000 \
  ipv4.method manual ipv4.addresses 192.168.15.201/24 \
  ipv4.never-default yes

ssh root@<Kindle的IP>          # 密码为你安装 usbnet 时所配置

ssh root@<Kindle的IP>
mount -o remount,rw /
cd /etc/upstart
mv framework.conf framework.conf.disabled
mv lab126_gui.conf lab126_gui.conf.disabled
# OTA 四任务一并禁掉（防系统升级清越狱）
mv ota-update.conf ota-update.conf.disabled
mv otaupd.conf otaupd.conf.disabled
mv otav3.conf otav3.conf.disabled
mv wfmupdate.conf wfmupdate.conf.disabled

mount -o remount,rw /
echo "CST-8" > /var/local/system/tz

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""kd_render_frames.py —— 帧预渲染器（跑在 Linux 主机上）
渲染全部语录为静态帧 PNG，整包拷到 Kindle /mnt/us/kd_frames/
画布 800x600 横向 -> 旋转 90° -> 600x800 竖版缓冲，顶部朝左横放正立
"""
import sys, random
from pathlib import Path
from PIL import Image, ImageDraw, ImageFont

NOTO_SERIF = "/usr/share/fonts/opentype/noto/NotoSerifCJK-{}.ttc"  # index 2 = SC
DEJAVU     = "/usr/share/fonts/truetype/dejavu/DejaVuSerif{}.ttf"  # "" / "-Bold"

# ---- 语录池（样例，按格式扩充）。统一四元组 (语言, 主文, 对照文, 作者) ----
QUOTES = [   # 英文名言: (英文, 中文对照, 作者)
    ("The best way to predict the future is to invent it.", "预测未来的最好方式，就是去创造它。", "Alan Kay"),
    ("Stay hungry, stay foolish.", "求知若饥，虚心若愚。", "Steve Jobs"),
]
CN_QUOTES = [  # 中国经典: (中文, 出处)
    ("上善若水，水善利万物而不争。", "老子《道德经》"),
    ("天行健，君子以自强不息。", "《周易》"),
]
# 红楼梦 / 西游记 / 禅偈 / 古籍 / 唐诗宋词……同格式各建一个列表，加进 all_quotes()

def all_quotes():
    return ([("en", en, cn, who) for en, cn, who in QUOTES]
          + [("cn", cn, "", who) for cn, who in CN_QUOTES])

def wrap_text(text, font, max_w):
    """按像素宽度贪心换行：CJK 逐字、英文按词；行首标点禁则"""
    lines, cur = [], ""
    units, buf = [], ""
    for ch in text:
        if ch > "\u2e80" or ch in "，。；、：）】》”！？—":
            if buf: units.append(buf); buf = ""
            units.append(ch)
        elif ch == " ":
            if buf: units.append(buf)
            buf = ""; units.append(" ")
        else:
            buf += ch
    if buf: units.append(buf)

    for u in units:
        if u == " " and not cur: continue
        joiner = "" if (not cur or cur[-1] == " " or u == " "
                        or cur[-1] > "\u2e80" or u > "\u2e80") else " "
        piece = cur + joiner + u
        if font.getlength(piece) <= max_w:
            cur = piece
        else:
            if cur: lines.append(cur)
            cur = u if u != " " else ""
    if cur:                     # 关键收尾：最后一段未满行也要入列（否则吞行！）
        lines.append(cur)

    PUNCT = "，。；、：）】》”！？…"
    fixed = []
    for ln in lines:            # 行首句读标点回挂上一行行尾
        if fixed and ln and ln[0] in PUNCT:
            fixed[-1] += ln[0]; ln = ln[1:]
            while ln and ln[0] in PUNCT:
                fixed[-1] += ln[0]; ln = ln[1:]
            if not ln: continue
        fixed.append(ln)
    return fixed

# ---- 横向画布参数
LW, LH = 800, 600            # 设备 600x800@167ppi，横放观看即 800x600
MH, MV = 72, 52              # 左右 / 上下留白（顶部 52px 留给运行期时钟条）
CONTENT_W = LW - MH * 2
FOOTER_H = 28
AVAIL_H = LH - MV * 2 - FOOTER_H
ROTATE = "CW"                # CW=顶部朝左横放；摆反了改 "CCW" 重跑

def f_cn(size, weight="Regular"):
    return ImageFont.truetype(NOTO_SERIF.format(weight), size, index=2)

def f_en(size, bold=False):
    return ImageFont.truetype(DEJAVU.format("-Bold" if bold else ""), size)

def draw_block(d, lines, font, pitch, y, fill=0):
    for ln in lines:
        d.text(((LW - font.getlength(ln)) / 2, y), ln, font=font, fill=fill)
        y += pitch
    return y

def render_landscape(quote):
    img = Image.new("L", (LW, LH), 255)
    d = ImageDraw.Draw(img)
    kind, q_pri, q_sec, q_who = quote
    who = f"—— {q_who}"
    f_who = f_cn(20)

    if kind == "cn":        # 中文语录：只显示中文，字号自适应
        lines, size, pitch = None, 42, 63
        for s in (66, 60, 54, 48):
            ls = wrap_text(q_pri, f_cn(s, "Bold"), CONTENT_W)
            if len(ls) * int(s * 1.5) + 44 <= AVAIL_H:
                lines, size, pitch = ls, s, int(s * 1.5); break
        if lines is None:
            lines = wrap_text(q_pri, f_cn(48, "Bold"), CONTENT_W)
            size, pitch = 48, 72
        h = len(lines) * pitch + 44
        y = MV + max(0, int((AVAIL_H - h) * 0.42))
        y = draw_block(d, lines, f_cn(size, "Bold"), pitch, y)
        d.text((LW - MH - f_who.getlength(who), y + 14), who, font=f_who, fill=90)
    else:                   # 英文名言：英文加粗主文 + 中文对照
        f_sec = f_cn(26)
        cn_lines = wrap_text(q_sec, f_sec, CONTENT_W)
        lines, size, pitch = None, 34, 49
        for s in (46, 42, 38):
            ls = wrap_text(q_pri, f_en(s, bold=True), CONTENT_W)
            if len(ls) * int(s * 1.45) + len(cn_lines) * 39 + 44 <= AVAIL_H:
                lines, size, pitch = ls, s, int(s * 1.45); break
        if lines is None:
            lines = wrap_text(q_pri, f_en(38, bold=True), CONTENT_W)
            size, pitch = 38, 55
        h = len(lines) * pitch + len(cn_lines) * 39 + 44
        y = MV + max(0, int((AVAIL_H - h) * 0.42))
        y = draw_block(d, lines, f_en(size, bold=True), pitch, y)
        y = draw_block(d, cn_lines, f_sec, 39, y + 6, fill=70)
        d.text((LW - MH - f_who.getlength(who), y + 8), who, font=f_who, fill=90)

    foot = "你的署名"                    # 页脚（静态，不含日期——日期走实时时钟条）
    f_foot = f_cn(18)
    d.text(((LW - f_foot.getlength(foot)) / 2, LH - 36), foot, font=f_foot, fill=130)

    f_hint = f_cn(16)                    # 半屏翻页提示
    hint_l = "« 上一条"
    d.text((MH, LH - 32), hint_l, font=f_hint, fill=160)
    hint_r = "下一条 »"
    d.text((LW - MH - f_hint.getlength(hint_r), LH - 32), hint_r,
           font=f_hint, fill=160)

    return img.transpose(Image.ROTATE_270 if ROTATE == "CW" else Image.ROTATE_90)

def main():
    out = Path(sys.argv[1] if len(sys.argv) > 1 else "frames")
    all_quotes_ = all_quotes()
    # 固定种子洗牌：语录池按分类连排（红楼 26 连/宋词 22 连…观感差），
    # 洗牌后类型交错；种子固定 => 重渲染序列稳定，帧号语义不变
    random.Random(20260925).shuffle(all_quotes_)
    out.mkdir(parents=True, exist_ok=True)
    for i, q in enumerate(all_quotes_):
        render_landscape(q).save(out / f"q_{i:03d}.png", "PNG", optimize=True)
    Image.new("L", (LW, LH), 255).save(out / "white.png", "PNG")   # 夜间休息页
    print(f"rendered {len(all_quotes_)} frames + white.png -> {out}")

if __name__ == "__main__":
    main()

cd frames && tar czf ../frames.tar.gz *.png
scp frames.tar.gz root@<Kindle的IP>:/mnt/us/
# Kindle 上:
ssh root@<Kindle的IP> "cd /mnt/us && mkdir -p kd_frames && tar xzf frames.tar.gz -C kd_frames && rm frames.tar.gz"

#!/bin/sh
# kd_show.sh v5 —— Kindle 独立名言屏主循环（随机轮播版）
# 帧目录: /mnt/us/kd_frames/  (q_000.png ~ q_NNN.png + white.png)
# 帧序、随机、历史全部收敛在 kd_touchd 一处:
#   · 自动每 10 分钟: USR1 => 随机下一条(排除最近 10 条)
#   · 点击左半屏: 上一条(历史精确回退) / 右半屏: 下一条(随机)
#   · 开机: 从 kd_state 恢复上次位置

FRAMES=/mnt/us/kd_frames
TOTAL=$(ls "$FRAMES"/q_*.png 2>/dev/null | wc -l)
[ "$TOTAL" -lt 1 ] 2>/dev/null && TOTAL=208
LOG=/mnt/us/kd_frames/kd_show.log
EIPS=/usr/sbin/eips
CLOCK=/mnt/us/kd_bin/kd_clock
STATE=/mnt/us/kd_state
PIDF=/mnt/us/kd_touchd.pid
export TZ=CST-8                     # 固定北京时间，作息不受系统时区影响

log() { echo "$(date '+%F %T') $*" >> "$LOG"; }

# ---- 防休眠：让屏保计时器失效（脚本停止后自动恢复）
/usr/bin/lipc-set-prop -i com.lab126.powerd preventScreenSaver 1 2>/dev/null \
  || log "WARN: preventScreenSaver failed"

# ---- 通知导航进程换一条（随机）
nav_next() {
  pid=$(cat "$PIDF" 2>/dev/null)
  case "$pid" in ''|*[!0-9]*) return 1;; esac
  kill -USR1 "$pid" 2>/dev/null
}

show_idx() {  # $1=idx : 上屏 + 写 state（仅开机恢复用；运行期显示统一走 kd_touchd）
  frame=$(printf '%s/q_%03d.png' "$FRAMES" "$1")
  if [ -f "$frame" ]; then
    $EIPS -g "$frame"
    echo "$1" > "$STATE"
    return 0
  fi
  return 1
}

# ---- 读取上次位置
cur=0
if [ -f "$STATE" ]; then
  cur=$(cat "$STATE" 2>/dev/null)
  case "$cur" in ''|*[!0-9]*) cur=0;; esac
  [ "$cur" -ge "$TOTAL" ] && cur=0
fi

h=$(date +%H); m=$(date +%M)
hh=${h#0}; mm=${m#0}
mins=$((hh * 60 + mm))
last_slot=$((mins / 10))            # 当前 10 分钟槽视为已消费

last=-1
lmin=""
log "kd_show v5 started (total=$TOTAL, resume=$cur)"

# ---- 开机立即恢复画面（展示时段显 state 帧；夜间白屏）
if [ "$mins" -ge 480 ] && [ "$mins" -lt 1440 ]; then
  if show_idx "$cur"; then
    log "resume idx=$cur"
    last=$cur
  fi
else
  $EIPS -g "$FRAMES/white.png"
  log "night mode (white)"
  last="-2"
fi

while true; do
  h=$(date +%H); m=$(date +%M)
  hh=${h#0}; mm=${m#0}
  mins=$((hh * 60 + mm))

  if [ "$mins" -ge 480 ] && [ "$mins" -lt 1440 ]; then
    # ---- 展示时段：每 10 分钟边界随机前进一条（由 kd_touchd 统一执行）
    slot=$((mins / 10))
    if [ "$slot" != "$last_slot" ]; then
      if nav_next; then
        log "advance slot=$slot (usr1)"
        last="adv"
      else
        log "WARN: nav_next failed (no pid?)"
      fi
      last_slot=$slot
    fi
    # ---- 每分钟顶部时间条
    hm=$(date +%H%M)
    if [ "$hm" != "$lmin" ] && [ -x "$CLOCK" ]; then
      "$CLOCK" auto
      lmin=$hm
    fi
  else
    # ---- 夜间：纯白休息页（只切一次）；不推进，点击翻页仍可用
    if [ "$last" != "-2" ]; then
      $EIPS -g "$FRAMES/white.png"
      log "night mode (white)"
      last="-2"
    fi
    last_slot=-1                     # 夜间重置，8:00 醒来立即推进
  fi

  sleep 20
done

pip install fonttools
fonttools subset --font-number=2 \
    --text="0123456789:|.- 周一二三四五六日月年" \
    NotoSerifCJK-Bold.ttc --output-file=kd_font.ttf
# 产物仅 6.2KB，拷到 Kindle /mnt/us/kd_bin/kd_font.ttf

/* kd_clock.c —— Kindle 横屏顶部时间条叠加工具（运行在 Kindle 上）
 *
 * 设备: Kindle 基础版 7 代 (600x800 @167ppi, 8bpp fb, line_length 608)
 * 画面约定: 主帧为横放(顶朝左)渲染的竖版缓冲 600x800, eips -g 1:1 贴图
 *           => fb 的 x=599 列对应横屏画面的顶边
 * 用法: kd_clock auto [px]            取系统时间自动拼串(设 TZ=CST-8)
 *       kd_clock "14:23|周五 9月25日" [px]
 *       '|' 前为时刻(深色), 后为日期(浅色); px 默认 32
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <linux/fb.h>

#define STB_TRUETYPE_IMPLEMENTATION
#include "stb_truetype.h"
#include "mxcfb-kindle.h"   /* FBInk 自带的 Kindle mxcfb 定义 */

#define FBW 600
#define FBH 800
#define STRIP_H 52             /* 横屏顶部条带高度(px, = 主帧上边距 MV) */
#define FONT_PATH "/mnt/us/kd_bin/kd_font.ttf"
#define TEXT_DARK 60           /* 时刻文字灰度 */
#define DATE_DARK 135          /* 日期文字灰度 */

static const char *WDAY[] = { "周日", "周一", "周二", "周三", "周四", "周五", "周六" };

static int ll = 608;

static void die(const char *m)
{
    fprintf(stderr, "kd_clock: %s (%s)\n", m, strerror(errno));
    exit(1);
}

/* mxcfb 局部刷新 */
static void refresh(int fbfd, int left, int top, int w, int h)
{
    static unsigned marker = 4200;
    struct mxcfb_update_data u;
    memset(&u, 0, sizeof(u));
    u.update_region.top    = (unsigned)top;
    u.update_region.left   = (unsigned)left;
    u.update_region.width  = (unsigned)w;
    u.update_region.height = (unsigned)h;
    u.waveform_mode        = WAVEFORM_MODE_GC16_FAST;
    u.update_mode          = UPDATE_MODE_PARTIAL;
    u.update_marker        = ++marker;
    u.hist_bw_waveform_mode   = WAVEFORM_MODE_DU;
    u.hist_gray_waveform_mode = WAVEFORM_MODE_GC16_FAST;
    u.temp = TEMP_USE_AUTO;
    u.flags = 0;
    if (ioctl(fbfd, MXCFB_SEND_UPDATE, &u) < 0)
        fprintf(stderr, "kd_clock: refresh ioctl: %s\n", strerror(errno));
}

int main(int argc, char **argv)
{
    const char *arg = argc > 1 ? argv[1] : "auto";
    int px = argc > 2 ? atoi(argv[2]) : 32;
    if (px < 16) px = 16;
    if (px > STRIP_H - 12) px = STRIP_H - 12;

    char text[128];
    if (strcmp(arg, "auto") == 0) {
        setenv("TZ", "CST-8", 1);
        tzset();
        time_t t = time(NULL);
        struct tm tmv;
        localtime_r(&t, &tmv);
        snprintf(text, sizeof(text), "%02d:%02d|%s %d月%d日",
                 tmv.tm_hour, tmv.tm_min, WDAY[tmv.tm_wday % 7],
                 tmv.tm_mon + 1, tmv.tm_mday);
    } else {
        snprintf(text, sizeof(text), "%.127s", arg);
    }

    /* ---- 打开 framebuffer ---- */
    int fbfd = open("/dev/fb0", O_RDWR);
    if (fbfd < 0) die("open /dev/fb0");
    struct fb_fix_screeninfo finfo;
    if (ioctl(fbfd, FBIOGET_FSCREENINFO, &finfo) == 0 && finfo.line_length > 0)
        ll = (int)finfo.line_length;
    size_t fblen = (size_t)ll * FBH;
    unsigned char *fb = (unsigned char *)mmap(NULL, fblen, PROT_READ | PROT_WRITE,
                                              MAP_SHARED, fbfd, 0);
    if (fb == MAP_FAILED) die("mmap fb");

    /* ---- 加载字体 ---- */
    FILE *fp = fopen(FONT_PATH, "rb");
    if (!fp) die("open " FONT_PATH);
    fseek(fp, 0, SEEK_END);
    long fl = ftell(fp);
    fseek(fp, 0, SEEK_SET);
    unsigned char *fdata = (unsigned char *)malloc((size_t)fl);
    if (!fdata || fread(fdata, 1, (size_t)fl, fp) != (size_t)fl) die("read font");
    fclose(fp);
    stbtt_fontinfo font;
    if (stbtt_InitFont(&font, fdata, 0) == 0) die("stbtt_InitFont");
    float scale = stbtt_ScaleForPixelHeight(&font, (float)px);
    int ascent = 0, descent = 0, lineGap = 0;
    stbtt_GetFontVMetrics(&font, &ascent, &descent, &lineGap);
    int apx = (int)(ascent * scale);
    int dpx = (int)(-descent * scale);

    /* ---- 条带缓冲 strip[hx][hy]: hx=横屏水平行进(0..799), hy=横屏纵向(0..52) ---- */
    static unsigned char strip[FBH][STRIP_H];
    memset(strip, 255, sizeof(strip));

    int boxh = apx + dpx;
    int top = (STRIP_H - boxh) / 2;
    if (top < 2) top = 2;
    int base = top + apx;   /* 字形位图行 row 对应 hy = base + yoff + row */

    /* 两遍: 先测总宽, 再画; '|' 分段(段间加空隙), 颜色深浅区分 */
    long total_w = 0;
    long start_x = 0;
    int seg_gap = px / 3;
    int npass;
    for (npass = 0; npass < 2; npass++) {
        long cursor;
        int seg = 0;
        if (npass == 0) {
            cursor = 0;                 /* 第一遍: 累计文本宽度 */
        } else {
            cursor = start_x;           /* 第二遍: 从水平居中处起笔 */
        }
        const char *p = text;
        while (*p) {
            unsigned int cp = (unsigned char)*p;
            if (cp < 0x80) {
                p += 1;
            } else if ((cp & 0xE0) == 0xC0) {
                cp = ((cp & 0x1F) << 6) | (p[1] & 0x3F); p += 2;
            } else if ((cp & 0xF0) == 0xE0) {
                cp = ((cp & 0x0F) << 12) | ((p[1] & 0x3F) << 6) | (p[2] & 0x3F); p += 3;
            } else {
                cp = ((cp & 0x07) << 18) | ((p[1] & 0x3F) << 12) | ((p[2] & 0x3F) << 6) | (p[3] & 0x3F);
                p += 4;
            }
            if (cp == '|') {
                cursor += seg_gap;
                seg = 1;
                continue;
            }
            if (cp == ' ') {
                int aw = 0, lsb = 0;
                stbtt_GetCodepointHMetrics(&font, (int)' ', &aw, &lsb);
                cursor += (long)(aw * scale);
                continue;
            }
            if (npass == 0) {
                int aw = 0, lsb = 0;
                stbtt_GetCodepointHMetrics(&font, (int)cp, &aw, &lsb);
                cursor += (long)(aw * scale);
            } else {
                int bw = 0, bh = 0, xoff = 0, yoff = 0;
                unsigned char *bm = stbtt_GetCodepointBitmap(&font, scale, scale,
                                                             (int)cp, &bw, &bh, &xoff, &yoff);
                if (bm) {
                    int gx = (int)(cursor + xoff);
                    int gy = base + yoff;
                    unsigned char col = (unsigned char)(seg ? DATE_DARK : TEXT_DARK);
                    for (int r = 0; r < bh; r++) {
                        int hy = gy + r;
                        if (hy < 0 || hy >= STRIP_H) continue;
                        for (int c = 0; c < bw; c++) {
                            int hx = gx + c;
                            if (hx < 0 || hx >= FBH) continue;
                            unsigned char v = bm[(size_t)r * bw + c];
                            if (v == 0) continue;
                            unsigned char old = strip[hx][hy];   /* alpha 混合到白底 */
                            unsigned char nv = (unsigned char)((old * (255 - v) + col * v) / 255);
                            strip[hx][hy] = nv;
                        }
                    }
                    stbtt_FreeBitmap(bm, NULL);
                }
                int aw = 0, lsb = 0;
                stbtt_GetCodepointHMetrics(&font, (int)cp, &aw, &lsb);
                cursor += (long)(aw * scale);
            }
        }
        if (npass == 0) {
            total_w = cursor;
            if (total_w > FBH - 20) total_w = FBH - 20;   /* 防溢出 */
            start_x = (FBH - total_w) / 2;                /* 水平居中 */
            if (start_x < 10) start_x = 10;
        }
    }

    /* ---- 旋转写入 fb: fb[y=hx][x=599-hy], 条带 x∈[600-STRIP_H, 600) ---- */
    for (int hx = 0; hx < FBH; hx++) {
        unsigned char *frow = fb + (size_t)hx * ll;
        for (int hy = 0; hy < STRIP_H; hy++) {
            frow[FBW - 1 - hy] = strip[hx][hy];
        }
    }

    /* ---- 局部刷新整条条带 ---- */
    refresh(fbfd, FBW - STRIP_H, 0, STRIP_H, FBH);

    munmap(fb, fblen);
    close(fbfd);
    free(fdata);
    return 0;
}

arm-linux-gnueabihf-gcc -static -O2 -o kd_clock kd_clock.c \
    -I<FBInk源码目录>/eink -lm
# -static 很重要: Kindle 上没有对应的动态库环境

/* kd_touchd.c —— 触摸翻页 + 导航守护（双向历史 + 随机）（运行在 Kindle 上）
 *
 * 交互: 横放(顶朝左)时, 点左半屏 = 上一条(历史回退), 点右半屏 = 下一条(随机),
 *       中间竖带(native x 240..360)无效。
 * 历史模型:
 *   hist[] = 出现过的内容序列（只增不删）, pos = 当前显示下标。
 *   · 下一条: 随机挑一条(排除最近 10 条), 截断 pos 右侧前进历史后 append
 *   · 上一条: pos 左移一格, 精确重放
 *   · 回退到最早一条(pos==0): 按洗牌池顺序往前翻一页(确定性非随机), 前插入历史
 *   · 自动推进: 主循环每 10 分钟 kill -USR1 => 等价"下一条"
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <sys/ioctl.h>
#include <linux/input.h>

#define EVDEV   "/dev/input/event1"
#define FRAMES  "/mnt/us/kd_frames"
#define STATE   "/mnt/us/kd_state"
#define PIDF    "/mnt/us/kd_touchd.pid"
#define LOGF    "/mnt/us/kd_touch.log"
#define EIPS    "/usr/sbin/eips"
#define CLOCK   "/mnt/us/kd_bin/kd_clock"

#define DEADL 240              /* x < 240 -> 上一条 */
#define DEADR 360              /* x > 360 -> 下一条 */
#define HIST_MAX 4096
#define AVOID 10               /* 随机时排除最近出现条数 */

static volatile sig_atomic_t req_next = 0;
static volatile sig_atomic_t req_prev = 0;
static void on_usr1(int s) { (void)s; req_next = 1; }
static void on_usr2(int s) { (void)s; req_prev = 1; }

static FILE *lg = NULL;
static int total = 208;
static int hist[HIST_MAX];
static int hn = 0;
static int pos = -1;           /* 当前显示条在 hist 中的下标 */

static void ts_(char *buf, size_t n)
{
    time_t t = time(NULL);
    struct tm tmv;
    localtime_r(&t, &tmv);
    strftime(buf, n, "%F %T", &tmv);
}

static void lg2(const char *msg)
{
    if (!lg) return;
    char ts[32];
    ts_(ts, sizeof(ts));
    fprintf(lg, "%s %s\n", ts, msg);
    fflush(lg);
}

/* ---- 历史: 不变式 0 <= pos < hn, hist[pos] == 当前显示条 ---- */

static void hist_shrink(void)          /* 空间满了丢最老的一半 */
{
    int cut = HIST_MAX / 2;
    memmove(hist, hist + cut, (hn - cut) * sizeof(int));
    hn -= cut;
    pos -= cut;
    if (pos < 0) pos = 0;
}

static void hist_append(int idx)       /* 随机新条: 截断前进历史后追加 */
{
    if (hn >= HIST_MAX - 1) hist_shrink();
    hn = pos + 1;                      /* 作废"未来" */
    hist[hn] = idx;
    hn++;
    pos = hn - 1;
}

static void hist_insert_front(int idx) /* 最早历史前插(到头继续翻页用) */
{
    if (hn >= HIST_MAX - 1) hist_shrink();
    memmove(hist + 1, hist, (size_t)hn * sizeof(int));
    hist[0] = idx;
    hn++;
    pos = 0;
}

static void show_idx(int idx)          /* 显示帧 idx + 写 state + 重画时间条 */
{
    char cmd[256];
    snprintf(cmd, sizeof(cmd), "%s -g %s/q_%03d.png", EIPS, FRAMES, idx);
    if (system(cmd) != -1) {
        FILE *sf = fopen(STATE, "w");
        if (sf) { fprintf(sf, "%d\n", idx); fclose(sf); }
        system(CLOCK " auto");         /* eips 全幅贴图会盖掉时钟条, 补一次 */
    }
}

static int recent_seen(int idx, int n) /* 最近 n 条(从当前位置往回)是否出现过 idx */
{
    int i, c = 0;
    for (i = pos; i >= 0 && c < n; i--, c++)
        if (hist[i] == idx) return 1;
    return 0;
}

static int pick_random(void)
{
    int cur = pos >= 0 ? hist[pos] : -1;
    int tries, idx;
    for (tries = 0; tries < 60; tries++) {          /* 严格: 避当前+避最近 AVOID 条 */
        idx = rand() % total;
        if (idx != cur && !recent_seen(idx, AVOID)) return idx;
    }
    for (tries = 0; tries < 60; tries++) {          /* 放宽: 只避当前 */
        idx = rand() % total;
        if (idx != cur) return idx;
    }
    return (cur + 1) % total;                       /* 兜底 */
}

static void nav_next(void)
{
    int idx = pick_random();
    hist_append(idx);
    show_idx(idx);
    {
        char buf[80];
        snprintf(buf, sizeof(buf), "nav next -> %d (pos=%d/%d)", idx, pos, hn);
        lg2(buf);
    }
}

static void nav_prev(void)
{
    if (pos > 0) {
        pos--;                                     /* 精确重放 */
        show_idx(hist[pos]);
        {
            char buf[80];
            snprintf(buf, sizeof(buf), "nav prev -> %d (pos=%d/%d)", hist[pos], pos, hn);
            lg2(buf);
        }
    } else {
        /* 已回退到最早一条: 按洗牌池顺序继续往前翻一页(确定性, 非随机),
           前插入历史——之后按"下一条"随机, 再按"上一条"仍精确重放 */
        int idx = (hist[0] + total - 1) % total;
        hist_insert_front(idx);
        show_idx(idx);
        {
            char buf[80];
            snprintf(buf, sizeof(buf), "nav prev(head) -> %d (pos=%d/%d)", idx, pos, hn);
            lg2(buf);
        }
    }
}

int main(void)
{
    setenv("TZ", "CST-8", 1);
    tzset();
    srand((unsigned)(time(NULL) ^ getpid()));

    lg = fopen(LOGF, "a");

    FILE *pp = popen("ls " FRAMES "/q_*.png 2>/dev/null | wc -l", "r");
    if (pp) {
        int v = 0;
        if (fscanf(pp, "%d", &v) == 1 && v > 0) total = v;
        pclose(pp);
    }

    /* 从 state 恢复: hist=[当前位置], pos=0 */
    int cur = 0;
    FILE *sf = fopen(STATE, "r");
    if (sf) { if (fscanf(sf, "%d", &cur) != 1) cur = 0; fclose(sf); }
    if (cur < 0 || cur >= total) cur = 0;
    hist[0] = cur;
    hn = 1;
    pos = 0;

    /* 关键: sigaction + flags=0 (无 SA_RESTART) —— 否则阻塞中的 read 被信号
       打断后自动重启, EINTR 永不出现, 导航标志无人检查 */
    {
        struct sigaction sa;
        memset(&sa, 0, sizeof(sa));
        sa.sa_handler = on_usr1;
        sigemptyset(&sa.sa_mask);
        sa.sa_flags = 0;
        sigaction(SIGUSR1, &sa, NULL);
        sa.sa_handler = on_usr2;
        sigaction(SIGUSR2, &sa, NULL);
    }

    FILE *pf = fopen(PIDF, "w");
    if (pf) { fprintf(pf, "%d\n", getpid()); fclose(pf); }

    int fd = open(EVDEV, O_RDONLY);
    if (fd < 0) {
        lg2("FATAL open event1");
        return 1;
    }

    struct input_absinfo ax, ay;
    memset(&ax, 0, sizeof(ax));
    memset(&ay, 0, sizeof(ay));
    ioctl(fd, EVIOCGABS(ABS_X), &ax);
    ioctl(fd, EVIOCGABS(ABS_Y), &ay);
    {
        char buf[160];
        snprintf(buf, sizeof(buf), "touchd start total=%d resume=%d xrange=%d..%d",
                 total, cur, ax.minimum, ax.maximum);
        lg2(buf);
    }

    struct input_event ev;
    int last_x = -1;
    int got_abs = 0;
    time_t last_act = 0;

    for (;;) {
        ssize_t r = read(fd, &ev, sizeof(ev));
        if (r < 0) {
            if (errno == EINTR) {
                if (req_next) { req_next = 0; nav_next(); }
                if (req_prev) { req_prev = 0; nav_prev(); }
                continue;
            }
            continue;
        }
        if (r != (ssize_t)sizeof(ev)) continue;

        if (req_next) { req_next = 0; nav_next(); }
        if (req_prev) { req_prev = 0; nav_prev(); }

        if (ev.type == EV_ABS &&
            (ev.code == ABS_X || ev.code == 0x35 /*ABS_MT_POSITION_X*/)) {
            last_x = ev.value;
            got_abs = 1;
        } else if (ev.type == EV_SYN && ev.code == SYN_REPORT) {
            if (!got_abs) continue;
            got_abs = 0;

            time_t now = time(NULL);
            if (now - last_act < 1) continue;          /* 去抖: 1s 内只翻一次 */

            int xn;
            if (ax.maximum > ax.minimum && (ax.maximum - ax.minimum) >= 100) {
                int span = ax.maximum - ax.minimum + 1;
                xn = (last_x - ax.minimum) * 600 / span;
            } else {
                xn = last_x;   /* 驱动未提供量程(实测 xrange=0..0), 原生 0..599 */
            }
            if (xn < 0) xn = 0;
            if (xn > 599) xn = 599;

            int dir = 0;
            if (xn < DEADL)      dir = -1;
            else if (xn > DEADR) dir = 1;

            if (dir) {
                char buf[96];
                snprintf(buf, sizeof(buf), "touch raw=%d xn=%d", last_x, xn);
                lg2(buf);
                if (dir < 0) nav_prev(); else nav_next();
                last_act = time(NULL);
            }
        }
    }
    return 0;
}

arm-linux-gnueabihf-gcc -static -O2 -o kd_touchd kd_touchd.c
scp kd_touchd root@<Kindle的IP>:/mnt/us/kd_bin/
# 注意: 覆盖"正在运行"的二进制会报 ETXTBSY —— 先传成 kd_touchd.new 再 mv 覆盖