AskaEth/MeowOS-SDK
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'feat/tuku-webtoon-mode-and-continuity'

Browse Source
This commit is contained in:
AskaEth committed 2026-11-05 11:39:24 +08:00
2 parents 8cbb240931 ff97f3cee7
commit 6caf2bc6e6
14 files changed
+2539 -93
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

tuku/logic/library.c
+115
View File
@@ -7,8 +7,14 @@
* 收进结果并自然排序——因此根视图不会列出后代条目，进入子目录时再重新扫描该层。
*
* 内存：条目数组倍增分配；路径/名称定长，随 mr_library_free() 释放。
*
* M7 追加（不改扫描语义）：
* - 续读角标：含图册的副标题后缀「· 续读 Pn」（读 logic/reader 的每册 last page）；
* - 册间衔接：mr_book_adjacent 给出同父目录下按书库自然序的相邻「含图册」，
* 供阅读器末页前进/首页后退跨册；mr_library_dir_has_images 是共享的「是不是一本书」判据。
*/
#include "library.h"
#include "logic/reader.h" /* mr_cont_badge：书库行续读角标（M7） */
#include <ctype.h>
#include <dirent.h>
@@ -215,6 +221,17 @@ int mr_library_scan(mr_library *lib, const char *dir, int max_depth)
else
snprintf(e.subtitle, sizeof e.subtitle, "%d folder%s", e.subdirs,
e.subdirs == 1 ? "" : "s");
/* 续读角标（M7）：有 last page 记录的册，在副标题后缀「· 续读 Pn」。
* config 读失败/无记录时 mr_cont_badge 返回 0，副标题保持原样。 */
if (e.has_images) {
char badge[24];
if (mr_cont_badge(e.path, badge, (int)sizeof badge)) {
int used = (int)strlen(e.subtitle);
if (used < (int)sizeof e.subtitle - 2)
snprintf(e.subtitle + used, sizeof e.subtitle - (size_t)used,
" · %s", badge);
}
}
if (lib_add(lib, &e) != 0) {
closedir(d);
mr_library_free(lib);
@@ -245,3 +262,101 @@ int mr_path_parent(const char *path, char *out, int outsz)
out[n] = '\0';
return 0;
}
/* ============================================================ */
/* 册间衔接（M7） */
/* ============================================================ */
int mr_library_dir_has_images(const char *dir)
{
if (!dir || !dir[0]) return 0;
DIR *d = opendir(dir);
if (!d) return 0;
int found = 0;
struct dirent *de;
while ((de = readdir(d)) != NULL) {
const char *name = de->d_name;
if (name[0] == '.' || !mr_path_is_image(name)) continue;
char full[MR_PATH_MAX];
if (join_path(full, (int)sizeof full, dir, name) != 0) continue;
struct stat st;
if (lstat(full, &st) != 0 || !S_ISREG(st.st_mode)) continue;
found = 1;
break;
}
closedir(d);
return found;
}
static int name_ptr_cmp(const void *pa, const void *pb)
{
const char *a = *(const char *const *)pa;
const char *b = *(const char *const *)pb;
return mr_natural_cmp(a, b);
}
int mr_book_adjacent(const char *dir, int delta, char *out, int outsz)
{
if (!out || outsz <= 0) return -1;
out[0] = '\0';
if (!dir || !dir[0] || (delta != 1 && delta != -1)) return -1;
char norm[MR_PATH_MAX];
size_t dl = strlen(dir);
while (dl > 1 && dir[dl - 1] == '/') dl--;
if (dl >= sizeof norm) return -1;
memcpy(norm, dir, dl);
norm[dl] = '\0';
const char *slash = strrchr(norm, '/');
if (!slash || !slash[1]) return -1;
const char *cur = slash + 1;
char parent[MR_PATH_MAX];
if (mr_path_parent(norm, parent, (int)sizeof parent) != 0) return -1;
DIR *d = opendir(parent);
if (!d) return 0;
char **names = NULL;
int n = 0, cap = 0;
struct dirent *de;
while ((de = readdir(d)) != NULL) {
const char *name = de->d_name;
if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue;
if (ignored_dir_name(name)) continue;
char full[MR_PATH_MAX];
if (join_path(full, (int)sizeof full, parent, name) != 0) continue;
struct stat st;
if (lstat(full, &st) != 0 || S_ISLNK(st.st_mode) || !S_ISDIR(st.st_mode)) continue;
if (!mr_library_dir_has_images(full)) continue; /* 只算「一本书」，中间目录跳过 */
if (n >= cap) {
int nc = cap ? cap * 2 : 16;
char **nn = (char **)realloc(names, (size_t)nc * sizeof *nn);
if (!nn) break;
names = nn;
cap = nc;
}
size_t len = strlen(name);
names[n] = (char *)malloc(len + 1);
if (!names[n]) break;
memcpy(names[n], name, len + 1);
n++;
}
closedir(d);
int rc = 0;
if (n > 1) qsort(names, (size_t)n, sizeof *names, name_ptr_cmp);
int idx = -1;
for (int i = 0; i < n; i++)
if (strcmp(names[i], cur) == 0) { idx = i; break; }
int target = idx + delta;
if (idx >= 0 && target >= 0 && target < n) {
if (join_path(out, outsz, parent, names[target]) == 0) rc = 1;
}
for (int i = 0; i < n; i++) free(names[i]);
free(names);
return rc;
}
tuku/logic/library.h
+12
View File
@@ -1,6 +1,8 @@
/* logic/library.h — 漫画书库扫描/排序（纯 C，不依赖 meow_ui.h）。
*
* 分层契约同 examples/hello：logic 层只含文件系统与纯数据，宿主 gcc 可直接裸测。
* （M7 起另提供每册续读角标与册间顺序查询；续读状态本身由 logic/reader.c 持久化，
* 本层只读它来拼副标题，宿主测试用配置存根顶替。）
* 书库语义：
* - 从 TF 卡根（MR_ROOT_DIR）起列「直接子目录」；
* - 只保留自身含 PNG/JPEG/BMP 的目录，或子树中最终含图的中间目录（可继续导航）；
@@ -57,6 +59,16 @@ void mr_library_free(mr_library *lib);
* 成功 0；参数非法/输出缓冲不足 -1。 */
int mr_path_parent(const char *path, char *out, int outsz);
/* 目录是否**直接**含受支持图片（= 书库语义里的「一本书」，可直接进 reader）。
* 1=有；0=没有/不可读。 */
int mr_library_dir_has_images(const char *dir);
/* 册间衔接（M7）：同父目录下按书库自然序排列的「直接含图」兄弟册。
* delta=+1 下一册 / -1 上一册。1=找到并写入 out 完整路径；
* 0=没有相邻册（当前册是首/末册，或当前册不在兄弟表中）；-1=参数非法。
* 语义与书库一致：跳过隐藏/系统目录与符号链接，排序同 mr_natural_cmp。 */
int mr_book_adjacent(const char *dir, int delta, char *out, int outsz);
#ifdef __cplusplus
}
#endif
tuku/logic/reader.c
+124 -1
View File
@@ -1,10 +1,12 @@
/* logic/reader.c — 阅读方向状态（默认 RTL；M4/M6 的阅读器直接复用）。
/* logic/reader.c — 阅读方向状态（默认 RTL；M4/M6 的阅读器直接复用）+ 每册续读状态（M7）。
*
* M5 评审 P1 修复：方向设置要「下次启动生效」。最小持久化（不新增任何方向状态）：
* - mr_reader_set_direction 成功切换后 best-effort 写 meow_config("reader.dir","rtl"/"ltr")；
* 写失败只打 WARN，不阻断切换（本次运行仍生效）；
* - mr_reader_get_direction 首次调用惰性读一次配置恢复；无配置/值非法 → 默认 RTL；
* 之后走纯内存快路径（不再读配置）。
* M7：阅读模式（翻页/条漫）与每册 last page 同为 meow_config 小键（reader.mode/page.<册标识>，
* 册标识=规范化目录路径的 FNV-1a64）；书库行角标经 mr_cont_badge 读取同一份状态。
* 依赖面：只 include 配置/日志两个模块头（不含 UI）；宿主测试用
* test/settings_reader_stub.c 顶替 meow_config_* 与 meow_log。
*/
@@ -12,6 +14,8 @@
#include "include/meow_ui_config.h"
#include "include/meow_ui_log.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MR_DIR_CFG_KEY "reader.dir"
@@ -59,3 +63,122 @@ void mr_reader_test_reset(void)
g_restored = 0;
}
#endif
/* ============================================================ */
/* 阅读模式 + 每册续读状态（M7） */
/* ============================================================ */
int mr_mode_valid(int mode)
{
return mode == MR_MODE_PAGED || mode == MR_MODE_WEBTOON;
}
const char *mr_mode_name(int mode)
{
return mode == MR_MODE_WEBTOON ? "webtoon" : "paged";
}
int mr_mode_parse(const char *s)
{
if (!s) return -1;
if (strcmp(s, "paged") == 0) return MR_MODE_PAGED;
if (strcmp(s, "webtoon") == 0) return MR_MODE_WEBTOON;
return -1;
}
/* 目录规范化：去掉末尾 '/'（根 "/" 保留），保证同一册跨调用/跨启动得到同一键。 */
static void cont_norm_dir(const char *dir, char *out, int outsz)
{
if (!out || outsz <= 0) return;
out[0] = '\0';
if (!dir || !dir[0]) return;
int n = (int)strlen(dir);
while (n > 1 && dir[n - 1] == '/') n--;
if (n >= outsz) n = outsz - 1;
memcpy(out, dir, (size_t)n);
out[n] = '\0';
}
static unsigned long long cont_fnv1a64(const char *s)
{
unsigned long long h = 1469598103934665603ULL;
for (const unsigned char *p = (const unsigned char *)s; *p; p++) {
h ^= (unsigned long long)*p;
h *= 1099511628211ULL;
}
return h;
}
int mr_cont_key(const char *dir, const char *field, char *out, int outsz)
{
if (!out || outsz <= 0) return -1;
out[0] = '\0';
if (!dir || !dir[0] || !field || !field[0]) return -1;
char norm[MR_CONT_PATH_MAX];
cont_norm_dir(dir, norm, (int)sizeof norm);
if (!norm[0]) return -1;
int n = snprintf(out, (size_t)outsz, "reader.%s.%016llx", field, cont_fnv1a64(norm));
if (n <= 0 || n >= outsz) { out[0] = '\0'; return -1; }
return 0;
}
int mr_cont_get_page(const char *dir, int def)
{
char key[64];
char buf[24];
if (mr_cont_key(dir, "page", key, (int)sizeof key) != 0) return def;
if (meow_config_get(key, buf, (int)sizeof buf) != MEOW_CFG_OK) return def;
char *end = NULL;
long v = strtol(buf, &end, 10);
if (end == buf || (end && *end != '\0')) return def;
if (v < 0 || v > MR_CONT_PAGE_MAX) return def;
return (int)v;
}
void mr_cont_set_page(const char *dir, int page)
{
char key[64];
char val[24];
if (page < 0) page = 0;
if (page > MR_CONT_PAGE_MAX) page = MR_CONT_PAGE_MAX;
if (mr_cont_key(dir, "page", key, (int)sizeof key) != 0) return;
snprintf(val, sizeof val, "%d", page);
if (meow_config_set(key, val) != MEOW_CFG_OK)
meow_log(MEOW_LOG_WARN, "reader: save page failed (best-effort)");
}
int mr_cont_get_mode(const char *dir, int def)
{
char key[64];
char buf[16];
if (!mr_mode_valid(def)) def = MR_MODE_PAGED;
if (mr_cont_key(dir, "mode", key, (int)sizeof key) != 0) return def;
if (meow_config_get(key, buf, (int)sizeof buf) != MEOW_CFG_OK) return def;
int m = mr_mode_parse(buf);
return m >= 0 ? m : def;
}
void mr_cont_set_mode(const char *dir, int mode)
{
char key[64];
if (!mr_mode_valid(mode)) return;
if (mr_cont_key(dir, "mode", key, (int)sizeof key) != 0) return;
if (meow_config_set(key, mr_mode_name(mode)) != MEOW_CFG_OK)
meow_log(MEOW_LOG_WARN, "reader: save mode failed (best-effort)");
}
void mr_cont_save(const char *dir, int page, int mode)
{
if (!dir || !dir[0]) return;
mr_cont_set_page(dir, page);
mr_cont_set_mode(dir, mode);
}
int mr_cont_badge(const char *dir, char *out, int outsz)
{
if (!out || outsz <= 0) return 0;
out[0] = '\0';
int page = mr_cont_get_page(dir, -1);
if (page <= 0) return 0;
snprintf(out, (size_t)outsz, "续读 P%d", page + 1);
return 1;
}
tuku/logic/reader.h
+32 -1
View File
@@ -1,6 +1,7 @@
/* logic/reader.h — 阅读器纯逻辑接缝（M4 填充实现，M3 先落状态 API）。
/* logic/reader.h — 阅读器纯逻辑接缝（M4 填充实现，M3 先落状态 API；M7 追加模式与每册续读状态）。
*
* 阅读方向默认 RTL（日式漫画从右往左翻）；设置页/阅读器可切 LTR。
* 阅读模式（翻页/条漫）与每册 last page 走 meow_config 持久化，键含册标识。
* 本模块保持纯 C（不 include meow_ui.h），宿主可直接测。
*/
#ifndef MR_READER_H
@@ -17,6 +18,36 @@ int mr_reader_get_direction(void);
/* 只接受 MR_DIR_RTL / MR_DIR_LTR；其它值忽略（保持原方向）。 */
void mr_reader_set_direction(int dir);
/* ============================================================ */
/* 阅读模式（M7）：左右翻页 / 条漫竖向连续滚动 */
/* ============================================================ */
#define MR_MODE_PAGED 0 /* 左右翻页（默认） */
#define MR_MODE_WEBTOON 1 /* 条漫：垂直连续滚动 */
int mr_mode_valid(int mode);
const char *mr_mode_name(int mode); /* "paged" / "webtoon"（配置值；非法按 paged） */
int mr_mode_parse(const char *s); /* -1=未知 */
/* ============================================================ */
/* 每册续读状态（last page + mode，meow_config 持久化） */
/* ------------------------------------------------------------
* 键 = reader.<field>.<FNV-1a64(规范化目录路径)>：同一册（同一目录）跨启动恢复，
* 不同册互不影响；目录改名/移动视为新册。写失败只 WARN（best-effort，不阻断阅读）。
* 依赖：只 include 配置/日志两个模块头，宿主测试用 settings_reader_stub 顶替。
* ============================================================ */
#define MR_CONT_PATH_MAX 512 /* 册路径规范化的本地缓冲（同 MR_PATH_MAX 口径） */
#define MR_CONT_PAGE_MAX 1000000 /* 配置里 last page 的合理上限（防坏值） */
int mr_cont_key(const char *dir, const char *field, char *out, int outsz);
int mr_cont_get_mode(const char *dir, int def);
void mr_cont_set_mode(const char *dir, int mode);
int mr_cont_get_page(const char *dir, int def);
void mr_cont_set_page(const char *dir, int page);
/* 一次写 page+mode（尽最大努力，两键分别尝试）。 */
void mr_cont_save(const char *dir, int page, int mode);
/* 书库行续读角标：1=写入 "续读 P5"（page>0 才有记录）；0=无。 */
int mr_cont_badge(const char *dir, char *out, int outsz);
#ifdef __cplusplus
}
#endif
tuku/logic/reader/nav.c
+209
View File
@@ -1,5 +1,8 @@
/* logic/reader/nav.c — 阅读导航纯逻辑实现（见 nav.h 的方向语义说明）。 */
#include "logic/reader/nav.h"
#include "logic/reader/page_source.h" /* MR_BOOK_MAX_PAGES（条漫排版页数上限） */
#include <stdlib.h>
int mr_nav_tap_zone(int x, int view_w)
{
@@ -118,3 +121,209 @@ int mr_nav_fit_next(int fit)
if (fit < 0 || fit >= MR_FIT_COUNT) return MR_FIT_WIDTH;
return (fit + 1) % MR_FIT_COUNT;
}
/* ============================================================ */
/* 条漫排版 / 滚动窗口 */
/* ============================================================ */
static int strip_page_height(int src_w, int src_h, int vw)
{
long long h;
if (vw <= 0) vw = 1;
if (src_w > 0 && src_h > 0)
h = (long long)src_h * vw / src_w; /* 适宽等比 */
else
h = (long long)vw * 3 / 2; /* 未知尺寸：2:3 竖图占位 */
if (h < 1) h = 1;
if (h > MR_STRIP_MAX_PAGE_H) h = MR_STRIP_MAX_PAGE_H;
return (int)h;
}
void mr_strip_free(mr_strip *s)
{
if (!s) return;
free(s->top);
free(s->height);
s->top = NULL;
s->height = NULL;
s->count = s->total = 0;
s->vw = s->vh = 0;
}
int mr_strip_build(mr_strip *s, int count, int vw, int vh,
mr_strip_meta_fn meta, void *ctx)
{
if (!s) return -1;
mr_strip_free(s);
if (count <= 0 || count > MR_BOOK_MAX_PAGES || vw <= 0 || vh <= 0) return -1;
s->top = (int *)calloc((size_t)count + 1, sizeof *s->top);
s->height = (int *)calloc((size_t)count, sizeof *s->height);
if (!s->top || !s->height) { mr_strip_free(s); return -1; }
s->count = count;
s->vw = vw;
s->vh = vh;
long long y = 0;
for (int i = 0; i < count; i++) {
int sw = 0, sh = 0;
if (meta && !meta(ctx, i, &sw, &sh)) { sw = sh = 0; } /* 未知/失败 → 占位 */
int h = strip_page_height(sw, sh, vw);
s->height[i] = h;
s->top[i] = (int)y;
y += h;
if (y > 1000000000LL) { /* 累计偏移上限（防溢出；正常书远达不到） */
y = 1000000000LL;
for (int k = i + 1; k < count; k++) {
s->height[k] = 1;
s->top[k] = (int)y;
y += 1;
if (y > 1000000000LL) y = 1000000000LL;
}
s->top[count] = (int)y;
s->total = (int)y;
return 0;
}
}
s->top[count] = (int)y;
s->total = (int)y;
return 0;
}
int mr_strip_page_h(const mr_strip *s, int index)
{
if (!s || !s->height || index < 0 || index >= s->count) return 0;
return s->height[index];
}
int mr_strip_top(const mr_strip *s, int index)
{
if (!s || !s->top || index < 0 || index > s->count) return 0;
return s->top[index];
}
int mr_strip_total(const mr_strip *s)
{
return s ? s->total : 0;
}
int mr_strip_max_offset(const mr_strip *s)
{
if (!s || s->count <= 0) return 0;
int m = s->total - s->vh;
return m > 0 ? m : 0;
}
int mr_strip_page_at(const mr_strip *s, int off)
{
if (!s || s->count <= 0 || !s->top) return -1;
if (off <= 0) return 0;
if (off >= s->total) return s->count - 1;
int lo = 0, hi = s->count - 1;
while (lo < hi) { /* 最大的 top[i] <= off */
int mid = lo + (hi - lo + 1) / 2;
if (s->top[mid] <= off) lo = mid;
else hi = mid - 1;
}
return lo;
}
int mr_strip_offset_for_page(const mr_strip *s, int page)
{
if (!s || s->count <= 0) return -1;
if (page < 0) page = 0;
if (page >= s->count) page = s->count - 1;
int off = s->top[page];
int m = mr_strip_max_offset(s);
if (off > m) off = m;
if (off < 0) off = 0;
return off;
}
int mr_strip_window(const mr_strip *s, int off, int max_pages,
int *first, int *last)
{
if (first) *first = 0;
if (last) *last = -1;
if (!s || s->count <= 0) return 0;
if (max_pages <= 0) max_pages = 1;
int m = mr_strip_max_offset(s);
if (off < 0) off = 0;
if (off > m) off = m;
int f = mr_strip_page_at(s, off);
int l = mr_strip_page_at(s, off + s->vh - 1);
if (l < f) l = f;
int lo = f - 1; /* 视口 ±1 页 */
int hi = l + 1;
if (lo < 0) lo = 0;
if (hi > s->count - 1) hi = s->count - 1;
if (hi - lo + 1 > max_pages) { /* 驻留上限：从视口中心向外截 */
int center = (f + l) / 2;
lo = center - (max_pages - 1) / 2;
hi = lo + max_pages - 1;
if (lo < 0) { lo = 0; hi = max_pages - 1; }
if (hi > s->count - 1) { hi = s->count - 1; lo = hi - max_pages + 1; }
if (lo < 0) lo = 0;
}
if (first) *first = lo;
if (last) *last = hi;
return hi - lo + 1;
}
int mr_strip_at_end(const mr_strip *s, int off)
{
if (!s || s->count <= 0) return 0;
return off >= mr_strip_max_offset(s);
}
int mr_strip_at_start(const mr_strip *s, int off)
{
if (!s || s->count <= 0) return 0;
return off <= 0;
}
/* ============================================================ */
/* 跳页状态 */
/* ============================================================ */
void mr_jump_cancel(mr_jump *j)
{
if (!j) return;
j->pending = 0;
j->target = -1;
j->t0 = 0;
}
void mr_jump_begin(mr_jump *j, int page, int count, unsigned long long now)
{
if (!j) return;
if (count <= 0 || page < 0 || page >= count) { mr_jump_cancel(j); return; }
j->pending = 1;
j->target = page;
j->t0 = now;
}
int mr_jump_active(const mr_jump *j)
{
return j && j->pending ? 1 : 0;
}
int mr_jump_target(const mr_jump *j)
{
return (j && j->pending) ? j->target : -1;
}
int mr_jump_poll(mr_jump *j, int have_img, unsigned long long now,
unsigned long long timeout_ms, int *timed_out)
{
if (timed_out) *timed_out = 0;
if (!j || !j->pending) return 0;
if (have_img) { mr_jump_cancel(j); return 1; }
if (timeout_ms > 0 && now - j->t0 >= timeout_ms) {
mr_jump_cancel(j);
if (timed_out) *timed_out = 1;
return 1;
}
return 0;
}
tuku/logic/reader/nav.h
+59
View File
@@ -64,6 +64,65 @@ int mr_nav_slide_from(int rtl, int delta, int view_w);
/* fit 档循环：适宽 → 适高 → 原始 → 适宽。 */
int mr_nav_fit_next(int fit);
/* ============================================================ */
/* 条漫（M7）：竖向连续滚动的排版 / 滚动窗口 / 跳页状态 */
/* ------------------------------------------------------------
* 排版用页源契约的 meta()（原始像素尺寸，不解码）：每页按屏宽等比换算显示高度，
* 累加成「整条」的 y 偏移表。未知尺寸的页按 2:3 竖图占位（排版稳定，解码后不改布局）。
* 全部纯整数运算、无 SDK 依赖；reader.c 与宿主测试共用（logic/reader/nav.c）。
* ============================================================ */
#define MR_STRIP_MAX_PAGE_H 200000 /* 单页显示高度上限（防坏头/极端长图撑爆累计偏移） */
typedef struct mr_strip {
int count;
int vw, vh;
int *top; /* count+1 个：top[i]=第 i 页顶端偏移；top[count]=整条总高 */
int *height; /* count 个：每页显示高度（>=1） */
int total;
} mr_strip;
/* 页尺寸回调（通常是 mr_book_meta）：1=已知原始尺寸，0=未知。 */
typedef int (*mr_strip_meta_fn)(void *ctx, int index, int *w, int *h);
/* 建排版表。0=成功；参数非法/内存不足 -1（已清空、可安全 free）。 */
int mr_strip_build(mr_strip *s, int count, int vw, int vh,
mr_strip_meta_fn meta, void *ctx);
/* 释放偏移表并清零（可重复调用）。 */
void mr_strip_free(mr_strip *s);
int mr_strip_page_h(const mr_strip *s, int index); /* 越界 0 */
int mr_strip_top(const mr_strip *s, int index); /* index==count 返回总高；越界 0 */
int mr_strip_total(const mr_strip *s);
int mr_strip_max_offset(const mr_strip *s); /* max(0, total-vh) */
/* 视口顶端（off）落在哪一页；空册 -1。 */
int mr_strip_page_at(const mr_strip *s, int off);
/* 落位到某页顶端所需的滚动量（夹到 [0,max_offset]）；空册 -1。 */
int mr_strip_offset_for_page(const mr_strip *s, int page);
/* 视口可见页范围 [first,last] + ±1 解码窗，条数不超过 max_pages。
* 返回窗口页数；空册 0。first/last 可 NULL。 */
int mr_strip_window(const mr_strip *s, int off, int max_pages,
int *first, int *last);
int mr_strip_at_end(const mr_strip *s, int off); /* 1=已到条底 */
int mr_strip_at_start(const mr_strip *s, int off); /* 1=已在条顶 */
/* ---- 跳页（chrome 滑块）：目标页预解码完成后再落位，避免白屏/闪烁 ---- */
typedef struct mr_jump {
int pending; /* 1=正在等目标页 */
int target; /* 目标页；pending==0 时无意义 */
unsigned long long t0; /* 开始等待的时刻（ms） */
} mr_jump;
/* 开始跳页：page 夹到 [0,count)；count<=0 或 page<0 时取消。 */
void mr_jump_begin(mr_jump *j, int page, int count, unsigned long long now);
int mr_jump_active(const mr_jump *j);
int mr_jump_target(const mr_jump *j); /* 无 pending 返回 -1 */
void mr_jump_cancel(mr_jump *j);
/* 轮询：have_img=目标页是否已解码。1=可以落位（已清除 pending）；
* timed_out 非 NULL 时写入「是否因超时落位」（调用方据此提示降级）。
* 未就绪且未超时返回 0（继续等）。 */
int mr_jump_poll(mr_jump *j, int have_img, unsigned long long now,
unsigned long long timeout_ms, int *timed_out);
#ifdef __cplusplus
}
#endif
tuku/test/run_webtoon_tests.sh
Executable
+47
View File
@@ -0,0 +1,47 @@
#!/bin/bash
# run_webtoon_tests.sh — M7 条漫/模式/续读/跳页宿主测试（纯 C，不链 SDK、不需要设备）。
# - test_webtoon_strip：条漫排版（适宽高度/偏移表/可见窗口/未知尺寸兜底/跳页互逆）
# - test_jump_page：跳页状态机（预解码落位/超时降级/非法目标）与落位偏移映射
# - test_mode_persist：阅读模式与每册 last page 的 meow_config 持久化/坏值/写失败
# - test_cont_adjacent：册间自然序边界（首/末册/嵌套/符号链接）+ 书库续读角标
# 编译口径同 test/run_tests.sh（-I. + SDK 头，不链 meow_ui.a；配置/日志用存根）。
set -e
cd "$(dirname "$0")/.."
SDK="${MEOW_SDK_DIR:-$HOME/Proj/MeowOS-SDK/sdk}"
CFLAGS="-Wall -Wextra -O1 -I. -I$SDK"
OUT="build/host"
mkdir -p "$OUT"
gcc $CFLAGS test/test_webtoon_strip.c logic/reader/nav.c -o "$OUT/test_webtoon_strip"
"$OUT/test_webtoon_strip"
gcc $CFLAGS test/test_jump_page.c logic/reader/nav.c -o "$OUT/test_jump_page"
"$OUT/test_jump_page"
gcc $CFLAGS test/test_mode_persist.c logic/reader.c test/settings_reader_stub.c \
-o "$OUT/test_mode_persist"
"$OUT/test_mode_persist"
gcc $CFLAGS test/test_cont_adjacent.c logic/library.c logic/reader.c \
test/settings_reader_stub.c -o "$OUT/test_cont_adjacent"
"$OUT/test_cont_adjacent"
# 可选：真实 SDK 源码树上的阅读器集成测试（模式切换/续读/跳页/册间衔接）。
# 只发布 meow_ui.a 的交付环境自动 SKIP（与 test/run_tests.sh 的 settings_lock_host 同口径）。
if [ -f "$SDK/meow_ui_view.c" ] && [ -f "$SDK/meow_ui_config.c" ]; then
gcc $CFLAGS -DMEOW_UI_HOST_TEST -DMR_READER_HOST_TEST -I"$SDK/include" \
test/test_mode_switch_host.c ui/reader/reader.c \
logic/library.c logic/reader.c logic/reader/page_source.c logic/reader/nav.c \
"$SDK"/meow_ui_gfx.c "$SDK"/meow_ui_sys.c "$SDK"/meow_ui_theme.c \
"$SDK"/meow_ui_vol.c "$SDK"/meow_ui_log.c "$SDK"/meow_ui_widget.c \
"$SDK"/meow_ui_input.c "$SDK"/meow_ui_activity.c "$SDK"/meow_ui_dialog.c \
"$SDK"/meow_ui_ime.c "$SDK"/meow_ui_str.c "$SDK"/meow_pinyin.c \
"$SDK"/meow_ui_draw.c "$SDK"/meow_ui_view.c "$SDK"/meow_ui_box.c \
"$SDK"/meow_ui_anim.c "$SDK"/meow_ui_scroll.c "$SDK"/meow_ui_img.c \
"$SDK"/meow_ui_media.c "$SDK"/meow_notify_ipc.c "$SDK"/meow_ui_config.c \
"$SDK"/meow_ui_nav.c "$SDK"/stb_image.c "$SDK"/test_host_stub.c \
-pthread -lm -o "$OUT/test_mode_switch_host"
"$OUT/test_mode_switch_host"
else
echo "SKIP test_mode_switch_host: SDK 源码树不可用（只发布 meow_ui.a 的环境）"
fi
tuku/test/test_cont_adjacent.c
+249
View File
@@ -0,0 +1,249 @@
/* test_cont_adjacent.c — 册间顺序边界 + 书库续读角标宿主测试（无 SDK/硬件）。
*
* 覆盖：
* A1 「直接含图」判定：含图目录=书；只有子目录含图/空目录/仅非图文件=不是书；
* A2 兄弟册排序：同父目录、书库自然序（vol2 < vol10）；首/末册无相邻返回 0；
* A3 边界：末页前进→下一册、首页后退→上一册（调用方语义）；路径末尾斜杠等价；
* A4 排除：隐藏/系统目录、符号链接、普通文件不参与兄弟册；
* A5 参数：delta 非 ±1、NULL/小缓冲、不存在的目录；
* A6 书库扫描接线：有续读记录的册，行副标题出现「· 续读 Pn」角标。
*
* 编译（在 tuku/ 下）：
* gcc -Wall -Wextra -O1 -I. test/test_cont_adjacent.c logic/library.c logic/reader.c \
* test/settings_reader_stub.c -o test/test_cont_adjacent
* 或 test/run_webtoon_tests.sh。
*/
#include "logic/library.h"
#include "logic/reader.h"
#include "test/settings_reader_stub.h"
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
static int g_pass, g_fail;
#define CHECK(cond, ...) do { \
if (cond) { g_pass++; } \
else { g_fail++; printf("FAIL %s:%d ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
} while (0)
static int mkdir_p(const char *path)
{
char tmp[MR_PATH_MAX];
snprintf(tmp, sizeof tmp, "%s", path);
for (size_t i = 1; i <= strlen(tmp); i++) {
if (tmp[i] == '/' || tmp[i] == '\0') {
char ch = tmp[i];
tmp[i] = '\0';
if (mkdir(tmp, 0755) != 0) {
struct stat st;
if (stat(tmp, &st) != 0 || !S_ISDIR(st.st_mode)) return -1;
}
tmp[i] = ch;
}
}
return 0;
}
static int touch_file(const char *path)
{
FILE *f = fopen(path, "wb");
if (!f) return -1;
int ok = fwrite("x", 1, 1, f) == 1;
fclose(f);
return ok ? 0 : -1;
}
static int rm_rf(const char *path)
{
struct stat st;
if (lstat(path, &st) != 0) return -1;
if (!S_ISDIR(st.st_mode)) return unlink(path);
DIR *d = opendir(path);
if (!d) return -1;
struct dirent *de;
while ((de = readdir(d)) != NULL) {
if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
char full[MR_PATH_MAX];
snprintf(full, sizeof full, "%s/%s", path, de->d_name);
rm_rf(full);
}
closedir(d);
return rmdir(path);
}
static void joinp(char *out, int outsz, const char *a, const char *b)
{
snprintf(out, (size_t)outsz, "%s/%s", a, b);
}
static void test_has_images(const char *root)
{
char p[MR_PATH_MAX];
CHECK(mr_library_dir_has_images(root) == 1,
"root has a loose image file (scan/adjacency only treats subdirs as books)");
joinp(p, sizeof p, root, "vol1");
CHECK(mr_library_dir_has_images(p) == 1, "vol1 is a book");
joinp(p, sizeof p, root, "dirs_only");
CHECK(mr_library_dir_has_images(p) == 0, "dirs_only is not a book");
joinp(p, sizeof p, root, "empty");
CHECK(mr_library_dir_has_images(p) == 0, "empty is not a book");
joinp(p, sizeof p, root, "txonly");
CHECK(mr_library_dir_has_images(p) == 0, "text-only dir is not a book");
CHECK(mr_library_dir_has_images("/no/such/dir/xyz") == 0, "missing dir");
CHECK(mr_library_dir_has_images(NULL) == 0 && mr_library_dir_has_images("") == 0,
"NULL/empty safe");
}
static void expect_neighbor(const char *dir, int delta, const char *want, const char *tag)
{
char out[MR_PATH_MAX];
int r = mr_book_adjacent(dir, delta, out, (int)sizeof out);
if (!want) {
CHECK(r == 0 && out[0] == '\0', "%s: no neighbor (r=%d out=%s)", tag, r, out);
} else {
CHECK(r == 1 && strcmp(out, want) == 0, "%s: got %s (want %s)", tag, out, want);
}
}
static void test_adjacent(const char *root)
{
char vol1[MR_PATH_MAX], vol2[MR_PATH_MAX], vol10[MR_PATH_MAX];
char series_a[MR_PATH_MAX], series_b[MR_PATH_MAX];
char dirs_only[MR_PATH_MAX], out[MR_PATH_MAX];
joinp(vol1, sizeof vol1, root, "vol1");
joinp(vol2, sizeof vol2, root, "vol2");
joinp(vol10, sizeof vol10, root, "vol10");
joinp(series_a, sizeof series_a, root, "series/a");
joinp(series_b, sizeof series_b, root, "series/b");
joinp(dirs_only, sizeof dirs_only, root, "dirs_only");
/* 自然序：vol1 < vol2 < vol10（vol0 是符号链接，不参与） */
expect_neighbor(vol1, 1, vol2, "vol1 next");
expect_neighbor(vol2, 1, vol10, "vol2 next");
expect_neighbor(vol10, 1, NULL, "vol10 next (end)");
expect_neighbor(vol1, -1, NULL, "vol1 prev (start)");
expect_neighbor(vol2, -1, vol1, "vol2 prev");
expect_neighbor(vol10, -1, vol2, "vol10 prev");
/* 末尾斜杠等价 */
char slash[MR_PATH_MAX];
snprintf(slash, sizeof slash, "%s/", vol2);
expect_neighbor(slash, 1, vol10, "trailing slash next");
expect_neighbor(slash, -1, vol1, "trailing slash prev");
/* 嵌套父目录：series/a <-> series/b */
expect_neighbor(series_a, 1, series_b, "series a next");
expect_neighbor(series_b, -1, series_a, "series b prev");
expect_neighbor(series_b, 1, NULL, "series b next (end)");
/* 不是书的目录：不在兄弟表中 */
expect_neighbor(dirs_only, 1, NULL, "dirs_only not a book");
expect_neighbor(dirs_only, -1, NULL, "dirs_only not a book prev");
/* 路径参数：delta/缓冲/不存在 */
CHECK(mr_book_adjacent(vol1, 0, out, (int)sizeof out) == -1, "delta 0 invalid");
CHECK(mr_book_adjacent(vol1, 2, out, (int)sizeof out) == -1, "delta 2 invalid");
CHECK(mr_book_adjacent(vol1, -2, out, (int)sizeof out) == -1, "delta -2 invalid");
CHECK(mr_book_adjacent(NULL, 1, out, (int)sizeof out) == -1, "NULL dir");
CHECK(mr_book_adjacent(vol1, 1, NULL, 32) == -1, "NULL out");
CHECK(mr_book_adjacent(vol1, 1, out, 4) == 0, "small out -> no fit (0)");
CHECK(mr_book_adjacent("/no/such/book", 1, out, (int)sizeof out) == 0,
"missing parent -> 0");
CHECK(mr_book_adjacent("/", 1, out, (int)sizeof out) == -1, "root path invalid");
}
static void test_library_badge(const char *root)
{
mr_test_cfg_clear();
char vol1[MR_PATH_MAX], vol2[MR_PATH_MAX];
joinp(vol1, sizeof vol1, root, "vol1");
joinp(vol2, sizeof vol2, root, "vol2");
/* vol1 有续读记录（第 5 页），vol2 没有 */
mr_cont_save(vol1, 4, MR_MODE_WEBTOON);
mr_library lib;
memset(&lib, 0, sizeof lib);
int n = mr_library_scan(&lib, root, MR_LIB_MAX_DEPTH);
CHECK(n > 0, "library scan n=%d", n);
int seen1 = 0, seen2 = 0;
for (int i = 0; i < lib.count; i++) {
mr_library_entry *e = &lib.items[i];
if (strcmp(e->name, "vol1") == 0) {
seen1 = 1;
CHECK(strstr(e->subtitle, "续读 P5") != NULL, "vol1 subtitle=%s", e->subtitle);
CHECK(strstr(e->subtitle, "page") != NULL, "vol1 keeps pages text: %s", e->subtitle);
}
if (strcmp(e->name, "vol2") == 0) {
seen2 = 1;
CHECK(strstr(e->subtitle, "续读") == NULL, "vol2 no badge: %s", e->subtitle);
CHECK(strcmp(e->subtitle, "1 page") == 0, "vol2 subtitle=%s", e->subtitle);
}
}
CHECK(seen1 == 1, "vol1 listed");
CHECK(seen2 == 1, "vol2 listed");
mr_library_free(&lib);
/* 记录清除后角标消失 */
mr_cont_save(vol1, 0, MR_MODE_WEBTOON);
memset(&lib, 0, sizeof lib);
CHECK(mr_library_scan(&lib, root, MR_LIB_MAX_DEPTH) > 0, "rescan");
for (int i = 0; i < lib.count; i++)
if (strcmp(lib.items[i].name, "vol1") == 0)
CHECK(strstr(lib.items[i].subtitle, "续读") == NULL, "cleared badge gone");
mr_library_free(&lib);
}
int main(void)
{
char tmpl[] = "./mr_cont_adj_XXXXXX";
char *root = mkdtemp(tmpl);
CHECK(root != NULL, "mkdtemp");
if (!root) return 1;
char p[MR_PATH_MAX];
const char *books[] = { "vol1", "vol2", "vol10", "series/a", "series/b", "dirs_only/inside" };
for (unsigned i = 0; i < sizeof books / sizeof books[0]; i++) {
joinp(p, sizeof p, root, books[i]);
CHECK(mkdir_p(p) == 0, "mkdir %s", p);
char img[MR_PATH_MAX];
joinp(img, sizeof img, p, "001.png");
CHECK(touch_file(img) == 0, "image %s", img);
}
joinp(p, sizeof p, root, "empty");
mkdir_p(p);
joinp(p, sizeof p, root, "txonly");
mkdir_p(p);
joinp(p, sizeof p, root, "txonly/readme.txt");
touch_file(p);
joinp(p, sizeof p, root, ".hidden");
mkdir_p(p);
joinp(p, sizeof p, root, ".hidden/001.png");
touch_file(p);
joinp(p, sizeof p, root, "MeowOS");
mkdir_p(p);
joinp(p, sizeof p, root, "MeowOS/001.png");
touch_file(p);
joinp(p, sizeof p, root, "loose.png");
touch_file(p);
char vol1[MR_PATH_MAX], vol0[MR_PATH_MAX];
joinp(vol1, sizeof vol1, root, "vol1");
joinp(vol0, sizeof vol0, root, "vol0");
if (symlink(vol1, vol0) == 0) { /* 有权限才测；无权限时 symlink 失败也不影响上面的断言 */ }
test_has_images(root);
test_adjacent(root);
test_library_badge(root);
rm_rf(root);
printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
return g_fail ? 1 : 0;
}
tuku/test/test_jump_page.c
+140
View File
@@ -0,0 +1,140 @@
/* test_jump_page.c — 跳页状态机 + 条漫落位映射宿主测试（无 SDK/硬件）。
*
* 覆盖：
* J1 跳页状态：begin 夹取/非法取消、active/target、预解码就绪落位、超时降级落位；
* J2 落位映射：mr_strip_offset_for_page 与 page_at 互逆（首/中/末页，max 夹取）；
* J3 边界：空册/越界/重复取消；正常等待不提前落位（不白屏——没有图就不落）。
*
* 编译（在 tuku/ 下）：
* gcc -Wall -Wextra -O1 -I. test/test_jump_page.c logic/reader/nav.c \
* -o test/test_jump_page && ./test/test_jump_page
* 或 test/run_webtoon_tests.sh。
*/
#include "logic/reader/nav.h"
#include <stdio.h>
#include <string.h>
static int g_pass, g_fail;
#define CHECK(cond, ...) do { \
if (cond) { g_pass++; } \
else { g_fail++; printf("FAIL %s:%d ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
} while (0)
#define VW 480
#define VH 720
#define TIMEOUT 2500ULL
static int g_meta_w[8], g_meta_h[8], g_meta_n;
static int meta_cb(void *ctx, int i, int *w, int *h)
{
(void)ctx;
if (i < 0 || i >= g_meta_n) return 0;
*w = g_meta_w[i];
*h = g_meta_h[i];
return 1;
}
static void build_strip(mr_strip *s, int pages)
{
memset(s, 0, sizeof *s);
g_meta_n = pages;
for (int i = 0; i < pages; i++) {
g_meta_w[i] = 800;
g_meta_h[i] = 1200; /* 适宽后每页 720px */
}
CHECK(mr_strip_build(s, pages, VW, VH, meta_cb, NULL) == 0, "build strip pages=%d", pages);
}
static void test_jump_state(void)
{
mr_jump j;
memset(&j, 0, sizeof j);
CHECK(mr_jump_active(&j) == 0, "fresh inactive");
CHECK(mr_jump_target(&j) == -1, "fresh target -1");
/* 正常：开始 → 未就绪继续等 → 就绪落位 */
mr_jump_begin(&j, 4, 10, 100);
CHECK(mr_jump_active(&j) == 1 && mr_jump_target(&j) == 4, "begin active target=4");
int to = -1;
CHECK(mr_jump_poll(&j, 0, 200, TIMEOUT, &to) == 0 && to == 0, "waiting no timeout");
CHECK(mr_jump_active(&j) == 1, "still active while waiting");
CHECK(mr_jump_poll(&j, 1, 300, TIMEOUT, &to) == 1 && to == 0, "ready lands");
CHECK(mr_jump_active(&j) == 0 && mr_jump_target(&j) == -1, "cleared after land");
/* 超时：仍然落位，但标记降级 */
mr_jump_begin(&j, 2, 10, 1000);
CHECK(mr_jump_poll(&j, 0, 1000 + TIMEOUT - 1, TIMEOUT, &to) == 0, "just before timeout waits");
CHECK(mr_jump_poll(&j, 0, 1000 + TIMEOUT, TIMEOUT, &to) == 1 && to == 1, "timeout lands");
CHECK(mr_jump_active(&j) == 0, "timeout clears");
/* 就绪与超时同时成立：优先算正常就绪 */
mr_jump_begin(&j, 1, 10, 0);
CHECK(mr_jump_poll(&j, 1, 999999, TIMEOUT, &to) == 1 && to == 0,
"ready wins over timeout");
/* timeout=0 表示不限时 */
mr_jump_begin(&j, 1, 10, 0);
CHECK(mr_jump_poll(&j, 0, 999999999ULL, 0, &to) == 0 && to == 0, "no timeout when 0");
/* begin 夹取/非法 */
mr_jump_begin(&j, -1, 10, 0);
CHECK(mr_jump_active(&j) == 0, "begin(-1) cancels");
mr_jump_begin(&j, 10, 10, 0);
CHECK(mr_jump_active(&j) == 0, "begin(count) cancels");
mr_jump_begin(&j, 0, 0, 0);
CHECK(mr_jump_active(&j) == 0, "begin empty book cancels");
/* 取消幂等；NULL 安全 */
mr_jump_begin(&j, 3, 10, 5);
mr_jump_cancel(&j);
mr_jump_cancel(&j);
CHECK(mr_jump_active(&j) == 0, "cancel idempotent");
CHECK(mr_jump_poll(NULL, 1, 1, TIMEOUT, &to) == 0, "poll NULL");
mr_jump_cancel(NULL);
mr_jump_begin(NULL, 0, 10, 0);
/* timed_out 可为 NULL */
mr_jump_begin(&j, 5, 10, 0);
CHECK(mr_jump_poll(&j, 0, TIMEOUT + 1, TIMEOUT, NULL) == 1, "poll NULL timed_out");
}
static void test_land_mapping(void)
{
mr_strip s;
build_strip(&s, 5);
CHECK(mr_strip_total(&s) == 3600, "total=%d", mr_strip_total(&s));
CHECK(mr_strip_max_offset(&s) == 2880, "max=%d", mr_strip_max_offset(&s));
int expect_top[5] = { 0, 720, 1440, 2160, 2880 };
for (int i = 0; i < 5; i++) {
int off = mr_strip_offset_for_page(&s, i);
CHECK(off == expect_top[i], "page %d offset %d (want %d)", i, off, expect_top[i]);
CHECK(mr_strip_page_at(&s, off) == i, "page_at(offset(%d)) == %d", i, i);
}
/* 末页顶端恰在 max（整页铺满视口），落位不会越界 */
CHECK(mr_strip_offset_for_page(&s, 4) == mr_strip_max_offset(&s), "last page == max");
/* page+1 的偏移等于 page 的末端（页间无缝） */
CHECK(mr_strip_top(&s, 1) == mr_strip_top(&s, 0) + mr_strip_page_h(&s, 0),
"page tops contiguous");
/* 跳页目标页必须在解码窗里（否则会被淘汰）：窗口只给 1 槽时也能覆盖目标 */
int f = -1, l = -1;
CHECK(mr_strip_window(&s, 0, 1, &f, &l) == 1 && f == l, "single-slot window");
mr_strip_free(&s);
/* 空册：没有可落位目标 */
mr_strip e;
memset(&e, 0, sizeof e);
CHECK(mr_strip_offset_for_page(&e, 0) == -1, "empty book no offset");
CHECK(mr_strip_page_at(&e, 0) == -1, "empty book no page");
}
int main(void)
{
test_jump_state();
test_land_mapping();
printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
return g_fail ? 1 : 0;
}
tuku/test/test_mode_persist.c
+165
View File
@@ -0,0 +1,165 @@
/* test_mode_persist.c — 阅读模式 + 每册续读状态持久化宿主测试（无 SDK/硬件）。
*
* 覆盖：
* P1 模式值：valid/name/parse（paged/webtoon，非法值回退）；
* P2 册标识键：reader.page/mode.<FNV1a64(规范路径)>，末尾斜杠等价、不同册不同键、
* 键字符集安全（[A-Za-z0-9._-]）；
* P3 默认值：无记录时 get_mode/get_page 返回调用方给的默认值；
* P4 读写往返 + 册间隔离 + 一次 save 写两键；
* P5 坏值/非法模式忽略（不覆盖已有记录）；写失败只 WARN 不崩；
* P6 书库角标：page>0 → "续读 Pn"；page==0/无记录 → 无角标。
*
* 编译（在 tuku/ 下）：
* gcc -Wall -Wextra -O1 -I. test/test_mode_persist.c logic/reader.c \
* test/settings_reader_stub.c -o test/test_mode_persist
* 或 test/run_webtoon_tests.sh。
*/
#include "logic/reader.h"
#include "test/settings_reader_stub.h"
#include "include/meow_ui_config.h"
#include <ctype.h>
#include <stdio.h>
#include <string.h>
static int g_pass, g_fail;
#define CHECK(cond, ...) do { \
if (cond) { g_pass++; } \
else { g_fail++; printf("FAIL %s:%d ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
} while (0)
static void test_mode_values(void)
{
CHECK(mr_mode_valid(MR_MODE_PAGED) == 1, "paged valid");
CHECK(mr_mode_valid(MR_MODE_WEBTOON) == 1, "webtoon valid");
CHECK(mr_mode_valid(-1) == 0 && mr_mode_valid(2) == 0, "invalid modes");
CHECK(strcmp(mr_mode_name(MR_MODE_PAGED), "paged") == 0, "name paged");
CHECK(strcmp(mr_mode_name(MR_MODE_WEBTOON), "webtoon") == 0, "name webtoon");
CHECK(strcmp(mr_mode_name(99), "paged") == 0, "name invalid -> paged");
CHECK(mr_mode_parse("paged") == MR_MODE_PAGED, "parse paged");
CHECK(mr_mode_parse("webtoon") == MR_MODE_WEBTOON, "parse webtoon");
CHECK(mr_mode_parse("WEBTOON") == -1, "parse case sensitive");
CHECK(mr_mode_parse("") == -1 && mr_mode_parse(NULL) == -1, "parse empty/NULL");
}
static void test_keys(void)
{
char a[64], b[64], c[64];
CHECK(mr_cont_key("/sd/book1", "page", a, (int)sizeof a) == 0, "key ok");
CHECK(strncmp(a, "reader.page.", 12) == 0, "key prefix %s", a);
CHECK(strlen(a) == 12 + 16, "key len=%zu", strlen(a));
for (size_t i = 12; i < strlen(a); i++)
CHECK(isxdigit((unsigned char)a[i]) != 0, "key hex char");
CHECK(mr_cont_key("/sd/book1/", "page", b, (int)sizeof b) == 0, "key trailing slash");
CHECK(strcmp(a, b) == 0, "trailing slash normalizes: %s vs %s", a, b);
CHECK(mr_cont_key("/sd/book1", "mode", c, (int)sizeof c) == 0, "mode key");
CHECK(strncmp(c, "reader.mode.", 12) == 0, "mode prefix %s", c);
CHECK(strcmp(a, c) != 0, "field differs");
CHECK(mr_cont_key("/sd/book2", "page", c, (int)sizeof c) == 0, "book2 key");
CHECK(strcmp(a, c) != 0, "different books differ");
/* 参数/缓冲边界 */
CHECK(mr_cont_key(NULL, "page", a, (int)sizeof a) == -1, "NULL dir");
CHECK(mr_cont_key("", "page", a, (int)sizeof a) == -1, "empty dir");
CHECK(mr_cont_key("/a", NULL, a, (int)sizeof a) == -1, "NULL field");
CHECK(mr_cont_key("/a", "page", NULL, 32) == -1, "NULL out");
CHECK(mr_cont_key("/a", "page", a, 8) == -1 && a[0] == '\0', "small out");
}
static void test_defaults_and_roundtrip(void)
{
mr_test_cfg_clear();
CHECK(mr_cont_get_mode("/sd/a", MR_MODE_PAGED) == MR_MODE_PAGED, "default paged");
CHECK(mr_cont_get_mode("/sd/a", MR_MODE_WEBTOON) == MR_MODE_WEBTOON, "default param used");
CHECK(mr_cont_get_page("/sd/a", 0) == 0, "default page 0");
CHECK(mr_cont_get_page("/sd/a", 7) == 7, "default page param");
CHECK(mr_cont_badge("/sd/a", NULL, 0) == 0, "badge NULL safe");
char badge[24];
CHECK(mr_cont_badge("/sd/a", badge, (int)sizeof badge) == 0 && badge[0] == '\0',
"no record -> no badge");
mr_cont_set_mode("/sd/a", MR_MODE_WEBTOON);
CHECK(mr_cont_get_mode("/sd/a", MR_MODE_PAGED) == MR_MODE_WEBTOON, "mode roundtrip");
CHECK(mr_cont_get_mode("/sd/b", MR_MODE_PAGED) == MR_MODE_PAGED, "mode isolated per book");
mr_cont_set_page("/sd/a", 17);
CHECK(mr_cont_get_page("/sd/a", -1) == 17, "page roundtrip");
CHECK(mr_cont_get_page("/sd/b", -1) == -1, "page isolated per book");
CHECK(mr_cont_badge("/sd/a", badge, (int)sizeof badge) == 1, "badge shown");
CHECK(strcmp(badge, "续读 P18") == 0, "badge text %s", badge);
/* 一次 save 两键（模式 + 页码） */
mr_cont_save("/sd/c", 3, MR_MODE_WEBTOON);
CHECK(mr_cont_get_page("/sd/c", -1) == 3, "save page");
CHECK(mr_cont_get_mode("/sd/c", MR_MODE_PAGED) == MR_MODE_WEBTOON, "save mode");
CHECK(mr_cont_badge("/sd/c", badge, (int)sizeof badge) == 1 &&
strcmp(badge, "续读 P4") == 0, "save badge %s", badge);
/* page 0 视为「没有进度」，不出角标 */
mr_cont_save("/sd/d", 0, MR_MODE_PAGED);
CHECK(mr_cont_badge("/sd/d", badge, (int)sizeof badge) == 0 && badge[0] == '\0',
"page 0 -> no badge");
/* NULL/空路径安全 */
mr_cont_set_page(NULL, 5);
mr_cont_set_mode(NULL, MR_MODE_WEBTOON);
mr_cont_save(NULL, 1, 1);
mr_cont_save("", 1, 1);
CHECK(mr_cont_get_page(NULL, 9) == 9 && mr_cont_get_mode(NULL, MR_MODE_PAGED) == MR_MODE_PAGED,
"NULL dir safe");
}
static void test_bad_values(void)
{
mr_test_cfg_clear();
char key[64];
char buf[24];
/* 坏模式值 → 默认；坏页码（负数/非数字/超上限）→ 默认 */
CHECK(mr_cont_key("/sd/x", "mode", key, (int)sizeof key) == 0, "bad key");
mr_test_cfg_put(key, "vertical");
CHECK(mr_cont_get_mode("/sd/x", MR_MODE_PAGED) == MR_MODE_PAGED, "bad mode -> def");
CHECK(mr_cont_key("/sd/x", "page", key, (int)sizeof key) == 0, "bad page key");
mr_test_cfg_put(key, "-3");
CHECK(mr_cont_get_page("/sd/x", 11) == 11, "negative page -> def");
mr_test_cfg_put(key, "abc");
CHECK(mr_cont_get_page("/sd/x", 12) == 12, "non-numeric page -> def");
mr_test_cfg_put(key, "99999999");
CHECK(mr_cont_get_page("/sd/x", 13) == 13, "too-large page -> def");
mr_test_cfg_put(key, "0");
CHECK(mr_cont_get_page("/sd/x", 14) == 0, "zero page readable");
/* 非法模式值不覆盖已有记录 */
mr_cont_set_mode("/sd/y", MR_MODE_WEBTOON);
mr_cont_set_mode("/sd/y", 42);
CHECK(mr_cont_get_mode("/sd/y", MR_MODE_PAGED) == MR_MODE_WEBTOON, "invalid set ignored");
/* 写失败：只告警，内存保持旧值；不崩 */
mr_cont_save("/sd/z", 5, MR_MODE_PAGED);
int warns = mr_test_log_warns();
mr_test_cfg_fail_writes(1);
mr_cont_set_page("/sd/z", 9);
mr_cont_set_mode("/sd/z", MR_MODE_WEBTOON);
mr_cont_save("/sd/z", 10, MR_MODE_WEBTOON);
CHECK(mr_test_log_warns() > warns, "write failure warns (warns=%d)", mr_test_log_warns());
CHECK(mr_cont_get_page("/sd/z", -1) == 5, "failed write keeps old page");
CHECK(mr_cont_get_mode("/sd/z", MR_MODE_PAGED) == MR_MODE_PAGED, "failed write keeps old mode");
mr_test_cfg_fail_writes(0);
/* 写入后读回同一字符串（便于排查：paged/webtoon 明文） */
CHECK(mr_cont_key("/sd/y", "mode", key, (int)sizeof key) == 0, "read mode key");
CHECK(mr_test_cfg_get(key, buf, (int)sizeof buf) == 1 && strcmp(buf, "webtoon") == 0,
"stored mode string %s", buf);
}
int main(void)
{
test_mode_values();
test_keys();
test_defaults_and_roundtrip();
test_bad_values();
printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
return g_fail ? 1 : 0;
}
tuku/test/test_mode_switch_host.c
+273
View File
@@ -0,0 +1,273 @@
/* test_mode_switch_host.c — 阅读器模式/续读/跳页/册间衔接的宿主集成测试（可选，需 SDK 源码树）。
*
* 只做纯逻辑测试覆盖不到的接缝：真实 SDK view/activity/widget + 真实图片解码 + 真实
* meow_scroll/meow_anim 节拍。用 40x60 BMP 当页图（stb 可解，无外部依赖），在临时目录
* 建两本相邻册，然后模拟用户操作：
* H1 进入：默认翻页模式、页码 0、控件归属 ACT_READER（顶栏在 on_enter 建）；
* H2 chrome 图标一键切模式：翻页 ⇄ 条漫，切换立即写 meow_config（每册记忆）；
* H3 跳页滑块：展开 → 拖到末页 → 目标页解码完成后落位（不是先白屏再跳）；
* H4 离开/重进：恢复上次页 + 模式（续读）；
* H5 册间衔接：条漫末页上拉 → 下一册首页；首页下拉 → 上一册末页；首册再无上一册时
* 停在原地（不退出、不崩）。
*
* 编译：test/run_webtoon_tests.sh（需 SDK 源码树；只发布 meow_ui.a 时自动 SKIP）。
*/
#include "tuku_internal.h"
#include "ui/reader/reader.h"
#include "include/meow_ui_anim.h"
#include "meow_ui_internal.h" /* MEOW_EV_TAP / MEOW_EV_SWIPE（宿主测试内部头） */
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
static int g_fail;
#define CHECK(cond, ...) do { \
if (cond) { printf(" PASS\n"); } \
else { g_fail++; printf(" FAIL %s:%d ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
} while (0)
/* app.c 的导航上报在测试里不需要网络侧实现。 */
void mr_nav_report(void) {}
static int g_lib_enters;
static void lib_enter(meow_view *v, void *c) { (void)v; (void)c; g_lib_enters++; }
static void lib_leave(meow_view *v, void *c) { (void)v; (void)c; }
/* ---- 临时目录 + 最小 BMP24（stb 可解） ---- */
static void put16(unsigned char *p, unsigned v) { p[0] = (unsigned char)v; p[1] = (unsigned char)(v >> 8); }
static void put32(unsigned char *p, unsigned v)
{
p[0] = (unsigned char)v; p[1] = (unsigned char)(v >> 8);
p[2] = (unsigned char)(v >> 16); p[3] = (unsigned char)(v >> 24);
}
static int write_bmp24(const char *path, int w, int h)
{
int stride = ((w * 3 + 3) / 4) * 4;
int imgsz = stride * h;
unsigned char fh[14] = { 0 }, ih[40] = { 0 };
fh[0] = 'B'; fh[1] = 'M';
put32(fh + 2, (unsigned)(54 + imgsz));
put32(fh + 10, 54);
put32(ih + 0, 40);
put32(ih + 4, (unsigned)w);
put32(ih + 8, (unsigned)h);
put16(ih + 12, 1);
put16(ih + 14, 24);
put32(ih + 20, (unsigned)imgsz);
FILE *f = fopen(path, "wb");
if (!f) return -1;
int ok = fwrite(fh, 1, sizeof fh, f) == sizeof fh &&
fwrite(ih, 1, sizeof ih, f) == sizeof ih;
unsigned char *row = (unsigned char *)calloc(1, (size_t)stride);
if (!row) ok = 0;
for (int y = 0; ok && y < h; y++)
if (fwrite(row, 1, (size_t)stride, f) != (size_t)stride) ok = 0;
free(row);
if (fclose(f) != 0) ok = 0;
return ok ? 0 : -1;
}
static int mkdir_p(const char *path)
{
char tmp[MR_PATH_MAX];
snprintf(tmp, sizeof tmp, "%s", path);
for (size_t i = 1; i <= strlen(tmp); i++) {
if (tmp[i] == '/' || tmp[i] == '\0') {
char ch = tmp[i];
tmp[i] = '\0';
if (mkdir(tmp, 0755) != 0) {
struct stat st;
if (stat(tmp, &st) != 0 || !S_ISDIR(st.st_mode)) return -1;
}
tmp[i] = ch;
}
}
return 0;
}
static int rm_rf(const char *path)
{
struct stat st;
if (lstat(path, &st) != 0) return -1;
if (!S_ISDIR(st.st_mode)) return unlink(path);
DIR *d = opendir(path);
if (!d) return -1;
struct dirent *de;
while ((de = readdir(d)) != NULL) {
if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
char full[MR_PATH_MAX];
snprintf(full, sizeof full, "%s/%s", path, de->d_name);
rm_rf(full);
}
closedir(d);
return rmdir(path);
}
/* 驱动 SDK 动画节拍（宿主没有 meow_ui_run 主循环）。 */
static void pump_ms(int ms)
{
for (int i = 0; i < ms / 10; i++) {
usleep(10 * 1000);
meow_anim_tick();
}
}
/* 模拟 app.c 的点击路由：on_touch_down → on_tap（阅读页 tap 不在 view on_event 里）。 */
static int tap(int x, int y)
{
reader_on_touch_down(x, y);
reader_on_tap(x, y);
return 1;
}
static int swipe(int dir, int dist)
{
return meow_view_dispatch_event(MEOW_EV_SWIPE, dir, dist);
}
int main(void)
{
const char *base = getenv("TMPDIR");
if (!base || !base[0]) base = ".";
char tmpl[512];
snprintf(tmpl, sizeof tmpl, "%s/mr_mode_host_XXXXXX", base);
char *data = mkdtemp(tmpl);
if (!data) { printf("SKIP: mkdtemp failed\n"); return 0; }
setenv("MEOW_DATA_DIR", data, 1);
char root[MR_PATH_MAX], book1[MR_PATH_MAX], book2[MR_PATH_MAX];
snprintf(root, sizeof root, "./mr_mode_books_%ld", (long)getpid());
snprintf(book1, sizeof book1, "%s/vol1", root);
snprintf(book2, sizeof book2, "%s/vol2", root);
mkdir_p(book1);
mkdir_p(book2);
for (int b = 0; b < 2; b++) {
const char *dir = b ? book2 : book1;
for (int i = 0; i < 3; i++) {
char p[MR_PATH_MAX];
snprintf(p, sizeof p, "%s/p%d.bmp", dir, i + 1);
if (write_bmp24(p, 40, 60) != 0) { printf("SKIP: bmp write failed\n"); return 0; }
}
}
meow_ui_opts o = { 480, 720 };
if (meow_ui_init(&o) != 0) { printf("SKIP: meow_ui_init failed (no host backend)\n"); return 0; }
static const meow_view_hooks lh = { .on_enter = lib_enter, .on_leave = lib_leave };
meow_view *lib = meow_view_create(ACT_LIBRARY, MEOW_VIEW_ACTIVITY, &lh, NULL);
meow_view *reader = reader_view_create();
meow_view_page_push(ACT_LIBRARY);
/* TopAppBar 动作格（位图）：右起每格 48px；动作 0=模式 / 1=跳页 / 2=fit。 */
int w = meow_ui_width();
int mode_x = w - 10 - 48 * 3 + 24;
int jump_x = w - 10 - 48 * 2 + 24;
int bar_y = 28;
int slider_y = 56 + 4 + 20;
int sx = 24, sw = w - 48;
/* ---- H1 进入：翻页模式、第 1 页 ---- */
mr_reader_open_dir(book1);
CHECK(meow_ui_activity_active() == ACT_READER, "reader active after open");
CHECK(mr_reader_ui_count() == 3, "book pages=%d", mr_reader_ui_count());
CHECK(mr_reader_ui_mode() == MR_MODE_PAGED, "default mode is paged");
CHECK(mr_reader_ui_page() == 0, "start at page 0");
pump_ms(300);
/* ---- H2 模式切换：chrome 图标一键切，立即持久化 ---- */
CHECK(tap(mode_x, bar_y) == 1, "mode icon tap consumed");
CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "switched to webtoon");
CHECK(mr_cont_get_mode(book1, MR_MODE_PAGED) == MR_MODE_WEBTOON,
"webtoon mode persisted per book");
CHECK(tap(mode_x, bar_y) == 1, "mode icon tap consumed (back)");
CHECK(mr_reader_ui_mode() == MR_MODE_PAGED, "switched back to paged");
CHECK(mr_cont_get_mode(book1, MR_MODE_PAGED) == MR_MODE_PAGED, "paged mode persisted");
CHECK(tap(mode_x, bar_y) == 1, "mode icon tap consumed (again)");
CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "webtoon again for continuity");
/* ---- H3 跳页：滑块展开 → 拖到末页 → 预解码完成后落位 ---- */
CHECK(tap(jump_x, bar_y) == 1, "jump icon tap consumed");
CHECK(mr_reader_ui_jump_open() == 1, "slider open");
reader_on_touch_down(sx + sw, slider_y);
reader_on_tap(sx + sw, slider_y);
CHECK(mr_reader_ui_jump_open() == 0, "slider closed after pick");
CHECK(mr_reader_ui_jump_pending() == 1 || mr_reader_ui_page() == 2,
"jump pending (waiting for target decode)");
pump_ms(600);
CHECK(mr_reader_ui_jump_pending() == 0, "jump landed");
CHECK(mr_reader_ui_page() == 2, "jumped to last page (got %d)", mr_reader_ui_page());
/* ---- H4 续读：离开保存 page+mode，重进恢复 ---- */
CHECK(swipe(MEOW_SWIPE_LEFT, 200) == 0, "reader leaves back-swipe to app.c");
meow_view_page_pop();
CHECK(meow_ui_activity_active() == ACT_LIBRARY, "back to library");
CHECK(mr_cont_get_page(book1, -1) == 2, "last page saved (got %d)",
mr_cont_get_page(book1, -1));
CHECK(mr_cont_get_mode(book1, MR_MODE_PAGED) == MR_MODE_WEBTOON, "mode saved");
CHECK(g_lib_enters >= 2, "library re-entered");
mr_reader_open_dir(book1);
CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "mode restored on reopen");
CHECK(mr_reader_ui_page() == 2, "page restored on reopen (got %d)", mr_reader_ui_page());
pump_ms(300);
/* ---- H5 册间衔接：条漫末页上拉 → 下一册首页 ---- */
reader_on_touch_down(240, 600);
for (int i = 1; i <= 6; i++) {
reader_on_touch_move(240, 600 - i * 40);
usleep(5 * 1000);
}
CHECK(swipe(MEOW_SWIPE_UP, 240) == 1, "webtoon up-swipe consumed");
CHECK(strcmp(mr_reader_dir(), book2) == 0, "advanced to next book (got %s)", mr_reader_dir());
CHECK(mr_reader_ui_page() == 0, "next book starts at page 0");
CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "mode carried into fresh book");
pump_ms(300);
/* 首页下拉 → 上一册末页 */
reader_on_touch_down(240, 300);
for (int i = 1; i <= 6; i++) {
reader_on_touch_move(240, 300 + i * 40);
usleep(5 * 1000);
}
CHECK(swipe(MEOW_SWIPE_DOWN, 240) == 1, "webtoon down-swipe consumed");
CHECK(strcmp(mr_reader_dir(), book1) == 0, "back to previous book (got %s)", mr_reader_dir());
CHECK(mr_reader_ui_page() == 2, "previous book lands at last page (got %d)",
mr_reader_ui_page());
pump_ms(300);
/* 跳到首页后，再往上一册：没有相邻册，停在原地并提示（不退出/不崩）。 */
CHECK(tap(jump_x, bar_y) == 1, "jump icon tap consumed (to first page)");
CHECK(mr_reader_ui_jump_open() == 1, "slider open again");
reader_on_touch_down(sx + 2, slider_y);
reader_on_tap(sx + 2, slider_y);
pump_ms(500);
CHECK(mr_reader_ui_page() == 0, "jumped to first page (got %d)", mr_reader_ui_page());
reader_on_touch_down(240, 300);
for (int i = 1; i <= 6; i++) {
reader_on_touch_move(240, 300 + i * 40);
usleep(5 * 1000);
}
CHECK(swipe(MEOW_SWIPE_DOWN, 240) == 1, "edge down-swipe consumed");
CHECK(strcmp(mr_reader_dir(), book1) == 0, "no previous book: stay put");
CHECK(meow_ui_activity_active() == ACT_READER, "no previous book: still in reader (no exit)");
/* ---- 收尾 ---- */
meow_view_page_pop();
CHECK(meow_ui_activity_active() == ACT_LIBRARY, "popped back to library");
meow_view_free(reader);
meow_view_free(lib);
meow_ui_shutdown();
rm_rf(root);
rm_rf(data);
printf("%s: %s\n", g_fail ? "FAIL" : "PASS",
g_fail ? "see failures above" : "reader mode/continuity integration checks passed");
return g_fail ? 1 : 0;
}
tuku/test/test_webtoon_strip.c
+220
View File
@@ -0,0 +1,220 @@
/* test_webtoon_strip.c — 条漫排版/滚动窗口纯逻辑宿主测试（无 SDK/硬件）。
*
* 覆盖：
* W1 单页：高度=适宽、总高、max_offset=0、窗口只有本页、顶/底同时成立；
* W2 多页：按页高累加 offsets；page_at 二分定位（页边界/末页/越界）；
* W3 可见窗口：视口±1 页；max_pages 截断；条底/条顶窗口不越界；
* W4 尺寸兜底：未知 meta → 2:3 占位；横图适宽；极端长图夹到上限；
* W5 参数/生命周期：空册、非法视口、重复 free、重建；
* W6 跳页落位：offset_for_page 与 page_at 互逆（含末页 max 夹取）。
*
* 编译（在 tuku/ 下）：
* gcc -Wall -Wextra -O1 -I. test/test_webtoon_strip.c logic/reader/nav.c \
* -o test/test_webtoon_strip && ./test/test_webtoon_strip
* 或 test/run_webtoon_tests.sh。
*/
#include "logic/reader/nav.h"
#include <stdio.h>
#include <string.h>
static int g_pass, g_fail;
#define CHECK(cond, ...) do { \
if (cond) { g_pass++; } \
else { g_fail++; printf("FAIL %s:%d ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
} while (0)
#define VW 480
#define VH 720
typedef struct fake_meta {
int n;
int w[16];
int h[16];
int known[16];
} fake_meta;
static int meta_cb(void *ctx, int i, int *w, int *h)
{
fake_meta *m = (fake_meta *)ctx;
if (!m || i < 0 || i >= m->n) return 0;
*w = m->w[i];
*h = m->h[i];
return m->known[i];
}
static void meta_page(fake_meta *m, int i, int w, int h, int known)
{
m->w[i] = w;
m->h[i] = h;
m->known[i] = known;
if (i + 1 > m->n) m->n = i + 1;
}
static void test_single_page(void)
{
fake_meta m;
memset(&m, 0, sizeof m);
meta_page(&m, 0, 800, 1200, 1);
mr_strip s;
memset(&s, 0, sizeof s);
CHECK(mr_strip_build(&s, 1, VW, VH, meta_cb, &m) == 0, "build single");
CHECK(s.count == 1, "count=%d", s.count);
CHECK(mr_strip_page_h(&s, 0) == 720, "single h=%d", mr_strip_page_h(&s, 0));
CHECK(mr_strip_total(&s) == 720, "single total=%d", mr_strip_total(&s));
CHECK(mr_strip_max_offset(&s) == 0, "single max=%d", mr_strip_max_offset(&s));
CHECK(mr_strip_page_at(&s, 0) == 0, "single page at 0");
CHECK(mr_strip_page_at(&s, 719) == 0, "single page at 719");
CHECK(mr_strip_page_at(&s, 720) == 0, "single page at total clamps");
CHECK(mr_strip_at_end(&s, 0) == 1, "single at end");
CHECK(mr_strip_at_start(&s, 0) == 1, "single at start");
int f = -1, l = -1;
CHECK(mr_strip_window(&s, 0, 4, &f, &l) == 1 && f == 0 && l == 0,
"single window %d..%d", f, l);
CHECK(mr_strip_offset_for_page(&s, 0) == 0, "single offset page0");
CHECK(mr_strip_offset_for_page(&s, 9) == 0, "single offset OOB clamps");
mr_strip_free(&s);
}
static void test_multi_pages(void)
{
fake_meta m;
memset(&m, 0, sizeof m);
/* 0: 800x1200 -> 720；1: 未知 -> 720 占位；2: 横图 1500x1000 -> 320；
* 3: 方图 400x400 -> 480；4: 极端长图 1x2000 -> 夹到 200000。 */
meta_page(&m, 0, 800, 1200, 1);
meta_page(&m, 1, 0, 0, 0);
meta_page(&m, 2, 1500, 1000, 1);
meta_page(&m, 3, 400, 400, 1);
meta_page(&m, 4, 1, 2000, 1);
mr_strip s;
memset(&s, 0, sizeof s);
CHECK(mr_strip_build(&s, 5, VW, VH, meta_cb, &m) == 0, "build multi");
CHECK(mr_strip_page_h(&s, 0) == 720, "h0=%d", mr_strip_page_h(&s, 0));
CHECK(mr_strip_page_h(&s, 1) == 720, "h1(unknown)=%d", mr_strip_page_h(&s, 1));
CHECK(mr_strip_page_h(&s, 2) == 320, "h2(landscape)=%d", mr_strip_page_h(&s, 2));
CHECK(mr_strip_page_h(&s, 3) == 480, "h3(square)=%d", mr_strip_page_h(&s, 3));
CHECK(mr_strip_page_h(&s, 4) == MR_STRIP_MAX_PAGE_H, "h4(extreme)=%d",
mr_strip_page_h(&s, 4));
CHECK(mr_strip_top(&s, 0) == 0, "top0=%d", mr_strip_top(&s, 0));
CHECK(mr_strip_top(&s, 1) == 720, "top1=%d", mr_strip_top(&s, 1));
CHECK(mr_strip_top(&s, 2) == 1440, "top2=%d", mr_strip_top(&s, 2));
CHECK(mr_strip_top(&s, 3) == 1760, "top3=%d", mr_strip_top(&s, 3));
CHECK(mr_strip_top(&s, 4) == 2240, "top4=%d", mr_strip_top(&s, 4));
CHECK(mr_strip_top(&s, 5) == 202240, "top[count]=%d", mr_strip_top(&s, 5));
CHECK(mr_strip_total(&s) == 202240, "total=%d", mr_strip_total(&s));
CHECK(mr_strip_max_offset(&s) == 201520, "max=%d", mr_strip_max_offset(&s));
CHECK(mr_strip_page_at(&s, 0) == 0, "page_at 0");
CHECK(mr_strip_page_at(&s, 719) == 0, "page_at 719");
CHECK(mr_strip_page_at(&s, 720) == 1, "page_at 720");
CHECK(mr_strip_page_at(&s, 1439) == 1, "page_at 1439");
CHECK(mr_strip_page_at(&s, 1440) == 2, "page_at 1440");
CHECK(mr_strip_page_at(&s, 1759) == 2, "page_at 1759");
CHECK(mr_strip_page_at(&s, 1760) == 3, "page_at 1760");
CHECK(mr_strip_page_at(&s, 2239) == 3, "page_at 2239");
CHECK(mr_strip_page_at(&s, 2240) == 4, "page_at 2240");
CHECK(mr_strip_page_at(&s, 9999999) == 4, "page_at huge -> last");
CHECK(mr_strip_page_at(&s, -50) == 0, "page_at negative -> first");
CHECK(mr_strip_page_at(&s, 0) == 0 && mr_strip_page_at(NULL, 0) == -1, "page_at NULL");
/* 视口窗口：off=0 只看得到页 0（页 1 从 720 开始）→ ±1 = [0,1] */
int f = -1, l = -1;
CHECK(mr_strip_window(&s, 0, 4, &f, &l) == 2 && f == 0 && l == 1,
"window top %d..%d", f, l);
/* off=1000：可见页 1..2 → 窗口 [0,3] */
CHECK(mr_strip_window(&s, 1000, 4, &f, &l) == 4 && f == 0 && l == 3,
"window mid %d..%d", f, l);
/* off=max：可见页 4 → 窗口 [3,4] */
CHECK(mr_strip_window(&s, 201520, 4, &f, &l) == 2 && f == 3 && l == 4,
"window bottom %d..%d", f, l);
/* 只用 1 个槽位：窗口收缩到焦点页 */
CHECK(mr_strip_window(&s, 1000, 1, &f, &l) == 1 && f >= 1 && f <= 2 && f == l,
"window max_pages=1 %d..%d", f, l);
CHECK(mr_strip_window(&s, -100, 4, &f, &l) == 2 && f == 0 && l == 1,
"window negative off %d..%d", f, l);
CHECK(mr_strip_at_end(&s, 0) == 0, "not at end at 0");
CHECK(mr_strip_at_end(&s, 201519) == 0, "not at end just before max");
CHECK(mr_strip_at_end(&s, 201520) == 1, "at end at max");
CHECK(mr_strip_at_start(&s, 0) == 1, "at start 0");
CHECK(mr_strip_at_start(&s, 1) == 0, "not at start 1");
/* 跳页落位：每页 offset 回读一致（末页夹到 max） */
for (int i = 0; i < 5; i++) {
int off = mr_strip_offset_for_page(&s, i);
int back = mr_strip_page_at(&s, off);
CHECK(back == i, "roundtrip page %d -> off %d -> page %d", i, off, back);
}
CHECK(mr_strip_offset_for_page(&s, 4) == 2240, "last page offset = its top");
/* 短册（内容不足一屏）：任何页都夹到 max=0 */
fake_meta m2;
memset(&m2, 0, sizeof m2);
meta_page(&m2, 0, 800, 300, 1); /* 高 180 */
meta_page(&m2, 1, 800, 300, 1);
mr_strip s2;
memset(&s2, 0, sizeof s2);
CHECK(mr_strip_build(&s2, 2, VW, VH, meta_cb, &m2) == 0, "build short");
CHECK(mr_strip_total(&s2) == 360 && mr_strip_max_offset(&s2) == 0, "short totals");
CHECK(mr_strip_offset_for_page(&s2, 1) == 0, "short last page clamps to 0");
CHECK(mr_strip_at_end(&s2, 0) == 1 && mr_strip_at_start(&s2, 0) == 1, "short edges");
mr_strip_free(&s2);
/* 越界参数 */
CHECK(mr_strip_page_h(&s, -1) == 0 && mr_strip_page_h(&s, 5) == 0, "page_h OOB");
CHECK(mr_strip_top(&s, -1) == 0 && mr_strip_top(&s, 6) == 0, "top OOB");
mr_strip_free(&s);
CHECK(s.top == NULL && s.height == NULL && s.count == 0, "free clears");
mr_strip_free(&s);
}
static void test_build_contract(void)
{
fake_meta m;
memset(&m, 0, sizeof m);
meta_page(&m, 0, 800, 1200, 1);
mr_strip s;
memset(&s, 0, sizeof s);
CHECK(mr_strip_build(NULL, 1, VW, VH, meta_cb, &m) == -1, "NULL strip");
CHECK(mr_strip_build(&s, 0, VW, VH, meta_cb, &m) == -1, "count 0 -> -1");
CHECK(s.top == NULL && s.count == 0, "failed build clears");
CHECK(mr_strip_build(&s, 1, 0, VH, meta_cb, &m) == -1, "vw 0 -> -1");
CHECK(mr_strip_build(&s, 1, VW, 0, meta_cb, &m) == -1, "vh 0 -> -1");
/* meta 回调为 NULL → 全部按 2:3 占位 */
CHECK(mr_strip_build(&s, 2, VW, VH, NULL, NULL) == 0, "NULL meta build");
CHECK(mr_strip_page_h(&s, 0) == 720 && mr_strip_page_h(&s, 1) == 720,
"NULL meta fallback heights");
mr_strip_free(&s);
/* meta 返回失败（0）也按占位处理 */
CHECK(mr_strip_build(&s, 1, VW, VH, meta_cb, &m) == 0, "rebuild after free");
CHECK(mr_strip_page_h(&s, 0) == 720, "rebuild height");
mr_strip_free(&s);
/* 空排版查询全部安全 */
mr_strip e;
memset(&e, 0, sizeof e);
CHECK(mr_strip_total(&e) == 0 && mr_strip_max_offset(&e) == 0, "empty totals");
CHECK(mr_strip_page_at(&e, 0) == -1, "empty page_at");
CHECK(mr_strip_offset_for_page(&e, 0) == -1, "empty offset_for_page");
int f = 9, l = 9;
CHECK(mr_strip_window(&e, 0, 4, &f, &l) == 0 && l == -1, "empty window");
CHECK(mr_strip_at_end(&e, 0) == 0 && mr_strip_at_start(&e, 0) == 0, "empty edges");
}
int main(void)
{
test_single_page();
test_multi_pages();
test_build_contract();
printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
return g_fail ? 1 : 0;
}
tuku/ui/reader/reader.c
+885 -91
View File
File diff suppressed because it is too large. Load diff
tuku/ui/reader/reader.h
+9
View File
@@ -13,6 +13,15 @@ extern "C" {
void reader_on_touch_down(int x, int y);
void reader_on_touch_move(int x, int y);
#ifdef MR_READER_HOST_TEST
/* 宿主集成测试专用：只读观察本页状态（不参与产品逻辑）。 */
int mr_reader_ui_mode(void); /* MR_MODE_PAGED / MR_MODE_WEBTOON */
int mr_reader_ui_page(void); /* 当前页（条漫=视口顶端所在页） */
int mr_reader_ui_count(void); /* 当前册页数 */
int mr_reader_ui_jump_open(void); /* 1=跳页滑块已展开 */
int mr_reader_ui_jump_pending(void);/* 1=跳页目标等待解码 */
#endif
#ifdef __cplusplus
}
#endif