Merge branch 'feat/tuku-fast-library-browsing'
This commit is contained in:
AskaEth committed
commit
5ac227b225
12 files changed
+2418
-355
No files matched your search
+354
-122
@@ -1,38 +1,57 @@
|
||||
/* logic/library.c — 书库目录扫描 + 自然排序（纯 C）。
|
||||
/* logic/library.c — 书库目录浏览：单层枚举 + 后台懒判定（纯 C）。
|
||||
*
|
||||
* 扫描分两步：
|
||||
* 1) scan_info()：递归探测一个目录是否「最终含图」，并带回直接图片数 / 含图子目录数 /
|
||||
* 缩略图源（优先本目录自然序第一张，其次第一个含图子目录）；
|
||||
* 2) mr_library_scan()：只对目标目录的**直接子目录**调用 scan_info()，把 nav=1 的目录
|
||||
* 收进结果并自然排序——因此根视图不会列出后代条目，进入子目录时再重新扫描该层。
|
||||
* 扫描（mr_library_scan / mr_library_scan_ex）与 os.meow.files 的 fsx_scan_dir 同构：
|
||||
* - 一次 opendir/readdir，逐项 lstat（只认目录与档案文件；符号链接跳过防环）；
|
||||
* - 隐藏项（"." 开头，含 . ..）跳过；系统目录/空目录/无图目录一律列出；
|
||||
* - 目录名/档案文件名按 mr_natural_cmp 自然升序；条目到 MR_LIB_SCAN_MAX 后仍有条目 →
|
||||
* 截断标注。不再对子目录做任何递归/探测——首帧成本只与本层条目数线性相关。
|
||||
*
|
||||
* 内存：条目数组倍增分配；路径/名称定长，随 mr_library_free() 释放。
|
||||
* 懒判定（probe）：
|
||||
* - mr_library_probe_dir 只读一层（图片项 lstat 校验普通文件），给出直接图片数与自然序首图；
|
||||
* - mr_library_probe_path 按行类型探测：目录走上面的单层扫描；档案册调调用方注入的
|
||||
* archive_pages（M11，logic 不依赖 zip）。两者共用 mtime(秒+纳秒)+size 失效的 256 项
|
||||
* LRU 缓存 + 互斥锁，可被后台线程并发调用；探测期间目录/档案发生变化则不写缓存。
|
||||
* - mr_library_apply_probe 把结果补回行；副标题由 mr_library_format_subtitle 统一生成，
|
||||
* 书行再拼 M7 的「· 续读 Pn」角标。
|
||||
*
|
||||
* M7 追加（不改扫描语义）：
|
||||
* - 续读角标：含图册的副标题后缀「· 续读 Pn」（读 logic/reader 的每册 last page）；
|
||||
* - 册间衔接：mr_book_adjacent 给出同父目录下按书库自然序的相邻「含图册」，
|
||||
* 供阅读器末页前进/首页后退跨册；mr_library_dir_has_images 是共享的「是不是一本书」判据。
|
||||
*
|
||||
* M11 追加（档案册，仍然不改目录扫描的主体语义）：
|
||||
* - 目标目录的**直接子文件**里 .cbz/.zip 也成行（行=文件名+档内页数，has_images=1）；
|
||||
* - 档案册探测由调用方注入（mr_lib_archive_fn），logic 层不依赖 zip 容器；
|
||||
* 不注入时所有 *_ex 入口与 M7 行为逐字一致；
|
||||
* - 册间衔接的兄弟表从「含图目录」扩成「含图目录 ∪ 含图片页的档案册」，同列自然序。
|
||||
* 小函数边界（add_dir_entry / add_archive_entry / entry_subtitle / entry_badge /
|
||||
* sibling_is_book）刻意留给 M13 的书库重写复用。
|
||||
* M11 档案册：注入 archive_pages 时 .cbz/.zip 直接子文件也成行（懒探测页数）；
|
||||
* 未注入时只列目录（M7 书库语义）。册间衔接的兄弟表 = 含图目录 ∪ 含图片页的档案册。
|
||||
*/
|
||||
#include "library.h"
|
||||
#include "logic/reader.h" /* mr_cont_badge：书库行续读角标（M7） */
|
||||
|
||||
#include <ctype.h>
|
||||
#include <dirent.h>
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <strings.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
/* 系统目录不参与书库（SD 根上的 MeowOS 目录树）。 */
|
||||
#ifdef MR_LIBRARY_TEST_HOOKS
|
||||
static mr_library_io_stats g_io;
|
||||
|
||||
void mr_library_test_io_reset(void)
|
||||
{
|
||||
memset(&g_io, 0, sizeof g_io);
|
||||
}
|
||||
|
||||
void mr_library_test_io_get(mr_library_io_stats *out)
|
||||
{
|
||||
if (out) *out = g_io;
|
||||
}
|
||||
|
||||
#define IO_OPEN() (g_io.opendirs++)
|
||||
#define IO_READDIR() (g_io.readdirs++)
|
||||
#define IO_LSTAT() (g_io.lstats++)
|
||||
#else
|
||||
#define IO_OPEN() ((void)0)
|
||||
#define IO_READDIR() ((void)0)
|
||||
#define IO_LSTAT() ((void)0)
|
||||
#endif
|
||||
|
||||
/* 系统目录不参与**册间衔接**（M7 兄弟册表）；浏览本身已放开（不隐藏）。 */
|
||||
static int ignored_dir_name(const char *name)
|
||||
{
|
||||
static const char *const skip[] = { "MeowAPPs", "MeowData", "MeowOS", "lost+found" };
|
||||
@@ -119,16 +138,7 @@ int mr_natural_cmp(const char *a, const char *b)
|
||||
return strcmp(a, b) < 0 ? -1 : (strcmp(a, b) > 0 ? 1 : 0);
|
||||
}
|
||||
|
||||
typedef struct scan_info {
|
||||
int pages; /* 直接图片数 */
|
||||
int subdirs; /* 含图子目录数 */
|
||||
int archives; /* 直接档案册数（.cbz/.zip 且探测到图片页） */
|
||||
int nav; /* 1=本目录最终含书（可直接看或可导航到书） */
|
||||
char cover[MR_PATH_MAX]; /* 缩略图源 */
|
||||
char first_name[MR_NAME_MAX]; /* 本目录自然序第一张图片的文件名（比较用） */
|
||||
} scan_info;
|
||||
|
||||
/* 档案册探测（UI 注入；NULL=纯目录书库，行为与 M7 一致）。 */
|
||||
/* 档案册探测（UI 注入；NULL=纯目录书库，档案文件不成行）。 */
|
||||
static int archive_pages_at(mr_lib_archive_fn probe, void *ud, const char *path)
|
||||
{
|
||||
if (!probe || !path || !path[0]) return 0;
|
||||
@@ -136,48 +146,234 @@ static int archive_pages_at(mr_lib_archive_fn probe, void *ud, const char *path)
|
||||
return n > 0 ? n : 0;
|
||||
}
|
||||
|
||||
static void scan_dir(const char *path, int depth, int max_depth, scan_info *si,
|
||||
mr_lib_archive_fn probe, void *ud)
|
||||
/* ============================================================ */
|
||||
/* 单层探测 + mtime/size 失效缓存 */
|
||||
/* ============================================================ */
|
||||
int mr_library_probe_dir(const char *dir, mr_library_probe *out)
|
||||
{
|
||||
memset(si, 0, sizeof *si);
|
||||
DIR *d = opendir(path);
|
||||
if (!d) return;
|
||||
if (!out) return -1;
|
||||
memset(out, 0, sizeof *out);
|
||||
if (!dir || !dir[0]) return -1;
|
||||
|
||||
IO_OPEN();
|
||||
DIR *d = opendir(dir);
|
||||
if (!d) return -1;
|
||||
|
||||
char best[MR_NAME_MAX];
|
||||
best[0] = '\0';
|
||||
out->empty = 1;
|
||||
struct dirent *de;
|
||||
while ((de = readdir(d)) != NULL) {
|
||||
IO_READDIR();
|
||||
const char *name = de->d_name;
|
||||
if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue;
|
||||
if (ignored_dir_name(name)) continue;
|
||||
if (name[0] == '.') continue; /* 隐藏项不算内容 */
|
||||
out->empty = 0;
|
||||
if (!mr_path_is_image(name)) continue;
|
||||
|
||||
char full[MR_PATH_MAX];
|
||||
if (join_path(full, (int)sizeof full, path, name) != 0) continue;
|
||||
|
||||
if (join_path(full, (int)sizeof full, dir, name) != 0) continue;
|
||||
IO_LSTAT();
|
||||
struct stat st;
|
||||
if (lstat(full, &st) != 0) continue;
|
||||
if (S_ISLNK(st.st_mode)) continue;
|
||||
if (lstat(full, &st) != 0 || !S_ISREG(st.st_mode)) continue;
|
||||
|
||||
if (S_ISDIR(st.st_mode)) {
|
||||
if (depth >= max_depth) continue;
|
||||
scan_info child;
|
||||
scan_dir(full, depth + 1, max_depth, &child, probe, ud);
|
||||
if (!child.nav) continue;
|
||||
si->subdirs++;
|
||||
if (!si->cover[0] && child.cover[0])
|
||||
copy_str(si->cover, (int)sizeof si->cover, child.cover);
|
||||
} else if (S_ISREG(st.st_mode)) {
|
||||
if (mr_path_is_image(name)) {
|
||||
si->pages++;
|
||||
if (!si->first_name[0] || mr_natural_cmp(name, si->first_name) < 0) {
|
||||
copy_str(si->first_name, (int)sizeof si->first_name, name);
|
||||
copy_str(si->cover, (int)sizeof si->cover, full);
|
||||
}
|
||||
} else if (mr_path_is_archive(name)) {
|
||||
if (archive_pages_at(probe, ud, full) > 0) si->archives++;
|
||||
}
|
||||
out->pages++;
|
||||
if (best[0] == '\0' || mr_natural_cmp(name, best) < 0) {
|
||||
copy_str(best, (int)sizeof best, name);
|
||||
copy_str(out->cover, (int)sizeof out->cover, full);
|
||||
}
|
||||
}
|
||||
closedir(d);
|
||||
si->nav = (si->pages > 0 || si->subdirs > 0 || si->archives > 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define MR_PROBE_CACHE_MAX 256
|
||||
|
||||
typedef struct probe_cache_entry {
|
||||
char path[MR_PATH_MAX];
|
||||
long long mtime_ns;
|
||||
long long size;
|
||||
mr_library_probe probe;
|
||||
unsigned long long last_use;
|
||||
} probe_cache_entry;
|
||||
|
||||
static probe_cache_entry *g_cache[MR_PROBE_CACHE_MAX];
|
||||
static unsigned long long g_cache_clock;
|
||||
static pthread_mutex_t g_cache_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
|
||||
static long long stat_mtime_ns(const struct stat *st)
|
||||
{
|
||||
#if defined(__APPLE__)
|
||||
return (long long)st->st_mtimespec.tv_sec * 1000000000LL + st->st_mtimespec.tv_nsec;
|
||||
#else
|
||||
return (long long)st->st_mtim.tv_sec * 1000000000LL + st->st_mtim.tv_nsec;
|
||||
#endif
|
||||
}
|
||||
|
||||
static probe_cache_entry *cache_find_locked(const char *path)
|
||||
{
|
||||
for (int i = 0; i < MR_PROBE_CACHE_MAX; i++) {
|
||||
if (!g_cache[i]) continue;
|
||||
if (strcmp(g_cache[i]->path, path) == 0) return g_cache[i];
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void cache_put_locked(const char *path, long long mtime_ns, long long size,
|
||||
const mr_library_probe *p)
|
||||
{
|
||||
probe_cache_entry *e = cache_find_locked(path);
|
||||
if (!e) {
|
||||
int slot = -1;
|
||||
for (int i = 0; i < MR_PROBE_CACHE_MAX; i++)
|
||||
if (!g_cache[i]) { slot = i; break; }
|
||||
if (slot < 0) { /* 满：淘汰最久未用项 */
|
||||
int lru = 0;
|
||||
unsigned long long oldest = g_cache[0]->last_use;
|
||||
for (int i = 1; i < MR_PROBE_CACHE_MAX; i++) {
|
||||
if (g_cache[i]->last_use < oldest) {
|
||||
oldest = g_cache[i]->last_use;
|
||||
lru = i;
|
||||
}
|
||||
}
|
||||
free(g_cache[lru]);
|
||||
g_cache[lru] = NULL;
|
||||
slot = lru;
|
||||
}
|
||||
e = (probe_cache_entry *)malloc(sizeof *e);
|
||||
if (!e) return; /* 缓存只是加速：失败就每次现算 */
|
||||
if (copy_str(e->path, (int)sizeof e->path, path) != 0) {
|
||||
free(e);
|
||||
return;
|
||||
}
|
||||
g_cache[slot] = e;
|
||||
}
|
||||
e->mtime_ns = mtime_ns;
|
||||
e->size = size;
|
||||
e->probe = *p;
|
||||
e->last_use = ++g_cache_clock;
|
||||
}
|
||||
|
||||
void mr_library_probe_cache_clear(void)
|
||||
{
|
||||
pthread_mutex_lock(&g_cache_lock);
|
||||
for (int i = 0; i < MR_PROBE_CACHE_MAX; i++) {
|
||||
free(g_cache[i]);
|
||||
g_cache[i] = NULL;
|
||||
}
|
||||
g_cache_clock = 0;
|
||||
pthread_mutex_unlock(&g_cache_lock);
|
||||
}
|
||||
|
||||
/* 无缓存探测：目录=单层目录扫描；档案册=注入回调取页数。 */
|
||||
static int probe_path_uncached(const char *path, int is_archive,
|
||||
mr_lib_archive_fn archive_pages, void *ud,
|
||||
mr_library_probe *out)
|
||||
{
|
||||
struct stat st;
|
||||
if (stat(path, &st) != 0) return -1;
|
||||
if (is_archive) {
|
||||
if (!archive_pages || !S_ISREG(st.st_mode)) return -1;
|
||||
out->pages = archive_pages_at(archive_pages, ud, path);
|
||||
out->empty = 0;
|
||||
out->cover[0] = '\0';
|
||||
return 0;
|
||||
}
|
||||
if (!S_ISDIR(st.st_mode)) return -1;
|
||||
return mr_library_probe_dir(path, out);
|
||||
}
|
||||
|
||||
int mr_library_probe_path(const char *path, int is_archive,
|
||||
mr_lib_archive_fn archive_pages, void *ud,
|
||||
mr_library_probe *out)
|
||||
{
|
||||
if (!out) return -1;
|
||||
memset(out, 0, sizeof *out);
|
||||
if (!path || !path[0]) return -1;
|
||||
|
||||
struct stat st;
|
||||
if (stat(path, &st) != 0) return -1;
|
||||
if (is_archive ? !S_ISREG(st.st_mode) : !S_ISDIR(st.st_mode)) return -1;
|
||||
|
||||
long long mtime_ns = stat_mtime_ns(&st);
|
||||
long long size = (long long)st.st_size;
|
||||
|
||||
pthread_mutex_lock(&g_cache_lock);
|
||||
probe_cache_entry *hit = cache_find_locked(path);
|
||||
if (hit && hit->mtime_ns == mtime_ns && hit->size == size) {
|
||||
*out = hit->probe;
|
||||
hit->last_use = ++g_cache_clock;
|
||||
pthread_mutex_unlock(&g_cache_lock);
|
||||
return 0;
|
||||
}
|
||||
pthread_mutex_unlock(&g_cache_lock);
|
||||
|
||||
mr_library_probe p;
|
||||
memset(&p, 0, sizeof p);
|
||||
if (probe_path_uncached(path, is_archive, archive_pages, ud, &p) != 0) return -1;
|
||||
|
||||
/* 评审 P2：只把「探测前后完全一致」的结果写入缓存。
|
||||
* 探测期间目录/档案的 mtime 或 size 变了（新增/替换文件），说明结果可能不完整，
|
||||
* 不能绑定到新 mtime 上当「新鲜」——本次直接返回，下次调用重新探测。 */
|
||||
struct stat st2;
|
||||
if (stat(path, &st2) == 0 && stat_mtime_ns(&st2) == mtime_ns &&
|
||||
(long long)st2.st_size == size) {
|
||||
pthread_mutex_lock(&g_cache_lock);
|
||||
cache_put_locked(path, mtime_ns, size, &p);
|
||||
pthread_mutex_unlock(&g_cache_lock);
|
||||
}
|
||||
|
||||
*out = p;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mr_library_probe_cached(const char *dir, mr_library_probe *out)
|
||||
{
|
||||
return mr_library_probe_path(dir, 0, NULL, NULL, out);
|
||||
}
|
||||
|
||||
/* ============================================================ */
|
||||
/* 行状态：副标题 / 补位 / 行合成 */
|
||||
/* ============================================================ */
|
||||
/* 基础副标题（不含 M7 续读角标）。 */
|
||||
static void entry_subtitle(mr_library_entry *e)
|
||||
{
|
||||
switch (e->probe_state) {
|
||||
case MR_LIB_READY:
|
||||
if (e->pages > 0)
|
||||
snprintf(e->subtitle, sizeof e->subtitle, "%d page%s", e->pages,
|
||||
e->pages == 1 ? "" : "s");
|
||||
else if (!e->is_archive && e->empty)
|
||||
snprintf(e->subtitle, sizeof e->subtitle, "空目录");
|
||||
else
|
||||
snprintf(e->subtitle, sizeof e->subtitle, "无图片");
|
||||
break;
|
||||
case MR_LIB_FAILED:
|
||||
snprintf(e->subtitle, sizeof e->subtitle, "无法读取");
|
||||
break;
|
||||
default:
|
||||
snprintf(e->subtitle, sizeof e->subtitle, "…");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* 续读角标（M7）：有 last page 记录的书行，在副标题后缀「· 续读 Pn」。
|
||||
* 档案册以档案路径为册标识，同一套逻辑复用。
|
||||
* config 读失败/无记录时 mr_cont_badge 返回 0，副标题保持原样。 */
|
||||
static void entry_badge(mr_library_entry *e)
|
||||
{
|
||||
if (e->has_images != 1) return;
|
||||
char badge[24];
|
||||
if (!mr_cont_badge(e->path, badge, (int)sizeof badge)) return;
|
||||
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);
|
||||
}
|
||||
|
||||
void mr_library_format_subtitle(mr_library_entry *e)
|
||||
{
|
||||
if (!e) return;
|
||||
entry_subtitle(e);
|
||||
entry_badge(e);
|
||||
}
|
||||
|
||||
void mr_library_free(mr_library *lib)
|
||||
@@ -187,6 +383,7 @@ void mr_library_free(mr_library *lib)
|
||||
lib->items = NULL;
|
||||
lib->count = 0;
|
||||
lib->cap = 0;
|
||||
lib->truncated = 0;
|
||||
}
|
||||
|
||||
static int lib_add(mr_library *lib, const mr_library_entry *e)
|
||||
@@ -210,51 +407,22 @@ static int entry_cmp(const void *pa, const void *pb)
|
||||
return mr_natural_cmp(a->name, b->name);
|
||||
}
|
||||
|
||||
/* 副标题（M11 扩展）：直接含图 → pages；只有档案册 → books；否则 folders。 */
|
||||
static void entry_subtitle(mr_library_entry *e, int archive_books)
|
||||
{
|
||||
if (e->has_images)
|
||||
snprintf(e->subtitle, sizeof e->subtitle, "%d page%s", e->pages,
|
||||
e->pages == 1 ? "" : "s");
|
||||
else if (archive_books > 0)
|
||||
snprintf(e->subtitle, sizeof e->subtitle, "%d book%s", archive_books,
|
||||
archive_books == 1 ? "" : "s");
|
||||
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，副标题保持原样。 */
|
||||
static void entry_badge(mr_library_entry *e)
|
||||
{
|
||||
if (!e->has_images) return;
|
||||
char badge[24];
|
||||
if (!mr_cont_badge(e->path, badge, (int)sizeof badge)) return;
|
||||
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);
|
||||
}
|
||||
|
||||
/* 文件夹册（含可导航中间目录）一行。 */
|
||||
static int add_dir_entry(mr_library *lib, const char *name, const char *full,
|
||||
const scan_info *si)
|
||||
/* 文件夹册行（M13）：一律列出、初始待探测；是否「书」由后台 probe 决定。 */
|
||||
static int add_dir_entry(mr_library *lib, const char *name, const char *full)
|
||||
{
|
||||
mr_library_entry e;
|
||||
memset(&e, 0, sizeof e);
|
||||
if (copy_str(e.name, (int)sizeof e.name, name) != 0) return 0;
|
||||
if (copy_str(e.path, (int)sizeof e.path, full) != 0) return 0;
|
||||
copy_str(e.cover, (int)sizeof e.cover, si->cover);
|
||||
e.pages = si->pages;
|
||||
e.subdirs = si->subdirs;
|
||||
e.has_images = (si->pages > 0);
|
||||
entry_subtitle(&e, si->archives);
|
||||
entry_badge(&e);
|
||||
e.pages = -1;
|
||||
e.has_images = -1;
|
||||
e.probe_state = MR_LIB_PENDING;
|
||||
mr_library_format_subtitle(&e);
|
||||
return lib_add(lib, &e);
|
||||
}
|
||||
|
||||
/* 档案册（.cbz/.zip）一行：文件即一本书，点入直接阅读。
|
||||
/* 档案册（.cbz/.zip）行：文件即一本书，点入直接阅读。
|
||||
* pages<0=待后台探测（M13 懒算）；>=0=已知页数（扫描期注入的旧路径/测试用）。
|
||||
* cover 留空——缩略图由 UI 解压档内首图（mr_zip_cover_path）生成。 */
|
||||
static int add_archive_entry(mr_library *lib, const char *name, const char *full,
|
||||
int pages)
|
||||
@@ -263,52 +431,58 @@ static int add_archive_entry(mr_library *lib, const char *name, const char *full
|
||||
memset(&e, 0, sizeof e);
|
||||
if (copy_str(e.name, (int)sizeof e.name, name) != 0) return 0;
|
||||
if (copy_str(e.path, (int)sizeof e.path, full) != 0) return 0;
|
||||
e.pages = pages;
|
||||
e.subdirs = 0;
|
||||
e.has_images = 1;
|
||||
snprintf(e.subtitle, sizeof e.subtitle, "%d page%s", pages, pages == 1 ? "" : "s");
|
||||
entry_badge(&e);
|
||||
e.is_archive = 1;
|
||||
if (pages < 0) {
|
||||
e.pages = -1;
|
||||
e.has_images = -1;
|
||||
e.probe_state = MR_LIB_PENDING;
|
||||
} else {
|
||||
e.pages = pages;
|
||||
e.has_images = (pages > 0) ? 1 : 0;
|
||||
e.probe_state = MR_LIB_READY;
|
||||
}
|
||||
mr_library_format_subtitle(&e);
|
||||
return lib_add(lib, &e);
|
||||
}
|
||||
|
||||
/* ============================================================ */
|
||||
/* 单层扫描 */
|
||||
/* ============================================================ */
|
||||
int mr_library_scan_ex(mr_library *lib, const char *dir, int max_depth,
|
||||
mr_lib_archive_fn archive_pages, void *ud)
|
||||
{
|
||||
(void)max_depth; /* 兼容旧签名：扫描不再递归 */
|
||||
(void)ud;
|
||||
if (!lib) return -1;
|
||||
mr_library_free(lib);
|
||||
if (!dir || !dir[0]) return -1;
|
||||
|
||||
if (max_depth <= 0 || max_depth > MR_LIB_MAX_DEPTH) max_depth = MR_LIB_MAX_DEPTH;
|
||||
|
||||
IO_OPEN();
|
||||
DIR *d = opendir(dir);
|
||||
if (!d) return -1;
|
||||
|
||||
struct dirent *de;
|
||||
while ((de = readdir(d)) != NULL) {
|
||||
IO_READDIR();
|
||||
const char *name = de->d_name;
|
||||
if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue;
|
||||
if (ignored_dir_name(name)) continue;
|
||||
if (name[0] == '.') continue; /* . .. 与隐藏项 */
|
||||
|
||||
char full[MR_PATH_MAX];
|
||||
if (join_path(full, (int)sizeof full, dir, name) != 0) continue;
|
||||
|
||||
IO_LSTAT();
|
||||
struct stat st;
|
||||
if (lstat(full, &st) != 0) continue;
|
||||
if (S_ISLNK(st.st_mode)) continue;
|
||||
|
||||
int rc = 0;
|
||||
if (S_ISDIR(st.st_mode)) {
|
||||
scan_info si;
|
||||
scan_dir(full, 1, max_depth, &si, archive_pages, ud);
|
||||
if (!si.nav) continue;
|
||||
rc = add_dir_entry(lib, name, full, &si);
|
||||
} else if (S_ISREG(st.st_mode) && mr_path_is_archive(name)) {
|
||||
int pages = archive_pages_at(archive_pages, ud, full);
|
||||
if (pages <= 0) continue; /* 坏档/无图片页：不当书 */
|
||||
rc = add_archive_entry(lib, name, full, pages);
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
int is_dir = S_ISDIR(st.st_mode);
|
||||
int is_arch = (!is_dir && archive_pages && S_ISREG(st.st_mode) &&
|
||||
mr_path_is_archive(name));
|
||||
if (!is_dir && !is_arch) continue;
|
||||
if (lib->count >= MR_LIB_SCAN_MAX) { lib->truncated = 1; break; }
|
||||
|
||||
int rc = is_dir ? add_dir_entry(lib, name, full)
|
||||
: add_archive_entry(lib, name, full, -1);
|
||||
if (rc != 0) {
|
||||
closedir(d);
|
||||
mr_library_free(lib);
|
||||
@@ -317,7 +491,8 @@ int mr_library_scan_ex(mr_library *lib, const char *dir, int max_depth,
|
||||
}
|
||||
closedir(d);
|
||||
|
||||
if (lib->count > 1) qsort(lib->items, (size_t)lib->count, sizeof *lib->items, entry_cmp);
|
||||
if (lib->count > 1)
|
||||
qsort(lib->items, (size_t)lib->count, sizeof *lib->items, entry_cmp);
|
||||
return lib->count;
|
||||
}
|
||||
|
||||
@@ -326,6 +501,62 @@ int mr_library_scan(mr_library *lib, const char *dir, int max_depth)
|
||||
return mr_library_scan_ex(lib, dir, max_depth, NULL, NULL);
|
||||
}
|
||||
|
||||
int mr_library_apply_probe(mr_library *lib, int idx, const mr_library_probe *p)
|
||||
{
|
||||
if (!lib || !p || idx < 0 || idx >= lib->count) return 0;
|
||||
mr_library_entry *e = &lib->items[idx];
|
||||
e->pages = p->pages;
|
||||
e->empty = p->empty;
|
||||
e->has_images = (p->pages > 0) ? 1 : 0;
|
||||
e->probe_state = MR_LIB_READY;
|
||||
copy_str(e->cover, (int)sizeof e->cover, p->cover);
|
||||
mr_library_format_subtitle(e);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int mr_library_mark_error(mr_library *lib, int idx)
|
||||
{
|
||||
if (!lib || idx < 0 || idx >= lib->count) return 0;
|
||||
mr_library_entry *e = &lib->items[idx];
|
||||
e->pages = -1;
|
||||
e->empty = 0;
|
||||
e->has_images = 0;
|
||||
e->probe_state = MR_LIB_FAILED;
|
||||
e->cover[0] = '\0';
|
||||
mr_library_format_subtitle(e);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int mr_library_row_at(const mr_library *lib, int idx, mr_library_row *out)
|
||||
{
|
||||
static char trunc_sub[48];
|
||||
static int trunc_ready;
|
||||
|
||||
if (!lib || !out) return 0;
|
||||
if (idx == lib->count && lib->truncated) {
|
||||
if (!trunc_ready) {
|
||||
snprintf(trunc_sub, sizeof trunc_sub, "仅显示前 %d 项", MR_LIB_SCAN_MAX);
|
||||
trunc_ready = 1;
|
||||
}
|
||||
memset(out, 0, sizeof *out);
|
||||
out->title = "已截断";
|
||||
out->subtitle = trunc_sub;
|
||||
out->disabled = 1;
|
||||
out->index = -1;
|
||||
return 1;
|
||||
}
|
||||
if (idx < 0 || idx >= lib->count) return 0;
|
||||
|
||||
const mr_library_entry *e = &lib->items[idx];
|
||||
memset(out, 0, sizeof *out);
|
||||
out->title = e->name;
|
||||
out->subtitle = e->subtitle;
|
||||
out->is_book = (e->has_images == 1);
|
||||
out->is_archive = e->is_archive;
|
||||
out->index = idx;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int mr_path_parent(const char *path, char *out, int outsz)
|
||||
{
|
||||
if (!path || !out || outsz <= 0) return -1;
|
||||
@@ -346,7 +577,7 @@ int mr_path_parent(const char *path, char *out, int outsz)
|
||||
}
|
||||
|
||||
/* ============================================================ */
|
||||
/* 册间衔接（M7） */
|
||||
/* 册间衔接（M7 / M11） */
|
||||
/* ============================================================ */
|
||||
int mr_library_dir_has_images(const char *dir)
|
||||
{
|
||||
@@ -427,7 +658,8 @@ int mr_book_adjacent_ex(const char *dir, int delta, char *out, int outsz,
|
||||
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)) continue;
|
||||
if (lstat(full, &st) != 0) continue;
|
||||
if (S_ISLNK(st.st_mode)) continue;
|
||||
if (!sibling_is_book(full, &st, archive_pages, ud)) continue;
|
||||
|
||||
if (n >= cap) {
|
||||
|
||||
+118
-35
@@ -1,19 +1,25 @@
|
||||
/* logic/library.h — 漫画书库扫描/排序（纯 C，不依赖 meow_ui.h）。
|
||||
/* logic/library.h — 书库目录浏览（纯 C，不依赖 meow_ui.h）。
|
||||
*
|
||||
* 分层契约同 examples/hello：logic 层只含文件系统与纯数据，宿主 gcc 可直接裸测。
|
||||
* （M7 起另提供每册续读角标与册间顺序查询；续读状态本身由 logic/reader.c 持久化，
|
||||
* 本层只读它来拼副标题，宿主测试用配置存根顶替。）
|
||||
* 书库语义：
|
||||
* - 从 TF 卡根（MR_ROOT_DIR）起列「直接子目录」；M11 起另列直接子文件里的
|
||||
* .cbz/.zip（档案册即一本书，与文件夹册同列自然序混排）；
|
||||
* - 只保留自身含 PNG/JPEG/BMP 的目录，或子树中最终含书的中间目录（可继续导航）；
|
||||
* - 行的 pages=该目录直接图片数（档案册=档内图片页数）；subdirs=其下含图子目录数；
|
||||
* - cover=缩略图源文件：优先该目录自然序第一张图，否则取第一个含图子目录的 cover
|
||||
* （档案册留空，UI 解压档内首图）；
|
||||
* - 条目按名称自然排序（page2 < page10），含前导零与数字/字母混合名。
|
||||
*
|
||||
* 深度上限 MR_LIB_MAX_DEPTH 用于防止坏卡/超大树的无限递归；隐藏目录与系统目录
|
||||
* （. 开头、MeowAPPs/MeowData/MeowOS/lost+found）不参与书库。符号链接跳过（防环）。
|
||||
* M13 浏览语义（用户要求：性能 + 访问放开；参考 os.meow.files 的 fsx_scan_dir）：
|
||||
* - mr_library_scan / mr_library_scan_ex 只枚举**当前目录一层**：一次 opendir/readdir +
|
||||
* 逐项 lstat，列出全部子目录（自然升序），不做任何递归「子树含图」探测；
|
||||
* - 访问放开：系统目录（MeowAPPs/MeowData/MeowOS/lost+found）不再隐藏，
|
||||
* 空目录/无图目录一律列出并可进入；仅跳过 "."/".." 与其它 "." 开头的隐藏项、
|
||||
* 符号链接（防环）；
|
||||
* - 「直接含图目录=一本书」的判定改为**后台懒算**：mr_library_probe_dir 只读一层，
|
||||
* mr_library_probe_path 按行类型（目录/档案册）走同一套 mtime 失效缓存（线程安全），
|
||||
* 结果经 mr_library_apply_probe 补回行（页数/首图/副标题）。首帧/滚动不做子目录 IO；
|
||||
* - 单目录条目上限 MR_LIB_SCAN_MAX（默认 2000）：到上限后若还有条目则截断并置
|
||||
* lib->truncated=1（UI 用 mr_library_row_at 末尾的提示行标注）。
|
||||
*
|
||||
* M11 档案册（.cbz/.zip）：注入 archive_pages 回调时，当前层的档案文件也成行（与目录同列
|
||||
* 自然序混排）；档案册的页数同样走懒探测（mr_library_probe_path + 注入回调），logic 层
|
||||
* 不依赖 zip 容器。未注入时（archive_pages==NULL）只列目录，等价 M7 书库。
|
||||
*
|
||||
* M7 续读角标 / 册间衔接：mr_library_format_subtitle 在探测完成后拼「· 续读 Pn」
|
||||
* （mr_cont_badge）；mr_library_dir_has_images / mr_book_adjacent(_ex) 语义不变。
|
||||
*/
|
||||
#ifndef MR_LIBRARY_H
|
||||
#define MR_LIBRARY_H
|
||||
@@ -24,24 +30,55 @@ extern "C" {
|
||||
|
||||
#define MR_PATH_MAX 512
|
||||
#define MR_NAME_MAX 256
|
||||
#define MR_LIB_MAX_DEPTH 8
|
||||
#define MR_LIB_MAX_DEPTH 8 /* 兼容旧调用：扫描已不递归，该参数被忽略 */
|
||||
|
||||
/* 单目录列出的条目上限（超大目录截断 + UI 提示；可用 -D 覆写便于宿主测试）。 */
|
||||
#ifndef MR_LIB_SCAN_MAX
|
||||
#define MR_LIB_SCAN_MAX 2000
|
||||
#endif
|
||||
|
||||
/* 行懒判定状态：0=待探测（副标题占位「…」）/1=已探测/2=探测失败（不可读）。 */
|
||||
#define MR_LIB_PENDING 0
|
||||
#define MR_LIB_READY 1
|
||||
#define MR_LIB_FAILED 2
|
||||
|
||||
typedef struct mr_library_entry {
|
||||
char name[MR_NAME_MAX]; /* 目录名/档案文件名（行主标题） */
|
||||
char path[MR_PATH_MAX]; /* 完整路径（导航/进 reader 用） */
|
||||
char cover[MR_PATH_MAX]; /* 缩略图源图（空=none；档案册由 UI 解压首图） */
|
||||
char subtitle[48]; /* 预先格式化好的 "N pages" / "N books" / "N folders" */
|
||||
int pages; /* 本目录直接图片数（档案册=档内图片页数） */
|
||||
int subdirs; /* 本目录下含图子目录数 */
|
||||
int has_images; /* 1=可直接阅读（直接含图 或 档案册） */
|
||||
char path[MR_PATH_MAX]; /* 完整路径（导航/进 reader/探测用） */
|
||||
char cover[MR_PATH_MAX]; /* 后台探测填：自然序第一张直接子图（档案册留空，UI 解压首图） */
|
||||
char subtitle[48]; /* 占位「…」；探测后 "N pages"/"空目录"/"无图片"/"无法读取" */
|
||||
int pages; /* -1=未判定；>=0=直接图片数（档案册=档内图片页数） */
|
||||
int subdirs; /* 兼容字段（M11 及旧读者）：新扫描不统计，恒 0 */
|
||||
int has_images; /* 1=书；0=非书；-1=未判定 */
|
||||
int probe_state; /* MR_LIB_PENDING / MR_LIB_READY / MR_LIB_FAILED */
|
||||
int empty; /* 1=空目录（目录且 probe_state==READY 后有效） */
|
||||
int is_archive; /* 1=.cbz/.zip 档案册行 */
|
||||
} mr_library_entry;
|
||||
|
||||
typedef struct mr_library {
|
||||
mr_library_entry *items;
|
||||
int count;
|
||||
int count; /* 当前层列出的条目数 */
|
||||
int cap;
|
||||
int truncated; /* 1=达到 MR_LIB_SCAN_MAX 被截断 */
|
||||
} mr_library;
|
||||
|
||||
/* 单行探测结果（目录=本层直接图片数；档案册=档内图片页数；均不递归）。 */
|
||||
typedef struct mr_library_probe {
|
||||
int pages; /* 受支持图片数（png/jpg/jpeg/bmp；档案册=档内页数） */
|
||||
int empty; /* 1=目录没有可见子项（档案册恒 0） */
|
||||
char cover[MR_PATH_MAX]; /* 目录的自然序第一张图（档案册留空） */
|
||||
} mr_library_probe;
|
||||
|
||||
/* 行数据（纯内存合成；UI 的每帧 src 回调直接取用，零 IO）。 */
|
||||
typedef struct mr_library_row {
|
||||
const char *title; /* 主标题 */
|
||||
const char *subtitle; /* 副标题（可空串） */
|
||||
int is_book; /* 1=书（显示页数/缩略图，点入阅读，无进入箭头） */
|
||||
int is_archive; /* 1=档案册行 */
|
||||
int disabled; /* 1=提示行（不可点，如截断标注） */
|
||||
int index; /* 对应 mr_library.items 下标；提示行=-1 */
|
||||
} mr_library_row;
|
||||
|
||||
/* 扩展名判断：png/jpg/jpeg/bmp（大小写不敏感）。1=受支持图片。 */
|
||||
int mr_path_is_image(const char *name);
|
||||
|
||||
@@ -53,22 +90,19 @@ int mr_path_is_archive(const char *name);
|
||||
* 非数字段 ASCII 大小写不敏感，完全等价时按原始字节序定序。 */
|
||||
int mr_natural_cmp(const char *a, const char *b);
|
||||
|
||||
/* 扫描 dir 的直接子目录，写入 lib（先释放 lib 旧内容）。
|
||||
* 返回条目数（>=0）；dir 不可读返回 -1（lib 仍为空且可安全 mr_library_free）。
|
||||
* max_depth<=0 或超过 MR_LIB_MAX_DEPTH 时按上限处理。 */
|
||||
/* 扫描 dir 的**直接子目录**（单层；不读子目录内容），写入 lib（先释放 lib 旧内容）。
|
||||
* 返回条目数（>=0）；dir 不可读/不存在/不是目录返回 -1（lib 仍为空且可安全 free）。
|
||||
* max_depth 仅为兼容旧调用保留，已忽略（不再递归）。 */
|
||||
int mr_library_scan(mr_library *lib, const char *dir, int max_depth);
|
||||
|
||||
/* ============================================================ */
|
||||
/* 档案册（M11）：.cbz/.zip 当一本书，与文件夹册同列 */
|
||||
/* ------------------------------------------------------------
|
||||
* logic 层不依赖 zip 容器（保持宿主裸测/链接面干净）：档案册探测由 UI 注入。
|
||||
* archive_pages(path, ud) 对普通文件返回图片页数（>0=是一本书），0=不是/坏档。
|
||||
* 传 NULL 时行为与 mr_library_scan 完全一致（纯目录书库），M7 语义不变。
|
||||
*
|
||||
* 档案册行的口径：name=文件名（含扩展名）、path=档案文件路径、pages=档内页数、
|
||||
* has_images=1（点入直接阅读）、cover 留空（缩略图由 UI 解压首图生成）、
|
||||
* 副标题 "N pages"、续读角标同文件夹册（按档案路径记）。
|
||||
* 只含档案册的子目录算「可导航」（nav），副标题写 "N books"。
|
||||
* archive_pages(path, ud) 返回档内图片页数（>0=是一本书），0=不是/坏档。
|
||||
* 传 NULL 时行为与 M7 完全一致（纯目录书库，档案文件不成行）。
|
||||
* 档案册行：name=文件名、path=档案路径、is_archive=1、cover 留空（UI 解压首图）、
|
||||
* 页数/书标记由后台 probe 经同一注入回调懒算。
|
||||
* ============================================================ */
|
||||
typedef int (*mr_lib_archive_fn)(const char *path, void *ud);
|
||||
|
||||
@@ -79,14 +113,52 @@ int mr_library_scan_ex(mr_library *lib, const char *dir, int max_depth,
|
||||
void mr_library_free(mr_library *lib);
|
||||
|
||||
/* 取父目录路径（去掉末尾 '/' 后截断最后一段）。根 "/" 返回 "/"。
|
||||
* 成功 0；参数非法/输出缓冲不足 -1。 */
|
||||
* 成功 0；参数非法/输出缓冲不足 -1。可一路向上到文件系统 '/'。 */
|
||||
int mr_path_parent(const char *path, char *out, int outsz);
|
||||
|
||||
/* ---- 后台懒判定（单层探测；可由工作线程调用） ---- */
|
||||
|
||||
/* 单层探测目录 dir：直接图片数 + 自然序首图 + 是否空目录。不递归、不跟随符号链接。
|
||||
* 0=成功；-1=参数非法/不可读（out 清零）。 */
|
||||
int mr_library_probe_dir(const char *dir, mr_library_probe *out);
|
||||
|
||||
/* 带缓存探测目录：按目录 mtime（秒+纳秒）+ size 失效；内部互斥锁，可多线程并发调用。
|
||||
* 0=成功（可能来自缓存）；-1=不可读（失败不缓存）。 */
|
||||
int mr_library_probe_cached(const char *dir, mr_library_probe *out);
|
||||
|
||||
/* 按行探测（目录或档案册），带同一套缓存：
|
||||
* is_archive=0 → 目录（等价 mr_library_probe_cached）；
|
||||
* is_archive=1 → 调 archive_pages(path,ud) 取档内页数（cover 留空、empty=0）；
|
||||
* archive_pages 为 NULL 时返回 -1。
|
||||
* 0=成功；-1=参数非法/不可读。探测期间 mtime/size 变化则不写入缓存（避免假新鲜）。 */
|
||||
int mr_library_probe_path(const char *path, int is_archive,
|
||||
mr_lib_archive_fn archive_pages, void *ud,
|
||||
mr_library_probe *out);
|
||||
|
||||
/* 清空探测缓存（目录整体切换/测试用）。 */
|
||||
void mr_library_probe_cache_clear(void);
|
||||
|
||||
/* 把探测结果补回第 idx 行（pages/has_images/cover/subtitle/empty）。
|
||||
* 1=已应用；0=参数非法/越界。 */
|
||||
int mr_library_apply_probe(mr_library *lib, int idx, const mr_library_probe *p);
|
||||
|
||||
/* 标记第 idx 行探测失败（不可读）：副标题「无法读取」，视为非书。1=已应用；0=非法。 */
|
||||
int mr_library_mark_error(mr_library *lib, int idx);
|
||||
|
||||
/* 按行当前状态重算副标题（占位/页数/空目录/无图片/无法读取），
|
||||
* 并在书行（has_images==1）后缀「· 续读 Pn」（M7 角标）。 */
|
||||
void mr_library_format_subtitle(mr_library_entry *e);
|
||||
|
||||
/* 行合成（纯内存、零 IO、O(1)；UI 线程每帧调用）：idx 越界返回 0。
|
||||
* idx==count 且 lib->truncated 时输出末尾提示行（disabled=1）。
|
||||
* 返回的 title/subtitle 指向 lib 内部或函数内静态缓冲（截断提示行），调用方不要长期持有。 */
|
||||
int mr_library_row_at(const mr_library *lib, int idx, mr_library_row *out);
|
||||
|
||||
/* 目录是否**直接**含受支持图片（= 书库语义里的「一本书」，可直接进 reader）。
|
||||
* 1=有；0=没有/不可读。 */
|
||||
int mr_library_dir_has_images(const char *dir);
|
||||
|
||||
/* 册间衔接（M7）：同父目录下按书库自然序排列的「可直接阅读」兄弟册。
|
||||
/* 册间衔接（M7）：同父目录下按书库自然序排列的「直接含图」兄弟册。
|
||||
* delta=+1 下一册 / -1 上一册。1=找到并写入 out 完整路径；
|
||||
* 0=没有相邻册（当前册是首/末册，或当前册不在兄弟表中）；-1=参数非法。
|
||||
* 语义与书库一致：跳过隐藏/系统目录与符号链接，排序同 mr_natural_cmp。
|
||||
@@ -94,12 +166,23 @@ int mr_library_dir_has_images(const char *dir);
|
||||
int mr_book_adjacent(const char *dir, int delta, char *out, int outsz);
|
||||
|
||||
/* 册间衔接 + 档案册（M11）：兄弟表 = 「直接含图目录」∪「含图片页的 .cbz/.zip」，
|
||||
* 两者同列按名称自然序混排（mission 基线：跨册衔接按同父目录自然序）。
|
||||
* 因此末页前进可以从文件夹册进到同目录的档案册，反之亦然。
|
||||
* 两者同列按名称自然序混排（跨册衔接按同父目录自然序）。
|
||||
* archive_pages 传 NULL 时与 mr_book_adjacent 完全等价。 */
|
||||
int mr_book_adjacent_ex(const char *dir, int delta, char *out, int outsz,
|
||||
mr_lib_archive_fn archive_pages, void *ud);
|
||||
|
||||
#ifdef MR_LIBRARY_TEST_HOOKS
|
||||
/* 宿主测试用 IO 计数（scan/probe_dir 的 opendir/readdir/lstat 次数；线程安全不保证）。 */
|
||||
typedef struct mr_library_io_stats {
|
||||
long opendirs;
|
||||
long readdirs;
|
||||
long lstats;
|
||||
} mr_library_io_stats;
|
||||
|
||||
void mr_library_test_io_reset(void);
|
||||
void mr_library_test_io_get(mr_library_io_stats *out);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
+50
-12
@@ -1,6 +1,9 @@
|
||||
#!/bin/bash
|
||||
# run_tests.sh — 宿主 gcc 构建并运行图库测试（不链 SDK 静态库、不需要设备）。
|
||||
# - test_library：书库扫描/自然排序/阅读方向（46 项）
|
||||
# - test_library：单层目录扫描/自然排序/父目录/阅读方向
|
||||
# - test_browse_nav：访问放开（系统/空/无图目录可进入）、上溯到 /、不可读目录、截断
|
||||
# - test_browse_lazy：单层探测/懒判定补位/mtime 失效缓存/行合成 O(1)/M7 册间语义
|
||||
# - test_browse_perf：500 目录×8 层嵌套+2000 文件夹具，断言扫描单层且有界
|
||||
# - test_settings_reader_persist：阅读方向 meow_config 持久化（默认/落盘/重启恢复/
|
||||
# 坏值/非法值/只读一次/写失败只告警）
|
||||
# - test_pin：启动 PIN 格式/设置/校验/修改/禁用/残缺配置/落盘失败（logic/pin.c 为纯 C，
|
||||
@@ -10,30 +13,48 @@
|
||||
# 交付环境只有库+头时自动 SKIP。
|
||||
# reader.c 的方向持久化只 include 配置/日志两个模块头；宿主测试用 test/settings_reader_stub.c
|
||||
# 顶替 meow_config_* 与 meow_log（所以下面各条都带 -I"$SDK" 与该存根）。
|
||||
# logic/library.c 的探测缓存用 pthread 互斥锁 → 相关编译带 -pthread。
|
||||
set -e
|
||||
cd "$(dirname "$0")/.."
|
||||
SDK="${MEOW_SDK_DIR:-$HOME/Proj/MeowOS-SDK/sdk}"
|
||||
OUT=build/host
|
||||
mkdir -p "$OUT"
|
||||
|
||||
gcc -Wall -Wextra -O1 -I. -I"$SDK" \
|
||||
test/test_library.c logic/library.c logic/reader.c test/settings_reader_stub.c \
|
||||
-o test/test_library
|
||||
./test/test_library
|
||||
-pthread -o "$OUT/test_library"
|
||||
"$OUT"/test_library
|
||||
|
||||
gcc -Wall -Wextra -O1 -DMR_LIBRARY_TEST_HOOKS -I. -I"$SDK" \
|
||||
test/test_browse_nav.c logic/library.c logic/reader.c test/settings_reader_stub.c \
|
||||
-pthread -o "$OUT/test_browse_nav"
|
||||
"$OUT"/test_browse_nav
|
||||
|
||||
gcc -Wall -Wextra -O1 -DMR_LIBRARY_TEST_HOOKS -I. -I"$SDK" \
|
||||
test/test_browse_lazy.c logic/library.c logic/reader.c test/settings_reader_stub.c \
|
||||
-pthread -o "$OUT/test_browse_lazy"
|
||||
"$OUT"/test_browse_lazy
|
||||
|
||||
gcc -Wall -Wextra -O1 -DMR_LIBRARY_TEST_HOOKS -I. -I"$SDK" \
|
||||
test/test_browse_perf.c logic/library.c logic/reader.c test/settings_reader_stub.c \
|
||||
-pthread -o "$OUT/test_browse_perf"
|
||||
"$OUT"/test_browse_perf
|
||||
|
||||
gcc -Wall -Wextra -O1 -I. -I"$SDK" \
|
||||
test/test_reader_core.c logic/library.c logic/reader.c \
|
||||
logic/reader/page_source.c logic/reader/nav.c test/settings_reader_stub.c \
|
||||
-o test/test_reader_core
|
||||
./test/test_reader_core
|
||||
-pthread -o "$OUT/test_reader_core"
|
||||
"$OUT"/test_reader_core
|
||||
|
||||
gcc -Wall -Wextra -O1 -DMR_READER_TEST_HOOKS -I. -I"$SDK" \
|
||||
test/test_settings_reader_persist.c logic/reader.c test/settings_reader_stub.c \
|
||||
-o test/test_settings_reader_persist
|
||||
./test/test_settings_reader_persist
|
||||
-o "$OUT"/test_settings_reader_persist
|
||||
"$OUT"/test_settings_reader_persist
|
||||
|
||||
gcc -Wall -Wextra -O1 -I. -I"$SDK" \
|
||||
test/test_pin.c logic/pin.c \
|
||||
-o test/test_pin
|
||||
./test/test_pin
|
||||
-o "$OUT"/test_pin
|
||||
"$OUT"/test_pin
|
||||
|
||||
if [ -f "$SDK/meow_ui_view.c" ] && [ -f "$SDK/meow_ui_config.c" ]; then
|
||||
gcc -Wall -Wextra -O1 -DMEOW_UI_HOST_TEST -I. -I"$SDK" -I"$SDK/include" \
|
||||
@@ -47,10 +68,27 @@ if [ -f "$SDK/meow_ui_view.c" ] && [ -f "$SDK/meow_ui_config.c" ]; then
|
||||
"$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 test/test_settings_lock_host
|
||||
./test/test_settings_lock_host
|
||||
-pthread -lm -o "$OUT"/test_settings_lock_host
|
||||
"$OUT"/test_settings_lock_host
|
||||
|
||||
# 书库浏览页集成（src2 懒算补位/行语义/上溯至 / /不可读提示）；同样需要 SDK 源码树。
|
||||
gcc -Wall -Wextra -O1 -DMEOW_UI_HOST_TEST -DMR_LIBRARY_UI_TEST_HOOKS \
|
||||
-I. -I"$SDK" -I"$SDK/include" \
|
||||
test/test_browse_ui_host.c ui/library/library.c logic/library.c \
|
||||
logic/reader.c logic/reader/page_source.c logic/reader/archive_source.c \
|
||||
logic/reader/page_cache.c logic/zip/zip.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 -lz -o "$OUT"/test_browse_ui_host
|
||||
"$OUT"/test_browse_ui_host
|
||||
else
|
||||
echo "SKIP test_settings_lock_host: SDK 源码树不可用（只发布 meow_ui.a 的环境）"
|
||||
echo "SKIP test_settings_lock_host/test_browse_ui_host: SDK 源码树不可用（只发布 meow_ui.a 的环境）"
|
||||
fi
|
||||
|
||||
# ---- 档案册（M11）：zip 容器 + CBZ 书库/阅读器集成 ----
|
||||
|
||||
@@ -0,0 +1,443 @@
|
||||
/* test_browse_lazy.c — 单层探测 / 懒判定 / mtime 失效缓存 / 行合成（纯 C，无 SDK）。
|
||||
*
|
||||
* 覆盖：
|
||||
* L1 单层探测：直接图片数、自然序首图、空目录标记；不递归（只有子目录含图的目录不算书）；
|
||||
* L2 懒判定接线：scan 后行全部 PENDING（占位副标题）→ apply_probe 后页数/首图/副标题/
|
||||
* 书标记；空目录「空目录」；无图目录「无图片」；探测失败「无法读取」且视为非书；
|
||||
* L3 缓存：mtime 失效（同 mtime 命中不读盘；目录变化后重扫并刷新结果）；并发调用线程安全；
|
||||
* L3b 评审 P2：探测期间 mtime/size 变化的结果不写缓存（避免「不完整结果绑定新 mtime」）；
|
||||
* L4 行合成 O(1)：mr_library_row_at 纯内存（IO 计数不变）、截断提示行；
|
||||
* L5 M7 兼容语义：「直接含图兄弟册」+ 自然序册间顺序（M7 mr_book_adjacent 的口径）。
|
||||
*
|
||||
* 编译（在 tuku/ 下）：
|
||||
* gcc -Wall -Wextra -O1 -I. -I../sdk -DMR_LIBRARY_TEST_HOOKS \
|
||||
* test/test_browse_lazy.c logic/library.c logic/reader.c test/settings_reader_stub.c \
|
||||
* -pthread -o build/host/test_browse_lazy
|
||||
*/
|
||||
#include "logic/library.h"
|
||||
|
||||
#include <dirent.h>
|
||||
#include <fcntl.h>
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <time.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;
|
||||
fputs("x", f);
|
||||
return fclose(f);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
/* 把目录 mtime 显式推后 3 秒（避免同秒内变化被缓存误命中）。 */
|
||||
static void bump_mtime(const char *path)
|
||||
{
|
||||
struct timespec ts[2];
|
||||
ts[0].tv_sec = time(NULL) + 3;
|
||||
ts[0].tv_nsec = 0;
|
||||
ts[1] = ts[0];
|
||||
utimensat(AT_FDCWD, path, ts, 0);
|
||||
}
|
||||
|
||||
static const mr_library_entry *find_entry(const mr_library *lib, const char *name)
|
||||
{
|
||||
for (int i = 0; i < lib->count; i++)
|
||||
if (strcmp(lib->items[i].name, name) == 0) return &lib->items[i];
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int find_index(const mr_library *lib, const char *name, int *out)
|
||||
{
|
||||
for (int i = 0; i < lib->count; i++)
|
||||
if (strcmp(lib->items[i].name, name) == 0) { *out = i; return 1; }
|
||||
*out = -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* ---- L1 + L2 ---- */
|
||||
static void test_probe_and_apply(const char *root)
|
||||
{
|
||||
char book[MR_PATH_MAX], noimg[MR_PATH_MAX], empty[MR_PATH_MAX], dirs_only[MR_PATH_MAX];
|
||||
char deep[MR_PATH_MAX];
|
||||
joinp(book, sizeof book, root, "book");
|
||||
joinp(noimg, sizeof noimg, root, "noimg");
|
||||
joinp(empty, sizeof empty, root, "empty");
|
||||
joinp(dirs_only, sizeof dirs_only, root, "dirs_only");
|
||||
joinp(deep, sizeof deep, root, "dirs_only/deep");
|
||||
|
||||
mr_library_probe p;
|
||||
CHECK(mr_library_probe_dir(book, &p) == 0, "probe book");
|
||||
CHECK(p.pages == 2, "book pages=%d", p.pages);
|
||||
CHECK(p.empty == 0, "book not empty");
|
||||
CHECK(strstr(p.cover, "page2.png") != NULL, "cover natural-first: %s", p.cover);
|
||||
|
||||
CHECK(mr_library_probe_dir(noimg, &p) == 0 && p.pages == 0 && p.empty == 0,
|
||||
"noimg: 0 pages, not empty");
|
||||
CHECK(mr_library_probe_dir(empty, &p) == 0 && p.pages == 0 && p.empty == 1,
|
||||
"empty dir flagged");
|
||||
CHECK(mr_library_probe_dir(dirs_only, &p) == 0 && p.pages == 0 && p.empty == 0,
|
||||
"dirs_only has no direct images (no recursion)");
|
||||
CHECK(mr_library_probe_dir(deep, &p) == 0 && p.pages == 1, "deep is a book");
|
||||
|
||||
char slash[MR_PATH_MAX];
|
||||
snprintf(slash, sizeof slash, "%s/", book);
|
||||
CHECK(mr_library_probe_dir(slash, &p) == 0 && p.pages == 2, "trailing slash");
|
||||
|
||||
CHECK(mr_library_probe_dir("/no/such/dir", &p) == -1, "missing dir -> -1");
|
||||
CHECK(mr_library_probe_dir(NULL, &p) == -1, "NULL -> -1");
|
||||
|
||||
mr_library lib;
|
||||
memset(&lib, 0, sizeof lib);
|
||||
CHECK(mr_library_scan(&lib, root, MR_LIB_MAX_DEPTH) == 5, "scan 5 dirs (got %d)", lib.count);
|
||||
|
||||
const mr_library_entry *e = find_entry(&lib, "book");
|
||||
CHECK(e && e->probe_state == MR_LIB_PENDING && e->pages == -1,
|
||||
"book pending after scan");
|
||||
|
||||
int idx_book, idx_noimg, idx_empty, idx_dirs;
|
||||
CHECK(find_index(&lib, "book", &idx_book), "book index");
|
||||
CHECK(find_index(&lib, "noimg", &idx_noimg), "noimg index");
|
||||
CHECK(find_index(&lib, "empty", &idx_empty), "empty index");
|
||||
CHECK(find_index(&lib, "dirs_only", &idx_dirs), "dirs_only index");
|
||||
if (idx_book < 0 || idx_noimg < 0 || idx_empty < 0 || idx_dirs < 0) {
|
||||
mr_library_free(&lib);
|
||||
return;
|
||||
}
|
||||
|
||||
CHECK(mr_library_probe_dir(lib.items[idx_book].path, &p) == 0, "probe row book");
|
||||
CHECK(mr_library_apply_probe(&lib, idx_book, &p) == 1, "apply book");
|
||||
e = &lib.items[idx_book];
|
||||
CHECK(e->has_images == 1 && e->pages == 2 && e->probe_state == MR_LIB_READY,
|
||||
"book ready");
|
||||
CHECK(strcmp(e->subtitle, "2 pages") == 0, "book subtitle=%s", e->subtitle);
|
||||
CHECK(strstr(e->cover, "page2.png") != NULL, "book row cover=%s", e->cover);
|
||||
|
||||
CHECK(mr_library_probe_dir(lib.items[idx_noimg].path, &p) == 0 &&
|
||||
mr_library_apply_probe(&lib, idx_noimg, &p) == 1, "apply noimg");
|
||||
e = &lib.items[idx_noimg];
|
||||
CHECK(e->has_images == 0 && strcmp(e->subtitle, "无图片") == 0,
|
||||
"noimg subtitle=%s", e->subtitle);
|
||||
|
||||
CHECK(mr_library_probe_dir(lib.items[idx_empty].path, &p) == 0 &&
|
||||
mr_library_apply_probe(&lib, idx_empty, &p) == 1, "apply empty");
|
||||
e = &lib.items[idx_empty];
|
||||
CHECK(e->has_images == 0 && e->empty == 1 && strcmp(e->subtitle, "空目录") == 0,
|
||||
"empty subtitle=%s", e->subtitle);
|
||||
|
||||
CHECK(mr_library_mark_error(&lib, idx_dirs) == 1, "mark error");
|
||||
e = &lib.items[idx_dirs];
|
||||
CHECK(e->probe_state == MR_LIB_FAILED && e->has_images == 0 &&
|
||||
strcmp(e->subtitle, "无法读取") == 0, "failed subtitle=%s", e->subtitle);
|
||||
|
||||
CHECK(mr_library_apply_probe(&lib, 999, &p) == 0, "apply out of range");
|
||||
CHECK(mr_library_mark_error(&lib, -1) == 0, "mark_error out of range");
|
||||
|
||||
mr_library_free(&lib);
|
||||
}
|
||||
|
||||
/* 档案册探测回调（P2 用例）：可注入「探测期间文件变化」。 */
|
||||
typedef struct arch_probe_ctx {
|
||||
int calls;
|
||||
int bump_times; /* 前 N 次调用里改动文件 mtime（模拟探测期间变化） */
|
||||
} arch_probe_ctx;
|
||||
|
||||
static int arch_probe(const char *path, void *ud)
|
||||
{
|
||||
arch_probe_ctx *c = (arch_probe_ctx *)ud;
|
||||
c->calls++;
|
||||
if (c->calls <= c->bump_times) bump_mtime(path);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* ---- L3b：评审 P2——探测期间 mtime 变化不得写入缓存（消除假新鲜） ---- */
|
||||
static void test_cache_race(const char *root)
|
||||
{
|
||||
char arc[MR_PATH_MAX];
|
||||
joinp(arc, sizeof arc, root, "race.cbz");
|
||||
CHECK(touch_file(arc) == 0, "create race.cbz");
|
||||
|
||||
mr_library_probe_cache_clear();
|
||||
mr_library_probe p;
|
||||
|
||||
/* 稳定文件：第二次走缓存，回调只调一次。 */
|
||||
arch_probe_ctx stable = { 0, 0 };
|
||||
CHECK(mr_library_probe_path(arc, 1, arch_probe, &stable, &p) == 0 && p.pages == 1,
|
||||
"archive probe");
|
||||
CHECK(mr_library_probe_path(arc, 1, arch_probe, &stable, &p) == 0 && p.pages == 1,
|
||||
"archive probe (cached)");
|
||||
CHECK(stable.calls == 1, "stable archive cached (calls=%d)", stable.calls);
|
||||
|
||||
/* 探测期间文件变化：本次结果不得入缓存 → 下一次仍重新探测。 */
|
||||
mr_library_probe_cache_clear();
|
||||
arch_probe_ctx race = { 0, 1 };
|
||||
CHECK(mr_library_probe_path(arc, 1, arch_probe, &race, &p) == 0 && p.pages == 1,
|
||||
"racing archive probe");
|
||||
CHECK(race.calls == 1, "racing probe called once (calls=%d)", race.calls);
|
||||
CHECK(mr_library_probe_path(arc, 1, arch_probe, &race, &p) == 0 && p.pages == 1,
|
||||
"racing archive probe again");
|
||||
CHECK(race.calls == 2, "changed-during-probe result NOT cached (calls=%d)", race.calls);
|
||||
/* 第二次稳定后落缓存，第三次命中。 */
|
||||
CHECK(mr_library_probe_path(arc, 1, arch_probe, &race, &p) == 0 && p.pages == 1,
|
||||
"racing archive probe third");
|
||||
CHECK(race.calls == 2, "stable result cached after third call (calls=%d)", race.calls);
|
||||
mr_library_probe_cache_clear();
|
||||
}
|
||||
|
||||
/* ---- L3：mtime 失效缓存 + 并发 ---- */
|
||||
#define THREADS 6
|
||||
typedef struct th_arg {
|
||||
const char *dir;
|
||||
int want;
|
||||
int *fail;
|
||||
pthread_mutex_t *mu;
|
||||
} th_arg;
|
||||
|
||||
static void *probe_thread(void *arg)
|
||||
{
|
||||
th_arg *a = (th_arg *)arg;
|
||||
for (int i = 0; i < 200; i++) {
|
||||
mr_library_probe p;
|
||||
int ok = (mr_library_probe_cached(a->dir, &p) == 0 && p.pages == a->want);
|
||||
if (!ok) {
|
||||
pthread_mutex_lock(a->mu);
|
||||
(*a->fail)++;
|
||||
pthread_mutex_unlock(a->mu);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void test_cache(const char *root)
|
||||
{
|
||||
char book[MR_PATH_MAX];
|
||||
joinp(book, sizeof book, root, "book");
|
||||
|
||||
mr_library_probe_cache_clear();
|
||||
mr_library_io_stats st;
|
||||
mr_library_probe p;
|
||||
|
||||
mr_library_test_io_reset();
|
||||
CHECK(mr_library_probe_cached(book, &p) == 0 && p.pages == 2, "cache miss probe");
|
||||
mr_library_test_io_get(&st);
|
||||
CHECK(st.opendirs == 1, "cache miss opens once (got %ld)", st.opendirs);
|
||||
|
||||
mr_library_test_io_reset();
|
||||
CHECK(mr_library_probe_cached(book, &p) == 0 && p.pages == 2, "cache hit");
|
||||
mr_library_test_io_get(&st);
|
||||
CHECK(st.opendirs == 0 && st.lstats == 0, "cache hit does no IO (open=%ld stat=%ld)",
|
||||
st.opendirs, st.lstats);
|
||||
|
||||
char img[MR_PATH_MAX];
|
||||
joinp(img, sizeof img, book, "page30.png");
|
||||
CHECK(touch_file(img) == 0, "add image");
|
||||
bump_mtime(book);
|
||||
mr_library_test_io_reset();
|
||||
CHECK(mr_library_probe_cached(book, &p) == 0 && p.pages == 3,
|
||||
"cache invalidated by mtime (pages=%d)", p.pages);
|
||||
mr_library_test_io_get(&st);
|
||||
CHECK(st.opendirs == 1, "invalidation re-opens (got %ld)", st.opendirs);
|
||||
|
||||
CHECK(mr_library_probe_cached("/no/such/dir", &p) == -1, "missing dir -> -1");
|
||||
|
||||
pthread_t th[THREADS];
|
||||
th_arg args[THREADS];
|
||||
int failures = 0;
|
||||
pthread_mutex_t mu = PTHREAD_MUTEX_INITIALIZER;
|
||||
int started = 0;
|
||||
for (int t = 0; t < THREADS; t++) {
|
||||
args[t].dir = book;
|
||||
args[t].want = 3;
|
||||
args[t].fail = &failures;
|
||||
args[t].mu = μ
|
||||
if (pthread_create(&th[t], NULL, probe_thread, &args[t]) == 0) started++;
|
||||
}
|
||||
for (int t = 0; t < started; t++) pthread_join(th[t], NULL);
|
||||
CHECK(started == THREADS, "threads started (%d)", started);
|
||||
CHECK(failures == 0, "concurrent probe failures=%d", failures);
|
||||
pthread_mutex_destroy(&mu);
|
||||
}
|
||||
|
||||
/* ---- L4：行合成 O(1) + 截断提示行 ---- */
|
||||
static void test_rows(const char *root)
|
||||
{
|
||||
mr_library lib;
|
||||
memset(&lib, 0, sizeof lib);
|
||||
mr_library_scan(&lib, root, MR_LIB_MAX_DEPTH);
|
||||
|
||||
mr_library_io_stats st;
|
||||
mr_library_test_io_reset();
|
||||
struct timespec t0, t1;
|
||||
clock_gettime(CLOCK_MONOTONIC, &t0);
|
||||
int rows = 0;
|
||||
for (int r = 0; r < 2000; r++)
|
||||
for (int i = 0; i < lib.count; i++) {
|
||||
mr_library_row row;
|
||||
if (mr_library_row_at(&lib, i, &row)) rows++;
|
||||
}
|
||||
clock_gettime(CLOCK_MONOTONIC, &t1);
|
||||
mr_library_test_io_get(&st);
|
||||
long long us = (long long)(t1.tv_sec - t0.tv_sec) * 1000000LL +
|
||||
(t1.tv_nsec - t0.tv_nsec) / 1000LL;
|
||||
CHECK(rows == 2000 * lib.count, "rows synthesized (%d)", rows);
|
||||
CHECK(st.opendirs == 0 && st.readdirs == 0 && st.lstats == 0,
|
||||
"row synth is pure memory (open=%ld rd=%ld stat=%ld)",
|
||||
st.opendirs, st.readdirs, st.lstats);
|
||||
CHECK(us < 2000000, "row synth bounded (%lldus)", us);
|
||||
|
||||
mr_library_row row;
|
||||
CHECK(mr_library_row_at(&lib, lib.count, &row) == 0, "no extra row when not truncated");
|
||||
lib.truncated = 1;
|
||||
CHECK(mr_library_row_at(&lib, lib.count, &row) == 1 && row.disabled == 1,
|
||||
"truncation info row");
|
||||
CHECK(strcmp(row.title, "已截断") == 0, "truncation title=%s", row.title);
|
||||
CHECK(strstr(row.subtitle, "2000") != NULL, "truncation subtitle=%s", row.subtitle);
|
||||
mr_library_free(&lib);
|
||||
}
|
||||
|
||||
/* ---- L5：M7 兼容语义（直接含图兄弟册 + 自然序） ---- */
|
||||
static void collect_books(const char *parent, char names[][MR_NAME_MAX], int max, int *out_n)
|
||||
{
|
||||
mr_library lib;
|
||||
memset(&lib, 0, sizeof lib);
|
||||
int n = 0;
|
||||
if (mr_library_scan(&lib, parent, MR_LIB_MAX_DEPTH) > 0) {
|
||||
for (int i = 0; i < lib.count && n < max; i++) {
|
||||
mr_library_probe p;
|
||||
if (mr_library_probe_cached(lib.items[i].path, &p) == 0 && p.pages > 0) {
|
||||
snprintf(names[n], MR_NAME_MAX, "%s", lib.items[i].name);
|
||||
n++;
|
||||
}
|
||||
}
|
||||
}
|
||||
mr_library_free(&lib);
|
||||
*out_n = n;
|
||||
}
|
||||
|
||||
static int book_index(char names[][MR_NAME_MAX], int n, const char *cur)
|
||||
{
|
||||
for (int i = 0; i < n; i++)
|
||||
if (strcmp(names[i], cur) == 0) return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void test_m7_semantics(const char *root)
|
||||
{
|
||||
char parent[MR_PATH_MAX];
|
||||
joinp(parent, sizeof parent, root, "series");
|
||||
|
||||
char names[16][MR_NAME_MAX];
|
||||
int n = 0;
|
||||
collect_books(parent, names, 16, &n);
|
||||
CHECK(n == 3, "series books=%d (vol1/vol2/vol10; vol6 is not a book)", n);
|
||||
if (n == 3) {
|
||||
CHECK(strcmp(names[0], "vol1") == 0, "book[0]=%s", names[0]);
|
||||
CHECK(strcmp(names[1], "vol2") == 0, "book[1]=%s", names[1]);
|
||||
CHECK(strcmp(names[2], "vol10") == 0, "book[2]=%s", names[2]);
|
||||
}
|
||||
CHECK(book_index(names, n, "vol6") < 0, "dirs-only vol6 skipped (direct images only)");
|
||||
CHECK(book_index(names, n, ".hidden") < 0, "hidden skipped");
|
||||
CHECK(book_index(names, n, "MeowOS") < 0, "system dir without direct images skipped");
|
||||
|
||||
int i2 = book_index(names, n, "vol2");
|
||||
CHECK(i2 >= 0 && i2 + 1 < n && strcmp(names[i2 + 1], "vol10") == 0,
|
||||
"vol2 next = vol10 (natural order, vol6 skipped)");
|
||||
CHECK(book_index(names, n, "vol10") == n - 1, "vol10 is last (no next)");
|
||||
CHECK(book_index(names, n, "vol1") == 0, "vol1 is first (no prev)");
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
char tmpl[] = "./mr_lazy_XXXXXX";
|
||||
char *root = mkdtemp(tmpl);
|
||||
CHECK(root != NULL, "mkdtemp");
|
||||
if (!root) return 1;
|
||||
|
||||
char p[MR_PATH_MAX];
|
||||
const char *dirs[] = { "book", "noimg", "empty", "dirs_only/deep", "series" };
|
||||
for (unsigned i = 0; i < sizeof dirs / sizeof dirs[0]; i++) {
|
||||
joinp(p, sizeof p, root, dirs[i]);
|
||||
CHECK(mkdir_p(p) == 0, "mkdir %s", p);
|
||||
}
|
||||
|
||||
joinp(p, sizeof p, root, "book/page2.png"); CHECK(touch_file(p) == 0, "page2");
|
||||
joinp(p, sizeof p, root, "book/page10.jpg"); CHECK(touch_file(p) == 0, "page10");
|
||||
joinp(p, sizeof p, root, "book/notes.txt"); CHECK(touch_file(p) == 0, "notes");
|
||||
joinp(p, sizeof p, root, "noimg/readme.txt"); CHECK(touch_file(p) == 0, "readme");
|
||||
joinp(p, sizeof p, root, "dirs_only/deep/a.png"); CHECK(touch_file(p) == 0, "deep a");
|
||||
|
||||
/* M7 语义夹具：vol1/vol2/vol10 直接含图；vol6 只有子目录含图；.hidden / MeowOS 干扰项 */
|
||||
const char *mk[] = { "series/vol1/001.png", "series/vol2/001.png",
|
||||
"series/vol10/001.png", "series/vol6/sub/001.png",
|
||||
"series/.hidden/001.png", "series/MeowOS/deep/001.png" };
|
||||
for (unsigned i = 0; i < sizeof mk / sizeof mk[0]; i++) {
|
||||
joinp(p, sizeof p, root, mk[i]);
|
||||
/* 先建父目录，再落文件 */
|
||||
char dir[MR_PATH_MAX];
|
||||
snprintf(dir, sizeof dir, "%s", p);
|
||||
char *slash = strrchr(dir, '/');
|
||||
if (slash) { *slash = '\0'; CHECK(mkdir_p(dir) == 0, "mkdir %s", dir); }
|
||||
CHECK(touch_file(p) == 0, "image %s", p);
|
||||
}
|
||||
|
||||
test_probe_and_apply(root);
|
||||
test_cache(root);
|
||||
test_cache_race(root);
|
||||
test_rows(root);
|
||||
test_m7_semantics(root);
|
||||
|
||||
rm_rf(root);
|
||||
printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
|
||||
return g_fail ? 1 : 0;
|
||||
}
|
||||
@@ -0,0 +1,259 @@
|
||||
/* test_browse_nav.c — 浏览访问放开 / 上溯父目录 / 截断标注（纯 C，无 SDK）。
|
||||
*
|
||||
* 覆盖（M13 用户要求②）：
|
||||
* N1 访问放开：系统目录（MeowAPPs/MeowData/MeowOS/lost+found）不再隐藏，
|
||||
* 空目录/无图目录都列出且可进入（scan 返回 0 而不是 -1）；
|
||||
* N2 隐藏项/普通文件/符号链接仍不列（防环、防噪声）；
|
||||
* N3 不可读目录/不存在/不是目录：scan 返回 -1，调用方据此提示并停留；
|
||||
* N4 上溯父目录：mr_path_parent 可一路走到文件系统 "/"（不再以 TF 卡根为界）；
|
||||
* N5 单目录条目上限：达到 MR_LIB_SCAN_MAX 后截断并置 truncated（行合成给出提示行）。
|
||||
*
|
||||
* 编译（在 tuku/ 下）：
|
||||
* gcc -Wall -Wextra -O1 -I. -I../sdk -DMR_LIBRARY_TEST_HOOKS \
|
||||
* test/test_browse_nav.c logic/library.c logic/reader.c test/settings_reader_stub.c \
|
||||
* -pthread -o build/host/test_browse_nav
|
||||
*/
|
||||
#include "logic/library.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;
|
||||
fputs("x", f);
|
||||
return fclose(f);
|
||||
}
|
||||
|
||||
static int rm_rf(const char *path)
|
||||
{
|
||||
struct stat st;
|
||||
if (lstat(path, &st) != 0) return -1;
|
||||
if (!S_ISDIR(st.st_mode)) { chmod(path, 0700); return unlink(path); }
|
||||
chmod(path, 0700);
|
||||
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 const mr_library_entry *find_entry(const mr_library *lib, const char *name)
|
||||
{
|
||||
for (int i = 0; i < lib->count; i++)
|
||||
if (strcmp(lib->items[i].name, name) == 0) return &lib->items[i];
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* ---- N1/N2 ---- */
|
||||
static void test_open_access(const char *root)
|
||||
{
|
||||
mr_library lib;
|
||||
memset(&lib, 0, sizeof lib);
|
||||
int n = mr_library_scan(&lib, root, MR_LIB_MAX_DEPTH);
|
||||
CHECK(n == 7, "root lists 7 dirs (got %d)", n);
|
||||
CHECK(lib.truncated == 0, "root not truncated");
|
||||
|
||||
static const char *want[7] = {
|
||||
"book", "empty", "lost+found", "MeowAPPs", "MeowData", "MeowOS", "noimg"
|
||||
};
|
||||
for (int i = 0; i < 7 && i < lib.count; i++)
|
||||
CHECK(strcmp(lib.items[i].name, want[i]) == 0,
|
||||
"sort[%d]=%s got %s", i, want[i], lib.items[i].name);
|
||||
|
||||
for (int i = 0; i < 7; i++)
|
||||
CHECK(find_entry(&lib, want[i]) != NULL, "system/empty/noimg dir listed: %s", want[i]);
|
||||
CHECK(find_entry(&lib, ".hidden") == NULL, "hidden dir excluded");
|
||||
CHECK(find_entry(&lib, "linkdir") == NULL, "symlink dir excluded");
|
||||
CHECK(find_entry(&lib, "loose.png") == NULL, "file excluded");
|
||||
|
||||
/* 可进入：每个列出的目录都能被 scan（0 项也算成功，不等于 -1）。 */
|
||||
char p[MR_PATH_MAX];
|
||||
for (int i = 0; i < lib.count; i++) {
|
||||
mr_library child;
|
||||
memset(&child, 0, sizeof child);
|
||||
CHECK(mr_library_scan(&child, lib.items[i].path, MR_LIB_MAX_DEPTH) >= 0,
|
||||
"enter %s", lib.items[i].name);
|
||||
mr_library_free(&child);
|
||||
}
|
||||
|
||||
joinp(p, sizeof p, root, "MeowOS");
|
||||
mr_library syslib;
|
||||
memset(&syslib, 0, sizeof syslib);
|
||||
CHECK(mr_library_scan(&syslib, p, MR_LIB_MAX_DEPTH) == 1 &&
|
||||
find_entry(&syslib, "sub") != NULL, "system dir browsable");
|
||||
mr_library_free(&syslib);
|
||||
|
||||
joinp(p, sizeof p, root, "empty");
|
||||
mr_library empty;
|
||||
memset(&empty, 0, sizeof empty);
|
||||
CHECK(mr_library_scan(&empty, p, MR_LIB_MAX_DEPTH) == 0, "empty dir enterable (0 items)");
|
||||
mr_library_free(&empty);
|
||||
|
||||
mr_library_free(&lib);
|
||||
}
|
||||
|
||||
/* ---- N3 ---- */
|
||||
static void test_unreadable(const char *root)
|
||||
{
|
||||
mr_library lib;
|
||||
char p[MR_PATH_MAX];
|
||||
memset(&lib, 0, sizeof lib);
|
||||
CHECK(mr_library_scan(&lib, "/no/such/dir/m13", MR_LIB_MAX_DEPTH) == -1, "missing -> -1");
|
||||
CHECK(lib.count == 0 && lib.truncated == 0, "failed scan leaves empty lib");
|
||||
mr_library_free(&lib);
|
||||
|
||||
joinp(p, sizeof p, root, "loose.png");
|
||||
memset(&lib, 0, sizeof lib);
|
||||
CHECK(mr_library_scan(&lib, p, MR_LIB_MAX_DEPTH) == -1, "file (not dir) -> -1");
|
||||
mr_library_free(&lib);
|
||||
|
||||
if (geteuid() != 0) { /* root 下 EACCES 不生效，跳过权限用例 */
|
||||
joinp(p, sizeof p, root, "noread");
|
||||
CHECK(mkdir_p(p) == 0, "mkdir noread");
|
||||
CHECK(chmod(p, 0000) == 0, "chmod 000");
|
||||
memset(&lib, 0, sizeof lib);
|
||||
CHECK(mr_library_scan(&lib, p, MR_LIB_MAX_DEPTH) == -1, "unreadable -> -1");
|
||||
CHECK(lib.count == 0, "unreadable lib empty");
|
||||
mr_library_free(&lib);
|
||||
chmod(p, 0700);
|
||||
}
|
||||
}
|
||||
|
||||
/* ---- N4 ---- */
|
||||
static void test_up_to_root(void)
|
||||
{
|
||||
char cur[MR_PATH_MAX];
|
||||
snprintf(cur, sizeof cur, "/usr/data/mnt/sd_0/a/b/c");
|
||||
int steps = 0;
|
||||
while (strcmp(cur, "/") != 0 && steps < 32) {
|
||||
char up[MR_PATH_MAX];
|
||||
int r = mr_path_parent(cur, up, (int)sizeof up);
|
||||
CHECK(r == 0, "parent of %s", cur);
|
||||
if (r != 0) break;
|
||||
CHECK(strcmp(up, cur) != 0, "parent strictly shorter at %s", cur);
|
||||
memcpy(cur, up, sizeof cur);
|
||||
steps++;
|
||||
}
|
||||
CHECK(strcmp(cur, "/") == 0, "reached filesystem root ('%s')", cur);
|
||||
CHECK(steps == 7, "steps to / = %d (want 7)", steps);
|
||||
|
||||
char up[MR_PATH_MAX];
|
||||
CHECK(mr_path_parent("/", up, (int)sizeof up) == 0 && strcmp(up, "/") == 0,
|
||||
"root parent stays /");
|
||||
CHECK(mr_path_parent("/usr/data/mnt/sd_0", up, (int)sizeof up) == 0 &&
|
||||
strcmp(up, "/usr/data/mnt") == 0,
|
||||
"TF root can go above mount point: %s", up);
|
||||
}
|
||||
|
||||
/* ---- N5 ---- */
|
||||
static void test_truncation(void)
|
||||
{
|
||||
CHECK(MR_LIB_SCAN_MAX == 2000, "default cap is 2000 (got %d)", MR_LIB_SCAN_MAX);
|
||||
|
||||
char tmpl[] = "./mr_nav_XXXXXX";
|
||||
char *root = mkdtemp(tmpl);
|
||||
CHECK(root != NULL, "mkdtemp");
|
||||
if (!root) return;
|
||||
|
||||
int total = MR_LIB_SCAN_MAX + 8;
|
||||
char p[MR_PATH_MAX];
|
||||
for (int i = 0; i < total; i++) {
|
||||
snprintf(p, sizeof p, "%s/d%04d", root, i);
|
||||
if (mkdir(p, 0755) != 0) { CHECK(0, "mkdir %s", p); break; }
|
||||
}
|
||||
|
||||
mr_library lib;
|
||||
memset(&lib, 0, sizeof lib);
|
||||
int n = mr_library_scan(&lib, root, MR_LIB_MAX_DEPTH);
|
||||
CHECK(n == MR_LIB_SCAN_MAX, "cap applied: n=%d", n);
|
||||
CHECK(lib.truncated == 1, "truncated flag set");
|
||||
CHECK(lib.count == MR_LIB_SCAN_MAX, "count == cap");
|
||||
|
||||
mr_library_row row;
|
||||
CHECK(mr_library_row_at(&lib, lib.count, &row) == 1 && row.disabled == 1,
|
||||
"truncation row present");
|
||||
CHECK(strcmp(row.title, "已截断") == 0, "truncation row title=%s", row.title);
|
||||
|
||||
mr_library_free(&lib);
|
||||
rm_rf(root);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
char tmpl[] = "./mr_nav_XXXXXX";
|
||||
char *root = mkdtemp(tmpl);
|
||||
CHECK(root != NULL, "mkdtemp");
|
||||
if (!root) return 1;
|
||||
|
||||
char p[MR_PATH_MAX];
|
||||
const char *dirs[] = { "MeowAPPs", "MeowData", "MeowOS/sub", "lost+found",
|
||||
"book", "empty", "noimg", ".hidden" };
|
||||
for (unsigned i = 0; i < sizeof dirs / sizeof dirs[0]; i++) {
|
||||
joinp(p, sizeof p, root, dirs[i]);
|
||||
CHECK(mkdir_p(p) == 0, "mkdir %s", p);
|
||||
}
|
||||
joinp(p, sizeof p, root, "MeowOS/001.png");
|
||||
touch_file(p);
|
||||
joinp(p, sizeof p, root, "book/001.png");
|
||||
touch_file(p);
|
||||
joinp(p, sizeof p, root, "noimg/readme.txt");
|
||||
touch_file(p);
|
||||
joinp(p, sizeof p, root, "loose.png");
|
||||
touch_file(p);
|
||||
/* 符号链接目录不参与浏览（有权限才建；建不了不影响其余断言）。 */
|
||||
char target[MR_PATH_MAX], link[MR_PATH_MAX];
|
||||
joinp(target, sizeof target, root, "book");
|
||||
joinp(link, sizeof link, root, "linkdir");
|
||||
symlink(target, link);
|
||||
|
||||
test_open_access(root);
|
||||
test_unreadable(root);
|
||||
test_up_to_root();
|
||||
|
||||
rm_rf(root);
|
||||
test_truncation();
|
||||
|
||||
printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
|
||||
return g_fail ? 1 : 0;
|
||||
}
|
||||
@@ -0,0 +1,199 @@
|
||||
/* test_browse_perf.c — 单层扫描性能/有界性验收（纯 C，无 SDK）。
|
||||
*
|
||||
* 夹具：500 个顶层目录 × 8 层嵌套（4000 个子目录）+ 根目录 2000 个文件。
|
||||
* 断言（对应 M13 任务⑤）：
|
||||
* P1 首帧扫描只做单层：opendir 次数 == 1（旧实现会递归打开数千个目录）；
|
||||
* lstat 次数 == 本层条目数；耗时有界；
|
||||
* P2 后台探测同样只读一层：每个目录一次 opendir，不进入其嵌套子树；
|
||||
* P3 行合成（UI src/bind 的数据面）纯内存、零 IO、O(1)；
|
||||
* P4 深目录直接扫描也只打开它自己。
|
||||
*
|
||||
* 编译（在 tuku/ 下）：
|
||||
* gcc -Wall -Wextra -O1 -I. -I../sdk -DMR_LIBRARY_TEST_HOOKS \
|
||||
* test/test_browse_perf.c logic/library.c logic/reader.c test/settings_reader_stub.c \
|
||||
* -pthread -o build/host/test_browse_perf
|
||||
*/
|
||||
#include "logic/library.h"
|
||||
|
||||
#include <dirent.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#define PERF_DIRS 500
|
||||
#define PERF_DEPTH 8
|
||||
#define PERF_FILES 2000
|
||||
|
||||
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;
|
||||
fputs("x", f);
|
||||
return fclose(f);
|
||||
}
|
||||
|
||||
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 long long now_us(void)
|
||||
{
|
||||
struct timespec ts;
|
||||
clock_gettime(CLOCK_MONOTONIC, &ts);
|
||||
return (long long)ts.tv_sec * 1000000LL + ts.tv_nsec / 1000LL;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
char tmpl[] = "./mr_perf_XXXXXX";
|
||||
char *root = mkdtemp(tmpl);
|
||||
CHECK(root != NULL, "mkdtemp");
|
||||
if (!root) return 1;
|
||||
|
||||
char p[MR_PATH_MAX];
|
||||
/* 根目录：2000 个文件 + 500 个顶层目录（每个顶层目录内是 8 层嵌套 + 1 张图）。 */
|
||||
for (int f = 0; f < PERF_FILES; f++) {
|
||||
snprintf(p, sizeof p, "%s/f%04d.txt", root, f);
|
||||
if (touch_file(p) != 0) { CHECK(0, "file %s", p); break; }
|
||||
}
|
||||
for (int d = 0; d < PERF_DIRS; d++) {
|
||||
char deep[MR_PATH_MAX];
|
||||
snprintf(deep, sizeof deep, "%s/d%04d", root, d);
|
||||
if (mkdir_p(deep) != 0) { CHECK(0, "mkdir %s", deep); break; }
|
||||
snprintf(p, sizeof p, "%s/001.png", deep); /* 顶层目录自身直接含图（=一本书） */
|
||||
if (touch_file(p) != 0) { CHECK(0, "touched top image"); break; }
|
||||
for (int l = 1; l <= PERF_DEPTH; l++) {
|
||||
char sub[MR_PATH_MAX];
|
||||
snprintf(sub, sizeof sub, "%s/l%d", deep, l);
|
||||
if (mkdir(sub, 0755) != 0) { CHECK(0, "mkdir %s", sub); break; }
|
||||
snprintf(deep, sizeof deep, "%s", sub);
|
||||
}
|
||||
snprintf(p, sizeof p, "%s/001.png", deep);
|
||||
if (touch_file(p) != 0) { CHECK(0, "touched deep image"); break; }
|
||||
}
|
||||
|
||||
/* ---- P1：首帧扫描只做单层 ---- */
|
||||
mr_library lib;
|
||||
memset(&lib, 0, sizeof lib);
|
||||
mr_library_test_io_reset();
|
||||
long long t0 = now_us();
|
||||
int n = mr_library_scan(&lib, root, MR_LIB_MAX_DEPTH);
|
||||
long long scan_us = now_us() - t0;
|
||||
mr_library_io_stats st;
|
||||
mr_library_test_io_get(&st);
|
||||
|
||||
CHECK(n == PERF_DIRS, "scan lists %d dirs (got %d)", PERF_DIRS, n);
|
||||
CHECK(lib.truncated == 0, "not truncated");
|
||||
CHECK(st.opendirs == 1, "single-layer scan: opendir=%ld (want 1)", st.opendirs);
|
||||
CHECK(st.lstats == PERF_FILES + PERF_DIRS,
|
||||
"lstat only current level: %ld (want %d)", st.lstats, PERF_FILES + PERF_DIRS);
|
||||
CHECK(scan_us < 1500000LL, "scan bounded: %lldus", scan_us);
|
||||
if (lib.count > 1) {
|
||||
CHECK(strcmp(lib.items[0].name, "d0000") == 0, "first=%s", lib.items[0].name);
|
||||
CHECK(strcmp(lib.items[lib.count - 1].name, "d0499") == 0,
|
||||
"last=%s", lib.items[lib.count - 1].name);
|
||||
}
|
||||
printf(" scan: %lldus, %d dirs, opendir=%ld lstat=%ld\n",
|
||||
scan_us, n, st.opendirs, st.lstats);
|
||||
|
||||
/* ---- P2：后台探测每目录只开一次，不进入嵌套子树 ---- */
|
||||
mr_library_test_io_reset();
|
||||
long long p0 = now_us();
|
||||
int bad = 0;
|
||||
for (int i = 0; i < lib.count; i++) {
|
||||
mr_library_probe probe;
|
||||
if (mr_library_probe_cached(lib.items[i].path, &probe) != 0 || probe.pages != 1)
|
||||
bad++;
|
||||
}
|
||||
long long probe_us = now_us() - p0;
|
||||
mr_library_test_io_get(&st);
|
||||
CHECK(bad == 0, "all top dirs have 1 direct image (bad=%d)", bad);
|
||||
CHECK(st.opendirs == PERF_DIRS,
|
||||
"probe stays shallow: opendir=%ld (want %d, not %d)",
|
||||
st.opendirs, PERF_DIRS, PERF_DIRS * (PERF_DEPTH + 1));
|
||||
CHECK(st.lstats == PERF_DIRS,
|
||||
"probe lstats only image candidates: %ld (want %d)", st.lstats, PERF_DIRS);
|
||||
CHECK(probe_us < 5000000LL, "probe bounded: %lldus", probe_us);
|
||||
printf(" probe: %lldus, opendir=%ld lstat=%ld\n", probe_us, st.opendirs, st.lstats);
|
||||
|
||||
/* ---- P3：行合成（bind/src 数据面）纯内存 O(1) ---- */
|
||||
mr_library_test_io_reset();
|
||||
long long r0 = now_us();
|
||||
int rows = 0;
|
||||
for (int r = 0; r < 1000; r++)
|
||||
for (int i = 0; i < lib.count; i++) {
|
||||
mr_library_row row;
|
||||
if (mr_library_row_at(&lib, i, &row)) rows++;
|
||||
}
|
||||
long long row_us = now_us() - r0;
|
||||
mr_library_test_io_get(&st);
|
||||
CHECK(rows == 1000 * lib.count, "rows synthesized (%d)", rows);
|
||||
CHECK(st.opendirs == 0 && st.readdirs == 0 && st.lstats == 0,
|
||||
"row synthesis does no IO (open=%ld rd=%ld stat=%ld)",
|
||||
st.opendirs, st.readdirs, st.lstats);
|
||||
CHECK(row_us < 1000000LL, "row synthesis bounded: %lldus", row_us);
|
||||
printf(" rows: %lldus for %d rows, zero IO\n", row_us, rows);
|
||||
|
||||
/* ---- P4：直接扫描深层目录同样只打开它自己 ---- */
|
||||
char deep[MR_PATH_MAX];
|
||||
snprintf(deep, sizeof deep, "%s", lib.items[0].path);
|
||||
for (int l = 1; l <= PERF_DEPTH; l++) {
|
||||
char sub[MR_PATH_MAX];
|
||||
snprintf(sub, sizeof sub, "%s/l%d", deep, l);
|
||||
snprintf(deep, sizeof deep, "%s", sub);
|
||||
}
|
||||
mr_library_test_io_reset();
|
||||
mr_library deep_lib;
|
||||
memset(&deep_lib, 0, sizeof deep_lib);
|
||||
CHECK(mr_library_scan(&deep_lib, deep, MR_LIB_MAX_DEPTH) == 0, "deep leaf has no subdir");
|
||||
mr_library_test_io_get(&st);
|
||||
CHECK(st.opendirs == 1, "deep scan opens once (got %ld)", st.opendirs);
|
||||
CHECK(st.lstats == 1, "deep scan lstats only its image (got %ld)", st.lstats);
|
||||
mr_library_free(&deep_lib);
|
||||
|
||||
mr_library_free(&lib);
|
||||
rm_rf(root);
|
||||
printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
|
||||
return g_fail ? 1 : 0;
|
||||
}
|
||||
@@ -0,0 +1,366 @@
|
||||
/* test_browse_ui_host.c — 书库浏览页宿主集成测试（可选，需 SDK 源码树）。
|
||||
*
|
||||
* 目的（M13）：
|
||||
* U1 列表用 src2 模式（每帧重取行）：扫描后行副标题是占位「…」，后台探测完成、
|
||||
* on_tick 补位后同一行立即显示页数——验证懒算结果能上屏（固定池 vsource 做不到）；
|
||||
* U2 行语义：书行显示 "N pages"（无进入箭头），空目录「空目录」，无图目录「无图片」；
|
||||
* U3 导航：可逐级上溯父目录；文件系统 "/" 处 library_go_up 返回 0（app.c 据此退出）；
|
||||
* 「TF卡」回根动作回到书库根；
|
||||
* U4 不可读目录：load 失败 → 停留原目录 + 顶部提示横幅；
|
||||
* U5 启动根不可读：create 时仍建空列表（不是只有横幅）；
|
||||
* U6 缩略图 LRU 跳过解压页缓存（M11 P2-1 回归）：cache_prune 只统计/删除缩略图，
|
||||
* mrpage_*（page_cache 的解压页）必须保留且不计入 64 张额度。
|
||||
*
|
||||
* 编译：见 test/run_tests.sh（与 test_settings_lock_host 同口径：链 SDK 源码树 + 打桩；
|
||||
* 只发布 meow_ui.a 的交付环境自动 SKIP）。ui/library/library.c 以
|
||||
* -DMR_LIBRARY_UI_TEST_HOOKS 编译出测试接缝；本测试另打桩 mr_reader_open_dir/mr_nav_report。
|
||||
*/
|
||||
#include "tuku_internal.h"
|
||||
#include "logic/library.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#include <dirent.h>
|
||||
|
||||
/* ---- ui/library/library.c 的测试接缝（仅 -DMR_LIBRARY_UI_TEST_HOOKS 时定义） ---- */
|
||||
int library_test_load(const char *dir);
|
||||
void library_test_set_root(const char *root);
|
||||
const char *library_test_root(void);
|
||||
const char *library_test_dir(void);
|
||||
void library_test_set_dir(const char *dir);
|
||||
int library_test_rows(void);
|
||||
int library_test_src(int idx, meow_list_item *item);
|
||||
int library_test_hint_active(void);
|
||||
const char *library_test_hint(void);
|
||||
int library_test_go_root(void);
|
||||
int library_test_go_up(void);
|
||||
int library_test_has_list(void);
|
||||
const char *library_test_cache_dir(void);
|
||||
int library_test_cache_on(void);
|
||||
void library_test_cache_prune(void);
|
||||
|
||||
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) {}
|
||||
|
||||
/* reader 打桩：只记录被打开的册路径（本测试不建 reader 页）。 */
|
||||
static char g_opened[MR_PATH_MAX];
|
||||
static int g_opened_n;
|
||||
void mr_reader_open_dir(const char *path)
|
||||
{
|
||||
snprintf(g_opened, sizeof g_opened, "%s", path ? path : "");
|
||||
g_opened_n++;
|
||||
}
|
||||
|
||||
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;
|
||||
fputs("x", f);
|
||||
return fclose(f);
|
||||
}
|
||||
|
||||
static int rm_rf(const char *path)
|
||||
{
|
||||
struct stat st;
|
||||
if (lstat(path, &st) != 0) return -1;
|
||||
if (!S_ISDIR(st.st_mode)) { chmod(path, 0700); return unlink(path); }
|
||||
chmod(path, 0700);
|
||||
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 int row_index_for(const char *name)
|
||||
{
|
||||
int rows = library_test_rows();
|
||||
for (int i = 0; i < rows; i++) {
|
||||
meow_list_item it;
|
||||
if (!library_test_src(i, &it)) continue;
|
||||
if (it.title && strcmp(it.title, name) == 0) return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void set_mtime(const char *path, time_t t)
|
||||
{
|
||||
struct timespec ts[2];
|
||||
ts[0].tv_sec = t;
|
||||
ts[0].tv_nsec = 0;
|
||||
ts[1] = ts[0];
|
||||
utimensat(AT_FDCWD, path, ts, 0);
|
||||
}
|
||||
|
||||
/* 统计缓存目录里的缩略图（*.bmp 且非 mrpage_*）与解压页（mrpage_*.bmp）。 */
|
||||
static int count_bmp(const char *dir, int *pages)
|
||||
{
|
||||
DIR *d = opendir(dir);
|
||||
if (!d) return -1;
|
||||
int thumbs = 0, pg = 0;
|
||||
struct dirent *de;
|
||||
while ((de = readdir(d)) != NULL) {
|
||||
size_t len = strlen(de->d_name);
|
||||
if (len <= 4 || strcmp(de->d_name + len - 4, ".bmp") != 0) continue;
|
||||
if (strncmp(de->d_name, "mrpage_", 7) == 0) pg++;
|
||||
else thumbs++;
|
||||
}
|
||||
closedir(d);
|
||||
if (pages) *pages = pg;
|
||||
return thumbs;
|
||||
}
|
||||
|
||||
static void wait_ready(int ms)
|
||||
{
|
||||
for (int t = 0; t < ms / 10; t++) {
|
||||
library_on_tick();
|
||||
int ready = 1;
|
||||
int rows = library_test_rows();
|
||||
for (int i = 0; i < rows; i++) {
|
||||
meow_list_item it;
|
||||
if (!library_test_src(i, &it)) continue;
|
||||
if (it.subtitle && strcmp(it.subtitle, "…") == 0) { ready = 0; break; }
|
||||
}
|
||||
if (ready) return;
|
||||
usleep(10000);
|
||||
}
|
||||
}
|
||||
|
||||
/* U6：缩略图 LRU 必须跳过解压页缓存（M11 P2-1 回归；MR_CACHE_MAX_FILES=64）。 */
|
||||
static void test_cache_prune_skips_pages(void)
|
||||
{
|
||||
const char *dir = library_test_cache_dir();
|
||||
CHECK(library_test_cache_on() && dir && dir[0], "thumbnail cache enabled: %s",
|
||||
dir ? dir : "");
|
||||
if (!dir || !dir[0]) return;
|
||||
|
||||
/* 清空之前可能写入的 bmp（本测试独占 MEOW_DATA_DIR）。 */
|
||||
DIR *d = opendir(dir);
|
||||
if (d) {
|
||||
struct dirent *de;
|
||||
while ((de = readdir(d)) != NULL) {
|
||||
size_t len = strlen(de->d_name);
|
||||
if (len > 4 && strcmp(de->d_name + len - 4, ".bmp") == 0) {
|
||||
char full[MR_PATH_MAX + 96];
|
||||
snprintf(full, sizeof full, "%s/%s", dir, de->d_name);
|
||||
unlink(full);
|
||||
}
|
||||
}
|
||||
closedir(d);
|
||||
}
|
||||
|
||||
char page[MR_PATH_MAX + 96], thumb[MR_PATH_MAX + 96];
|
||||
snprintf(page, sizeof page, "%s/mrpage_0123456789abcdef.bmp", dir);
|
||||
CHECK(touch_file(page) == 0, "create page cache file");
|
||||
set_mtime(page, time(NULL) - 7200); /* 最旧：若被误删一定先删它 */
|
||||
|
||||
time_t base = time(NULL) - 3600;
|
||||
for (int i = 0; i < 65; i++) { /* 65 张缩略图 > MR_CACHE_MAX_FILES */
|
||||
snprintf(thumb, sizeof thumb, "%s/%016x_%ld_%d.bmp", dir,
|
||||
(unsigned)i, (long)(base + i), i);
|
||||
CHECK(touch_file(thumb) == 0, "create thumbnail %d", i);
|
||||
set_mtime(thumb, base + i);
|
||||
}
|
||||
|
||||
int pages_before = 0;
|
||||
CHECK(count_bmp(dir, &pages_before) == 65, "precondition 65 thumbnails");
|
||||
CHECK(pages_before == 1, "precondition 1 page (got %d)", pages_before);
|
||||
|
||||
library_test_cache_prune();
|
||||
|
||||
int pages_after = 0;
|
||||
int thumbs_after = count_bmp(dir, &pages_after);
|
||||
CHECK(access(page, R_OK) == 0, "mrpage_* survives thumbnail LRU");
|
||||
CHECK(pages_after == 1, "mrpage_* not counted as thumbnail (got %d)", pages_after);
|
||||
CHECK(thumbs_after == 64, "thumbnails trimmed to 64 (got %d)", thumbs_after);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
const char *base = getenv("TMPDIR");
|
||||
if (!base || !base[0]) base = ".";
|
||||
char tmpl[512];
|
||||
snprintf(tmpl, sizeof tmpl, "%s/mr_browse_ui_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];
|
||||
snprintf(root, sizeof root, "%s/library", data);
|
||||
char p[MR_PATH_MAX];
|
||||
const char *dirs[] = { "book", "empty", "noimg", "deep/sub", "MeowOS/sub" };
|
||||
for (unsigned i = 0; i < sizeof dirs / sizeof dirs[0]; i++) {
|
||||
joinp(p, sizeof p, root, dirs[i]);
|
||||
if (mkdir_p(p) != 0) { printf("SKIP: mkdir %s failed\n", p); return 0; }
|
||||
}
|
||||
joinp(p, sizeof p, root, "book/page2.png"); touch_file(p);
|
||||
joinp(p, sizeof p, root, "book/page10.jpg"); touch_file(p);
|
||||
joinp(p, sizeof p, root, "noimg/readme.txt"); touch_file(p);
|
||||
joinp(p, sizeof p, root, "deep/sub/001.png"); touch_file(p);
|
||||
joinp(p, sizeof p, root, "MeowOS/sub/m.png"); touch_file(p);
|
||||
|
||||
meow_ui_opts o = { 480, 720 };
|
||||
if (meow_ui_init(&o) != 0) { printf("SKIP: meow_ui_init failed (no host backend)\n"); return 0; }
|
||||
|
||||
/* U5：先指向一个不存在的根，再 create —— 真实走「启动时根目录不可读」分支。 */
|
||||
const char *bad_root = "/no/such/tuku/m13_root";
|
||||
library_test_set_root(bad_root);
|
||||
CHECK(strcmp(library_test_root(), bad_root) == 0, "bad root installed");
|
||||
meow_view *lib = library_view_create();
|
||||
CHECK(library_test_hint_active(), "startup unreadable root shows hint: %s",
|
||||
library_test_hint());
|
||||
CHECK(library_test_rows() == 0, "startup empty list rows=%d", library_test_rows());
|
||||
CHECK(library_test_has_list(), "startup built listview for empty list");
|
||||
CHECK(strcmp(library_test_dir(), bad_root) == 0, "startup dir=%s", library_test_dir());
|
||||
|
||||
library_test_set_root(root);
|
||||
CHECK(strcmp(library_test_root(), root) == 0, "test root installed");
|
||||
meow_view_page_push(ACT_LIBRARY);
|
||||
CHECK(meow_ui_activity_active() == ACT_LIBRARY, "library active");
|
||||
|
||||
/* ---- U1：src2 行 + 懒算补位 ---- */
|
||||
CHECK(library_test_load(root) == 1, "load fixture");
|
||||
CHECK(library_test_rows() == 5, "5 rows (got %d)", library_test_rows());
|
||||
|
||||
static const char *want[5] = { "book", "deep", "empty", "MeowOS", "noimg" };
|
||||
for (int i = 0; i < 5; i++) {
|
||||
meow_list_item it;
|
||||
CHECK(library_test_src(i, &it) == 1, "src row %d", i);
|
||||
CHECK(it.title && strcmp(it.title, want[i]) == 0, "row[%d]=%s (want %s)",
|
||||
i, it.title ? it.title : "(null)", want[i]);
|
||||
CHECK(it.subtitle && strcmp(it.subtitle, "…") == 0,
|
||||
"row[%d] starts with placeholder (got %s)", i, it.subtitle ? it.subtitle : "");
|
||||
CHECK(it.right == MEOW_LIST_RIGHT_ARROW, "row[%d] has enter arrow while pending", i);
|
||||
}
|
||||
|
||||
wait_ready(3000);
|
||||
/* U2：补位后的行语义 */
|
||||
for (int i = 0; i < 5; i++) {
|
||||
meow_list_item it;
|
||||
library_test_src(i, &it);
|
||||
CHECK(it.subtitle && strcmp(it.subtitle, "…") != 0,
|
||||
"row[%d] subtitle filled (got %s)", i, it.subtitle ? it.subtitle : "");
|
||||
}
|
||||
int ib = row_index_for("book");
|
||||
int ie = row_index_for("empty");
|
||||
int in = row_index_for("noimg");
|
||||
int id = row_index_for("deep");
|
||||
meow_list_item it;
|
||||
CHECK(ib >= 0 && library_test_src(ib, &it) && strcmp(it.subtitle, "2 pages") == 0,
|
||||
"book subtitle=%s", it.subtitle ? it.subtitle : "");
|
||||
CHECK(it.right == MEOW_LIST_RIGHT_NONE, "book row has no enter arrow (opens reader)");
|
||||
CHECK(ie >= 0 && library_test_src(ie, &it) && strcmp(it.subtitle, "空目录") == 0,
|
||||
"empty subtitle=%s", it.subtitle ? it.subtitle : "");
|
||||
CHECK(in >= 0 && library_test_src(in, &it) && strcmp(it.subtitle, "无图片") == 0,
|
||||
"noimg subtitle=%s", it.subtitle ? it.subtitle : "");
|
||||
CHECK(id >= 0 && library_test_src(id, &it) && strcmp(it.subtitle, "无图片") == 0,
|
||||
"deep (images only in subdir) is not a book: %s", it.subtitle ? it.subtitle : "");
|
||||
|
||||
/* ---- 行点击：书 → reader；空目录 → 进入 ---- */
|
||||
int list_top = meow_ui_statusbar_height() + 56;
|
||||
g_opened_n = 0;
|
||||
library_on_tap(120, list_top + ib * 56 + 28);
|
||||
CHECK(g_opened_n == 1 && strstr(g_opened, "/book") != NULL,
|
||||
"tap book opens reader (%s)", g_opened);
|
||||
CHECK(strcmp(library_test_dir(), root) == 0, "tap book does not navigate");
|
||||
|
||||
library_on_tap(120, list_top + ie * 56 + 28);
|
||||
char empty_path[MR_PATH_MAX];
|
||||
joinp(empty_path, sizeof empty_path, root, "empty");
|
||||
CHECK(strcmp(library_test_dir(), empty_path) == 0,
|
||||
"tap empty dir enters it (%s)", library_test_dir());
|
||||
CHECK(library_test_rows() == 0, "empty dir shows empty list");
|
||||
|
||||
/* ---- U3：导航（逐级上溯 / 到 / 退出 / 回 TF 根） ---- */
|
||||
CHECK(library_test_go_up() == 1, "go_up from empty consumed");
|
||||
CHECK(strcmp(library_test_dir(), root) == 0, "go_up to fixture root");
|
||||
|
||||
char deep[MR_PATH_MAX];
|
||||
joinp(deep, sizeof deep, root, "deep/sub");
|
||||
CHECK(library_test_load(deep) == 1, "load deep/sub");
|
||||
CHECK(library_test_go_up() == 1, "go_up from deep/sub");
|
||||
joinp(p, sizeof p, root, "deep");
|
||||
CHECK(strcmp(library_test_dir(), p) == 0, "now at deep");
|
||||
|
||||
/* 「TF卡」回根 */
|
||||
CHECK(library_test_load(deep) == 1, "reload deep/sub");
|
||||
CHECK(library_test_go_root() == 1 && strcmp(library_test_dir(), root) == 0,
|
||||
"TF卡 action returns to library root");
|
||||
|
||||
/* 上溯到文件系统 /：go_up 在 / 返回 0（app.c 据此退出）。
|
||||
* 宿主（Termux）读不了 "/"：从 /usr 返回时 load("/") 失败，仍应切到 "/" 的空列表
|
||||
* （否则会卡在 /usr 无法退出），下一次返回=退出 App。 */
|
||||
library_test_set_dir("/usr");
|
||||
CHECK(library_test_go_up() == 1, "go_up toward / consumed");
|
||||
CHECK(strcmp(library_test_dir(), "/") == 0, "reached / (unreadable root fallback)");
|
||||
CHECK(library_test_go_up() == 0, "go_up at / returns 0 (app exits)");
|
||||
CHECK(strcmp(library_test_dir(), "/") == 0, "still at / after exit gesture");
|
||||
|
||||
/* ---- U4：不可读目录 → 停留 + 提示 ---- */
|
||||
CHECK(library_test_load(root) == 1, "back to fixture root");
|
||||
char noread[MR_PATH_MAX];
|
||||
joinp(noread, sizeof noread, root, "noread");
|
||||
if (geteuid() != 0) {
|
||||
CHECK(mkdir(noread, 0755) == 0, "mkdir noread");
|
||||
chmod(noread, 0000);
|
||||
int ok = library_test_load(noread);
|
||||
CHECK(ok == 0, "unreadable dir load fails");
|
||||
CHECK(strcmp(library_test_dir(), root) == 0, "stays in previous dir (%s)",
|
||||
library_test_dir());
|
||||
CHECK(library_test_hint_active(), "hint banner shown: %s", library_test_hint());
|
||||
CHECK(strstr(library_test_hint(), "无法读取") != NULL,
|
||||
"hint text mentions unreadable: %s", library_test_hint());
|
||||
chmod(noread, 0700);
|
||||
} else {
|
||||
printf(" SKIP unreadable-dir case (running as root)\n");
|
||||
}
|
||||
|
||||
test_cache_prune_skips_pages();
|
||||
|
||||
meow_view_free(lib);
|
||||
meow_ui_shutdown();
|
||||
rm_rf(data);
|
||||
printf("%s: %s\n", g_fail ? "FAIL" : "PASS",
|
||||
g_fail ? "see failures above" : "browse UI checks passed");
|
||||
return g_fail ? 1 : 0;
|
||||
}
|
||||
+70
-26
@@ -15,12 +15,13 @@
|
||||
* T6 坏档容错：非 zip/截断/无图片页/声明 96MiB 的 zip 炸弹 → 打开失败或 0 页，不崩。
|
||||
* T7 统一开册契约：目录册与档案册走同一个 mr_book（count/meta/open/close/destroy），
|
||||
* 越界 open 返回 NULL，close_auto 幂等。
|
||||
* T8 书库列档：.cbz 与文件夹册同列自然序（bookA < box < vol2.cbz < Vol10.cbz），
|
||||
* 行=文件名+页数；坏档/无图档案不列；只含档案册的目录写 "N books"；
|
||||
* 不注入探测回调时行为与 M7 完全一致（纯目录书库）。
|
||||
* T8 书库列档（M13 单层 + 懒判定）：.cbz 与文件夹册同列自然序（bookA < box < ... <
|
||||
* Vol10.cbz）；扫描期只成行、副标题占位，探测补位后才有页数/书标记；
|
||||
* 坏档/无图片页档案仍列出但为非书（访问放开，不再隐藏）；
|
||||
* 不注入探测回调时档案文件不成行（M7 语义），目录仍按单层列出。
|
||||
* T9 册间衔接：同父目录自然序混排（bookA → vol2.cbz → Vol10.cbz），
|
||||
* 首/末册返回 0；不注入探测回调时档案册不参与（M7 语义）。
|
||||
* T10 续读角标：档案路径作为册标识，副标题后缀「· 续读 Pn」。
|
||||
* T10 续读角标（M13 两段式）：档案路径作为册标识，probe 补位后副标题后缀「· 续读 Pn」。
|
||||
*
|
||||
* 编译（在 tuku/ 下）：
|
||||
* gcc -Wall -Wextra -Werror -O1 -I. test/test_cbz.c logic/library.c logic/reader.c \
|
||||
@@ -715,19 +716,49 @@ static const mr_library_entry *lib_find(const mr_library *lib, const char *name)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* M13：模拟 UI 后台探测补位（目录单层探测 / 档案册注入页数回调）。 */
|
||||
static void lib_probe_all(mr_library *lib)
|
||||
{
|
||||
for (int i = 0; i < lib->count; i++) {
|
||||
mr_library_probe p;
|
||||
if (mr_library_probe_path(lib->items[i].path, lib->items[i].is_archive,
|
||||
archive_pages_probe, NULL, &p) == 0)
|
||||
mr_library_apply_probe(lib, i, &p);
|
||||
else
|
||||
mr_library_mark_error(lib, i);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_library(void)
|
||||
{
|
||||
mr_test_cfg_clear();
|
||||
|
||||
/* M13：扫描只做单层枚举——目录（全部列出，含无图的 box）与档案文件（.cbz/.zip）
|
||||
* 都先成行、副标题占位；书/非书与页数由后台 probe 补位。 */
|
||||
mr_library lib;
|
||||
memset(&lib, 0, sizeof lib);
|
||||
int n = mr_library_scan_ex(&lib, g_lib, MR_LIB_MAX_DEPTH, archive_pages_probe, NULL);
|
||||
CHECK(n == 4, "library rows=%d (want bookA, box, vol2.cbz, Vol10.cbz)", n);
|
||||
if (n == 4) {
|
||||
CHECK(strcmp(lib.items[0].name, "bookA") == 0, "row0=%s", lib.items[0].name);
|
||||
CHECK(strcmp(lib.items[1].name, "box") == 0, "row1=%s", lib.items[1].name);
|
||||
CHECK(strcmp(lib.items[2].name, "vol2.cbz") == 0, "row2=%s", lib.items[2].name);
|
||||
CHECK(strcmp(lib.items[3].name, "Vol10.cbz") == 0, "row3=%s", lib.items[3].name);
|
||||
CHECK(n == 8, "library rows=%d (want 2 dirs + 6 archives)", n);
|
||||
static const char *want[8] = {
|
||||
"bookA", "box", "broken.cbz", "emptypages.cbz",
|
||||
"notabook.zip", "truncated.cbz", "vol2.cbz", "Vol10.cbz"
|
||||
};
|
||||
for (int i = 0; i < 8 && i < lib.count; i++) {
|
||||
CHECK(strcmp(lib.items[i].name, want[i]) == 0,
|
||||
"row[%d]=%s (want %s)", i, lib.items[i].name, want[i]);
|
||||
CHECK(lib.items[i].probe_state == MR_LIB_PENDING && lib.items[i].pages == -1,
|
||||
"%s pending after scan", lib.items[i].name);
|
||||
CHECK(strcmp(lib.items[i].subtitle, "…") == 0,
|
||||
"%s placeholder subtitle=%s", lib.items[i].name, lib.items[i].subtitle);
|
||||
}
|
||||
|
||||
/* 后台补位（等价 UI 的 on_tick）：目录走单层目录探测，档案走注入的 zip 页数回调。 */
|
||||
for (int i = 0; i < lib.count; i++) {
|
||||
mr_library_probe p;
|
||||
int ok = (mr_library_probe_path(lib.items[i].path, lib.items[i].is_archive,
|
||||
archive_pages_probe, NULL, &p) == 0);
|
||||
CHECK(ok, "%s probed", lib.items[i].name);
|
||||
if (ok) mr_library_apply_probe(&lib, i, &p);
|
||||
}
|
||||
|
||||
const mr_library_entry *e = lib_find(&lib, "bookA");
|
||||
@@ -737,15 +768,17 @@ static void test_library(void)
|
||||
CHECK(e && strstr(e->cover, "001.png") != NULL, "bookA cover=%s",
|
||||
e ? e->cover : "");
|
||||
|
||||
/* box 只含档案册：目录本身不直接含图 → 不是书（M13 不做递归/子表统计）。 */
|
||||
e = lib_find(&lib, "box");
|
||||
CHECK(e && e->has_images == 0 && e->subdirs == 0, "box fields");
|
||||
CHECK(e && strcmp(e->subtitle, "2 books") == 0, "box subtitle=%s",
|
||||
CHECK(e && e->has_images == 0 && e->subdirs == 0 && e->is_archive == 0,
|
||||
"box fields");
|
||||
CHECK(e && strcmp(e->subtitle, "无图片") == 0, "box subtitle=%s",
|
||||
e ? e->subtitle : "");
|
||||
CHECK(e && e->cover[0] == '\0', "box cover should be empty");
|
||||
|
||||
e = lib_find(&lib, "vol2.cbz");
|
||||
CHECK(e && e->pages == 3 && e->has_images == 1 && e->subdirs == 0,
|
||||
"vol2.cbz fields");
|
||||
CHECK(e && e->pages == 3 && e->has_images == 1 && e->subdirs == 0 &&
|
||||
e->is_archive == 1, "vol2.cbz fields");
|
||||
CHECK(e && strcmp(e->subtitle, "3 pages") == 0, "vol2.cbz subtitle=%s",
|
||||
e ? e->subtitle : "");
|
||||
CHECK(e && e->cover[0] == '\0', "archive cover should be empty (UI extracts)");
|
||||
@@ -756,19 +789,24 @@ static void test_library(void)
|
||||
CHECK(e && e->pages == 1 && strcmp(e->subtitle, "1 page") == 0,
|
||||
"Vol10.cbz pages/subtitle");
|
||||
|
||||
CHECK(lib_find(&lib, "notabook.zip") == NULL, "text-only zip listed");
|
||||
CHECK(lib_find(&lib, "emptypages.cbz") == NULL, "no-image cbz listed");
|
||||
CHECK(lib_find(&lib, "broken.cbz") == NULL, "broken cbz listed");
|
||||
CHECK(lib_find(&lib, "truncated.cbz") == NULL, "truncated cbz listed");
|
||||
CHECK(lib_find(&lib, ".hidden.cbz") == NULL, "hidden cbz listed");
|
||||
/* 坏档/无图片页档案：列出但探测为非书（M13 访问放开，不再隐藏）。 */
|
||||
static const char *not_book[] = { "notabook.zip", "emptypages.cbz",
|
||||
"broken.cbz", "truncated.cbz" };
|
||||
for (unsigned i = 0; i < sizeof not_book / sizeof not_book[0]; i++) {
|
||||
e = lib_find(&lib, not_book[i]);
|
||||
CHECK(e && e->is_archive == 1 && e->has_images == 0 && e->pages == 0 &&
|
||||
strcmp(e->subtitle, "无图片") == 0,
|
||||
"%s: not a book (subtitle=%s)", not_book[i], e ? e->subtitle : "(missing)");
|
||||
}
|
||||
CHECK(lib_find(&lib, ".hidden.cbz") == NULL, "hidden cbz not listed");
|
||||
mr_library_free(&lib);
|
||||
|
||||
/* 不注入探测回调：与 M7 完全一致（档案册不参与，只含档案册的目录也不 nav）。 */
|
||||
/* 不注入探测回调：M7 纯目录书库（档案文件不成行，目录仍按 M13 单层列出）。 */
|
||||
memset(&lib, 0, sizeof lib);
|
||||
CHECK(mr_library_scan(&lib, g_lib, MR_LIB_MAX_DEPTH) == 1,
|
||||
"legacy scan rows=%d (want 1: bookA)", lib.count);
|
||||
CHECK(lib.count >= 1 && strcmp(lib.items[0].name, "bookA") == 0,
|
||||
"legacy scan row0");
|
||||
CHECK(mr_library_scan(&lib, g_lib, MR_LIB_MAX_DEPTH) == 2,
|
||||
"legacy scan rows=%d (want 2: bookA, box)", lib.count);
|
||||
CHECK(lib.count >= 2 && strcmp(lib.items[0].name, "bookA") == 0 &&
|
||||
strcmp(lib.items[1].name, "box") == 0, "legacy scan rows");
|
||||
mr_library_free(&lib);
|
||||
}
|
||||
|
||||
@@ -835,11 +873,16 @@ static void test_badge_cover(void)
|
||||
mr_test_cfg_clear();
|
||||
mr_cont_save(vol2, 2, MR_MODE_WEBTOON);
|
||||
|
||||
/* M13 两段式：扫描期只有占位副标题；后台 probe 补位后才出现页数与续读角标。 */
|
||||
mr_library lib;
|
||||
memset(&lib, 0, sizeof lib);
|
||||
CHECK(mr_library_scan_ex(&lib, g_lib, MR_LIB_MAX_DEPTH, archive_pages_probe,
|
||||
NULL) == 4, "rescan for badge");
|
||||
NULL) == 8, "rescan for badge (single-layer rows)");
|
||||
const mr_library_entry *e = lib_find(&lib, "vol2.cbz");
|
||||
CHECK(e && strcmp(e->subtitle, "…") == 0, "vol2 placeholder before probe: %s",
|
||||
e ? e->subtitle : "");
|
||||
lib_probe_all(&lib);
|
||||
e = lib_find(&lib, "vol2.cbz");
|
||||
CHECK(e && strstr(e->subtitle, "续读 P3") != NULL, "badge subtitle=%s",
|
||||
e ? e->subtitle : "");
|
||||
CHECK(e && strstr(e->subtitle, "3 pages") != NULL, "badge keeps page text: %s",
|
||||
@@ -848,10 +891,11 @@ static void test_badge_cover(void)
|
||||
CHECK(e && strstr(e->subtitle, "续读") == NULL, "Vol10 should have no badge");
|
||||
mr_library_free(&lib);
|
||||
|
||||
/* 清除记录后角标消失 */
|
||||
/* 清除记录后角标消失（重扫 + 再探测；探测缓存只存页数，角标按当前配置重算）。 */
|
||||
mr_cont_save(vol2, 0, MR_MODE_WEBTOON);
|
||||
memset(&lib, 0, sizeof lib);
|
||||
mr_library_scan_ex(&lib, g_lib, MR_LIB_MAX_DEPTH, archive_pages_probe, NULL);
|
||||
lib_probe_all(&lib);
|
||||
e = lib_find(&lib, "vol2.cbz");
|
||||
CHECK(e && strstr(e->subtitle, "续读") == NULL, "cleared badge gone");
|
||||
mr_library_free(&lib);
|
||||
|
||||
@@ -6,11 +6,12 @@
|
||||
* A3 边界：末页前进→下一册、首页后退→上一册（调用方语义）；路径末尾斜杠等价；
|
||||
* A4 排除：隐藏/系统目录、符号链接、普通文件不参与兄弟册；
|
||||
* A5 参数：delta 非 ±1、NULL/小缓冲、不存在的目录；
|
||||
* A6 书库扫描接线：有续读记录的册，行副标题出现「· 续读 Pn」角标。
|
||||
* A6 书库扫描接线（M13 两段式）：scan 只列单层、副标题占位「…」；
|
||||
* probe/on_tick 补位后出现页数与「· 续读 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/settings_reader_stub.c -pthread -o test/test_cont_adjacent
|
||||
* 或 test/run_webtoon_tests.sh。
|
||||
*/
|
||||
#include "logic/library.h"
|
||||
@@ -158,6 +159,20 @@ static void test_adjacent(const char *root)
|
||||
CHECK(mr_book_adjacent("/", 1, out, (int)sizeof out) == -1, "root path invalid");
|
||||
}
|
||||
|
||||
/* 模拟 UI 后台探测：逐行单层 probe 并补位（page>0 的书行由 format_subtitle 拼续读角标）。 */
|
||||
static void probe_all_rows(mr_library *lib)
|
||||
{
|
||||
for (int i = 0; i < lib->count; i++) {
|
||||
mr_library_probe p;
|
||||
if (mr_library_probe_cached(lib->items[i].path, &p) == 0)
|
||||
mr_library_apply_probe(lib, i, &p);
|
||||
else
|
||||
mr_library_mark_error(lib, i);
|
||||
}
|
||||
}
|
||||
|
||||
/* A6 两段式（M13）：scan 只做单层枚举、行副标题是占位「…」；后台 probe/on_tick 补位后
|
||||
* 才有页数与「· 续读 Pn」角标。 */
|
||||
static void test_library_badge(const char *root)
|
||||
{
|
||||
mr_test_cfg_clear();
|
||||
@@ -173,28 +188,52 @@ static void test_library_badge(const char *root)
|
||||
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);
|
||||
CHECK(e->probe_state == MR_LIB_PENDING && e->pages == -1,
|
||||
"vol1 pending after scan");
|
||||
CHECK(strcmp(e->subtitle, "…") == 0, "vol1 placeholder subtitle=%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(e->probe_state == MR_LIB_PENDING && strcmp(e->subtitle, "…") == 0,
|
||||
"vol2 placeholder subtitle=%s", e->subtitle);
|
||||
}
|
||||
}
|
||||
CHECK(seen1 == 1, "vol1 listed");
|
||||
CHECK(seen2 == 1, "vol2 listed");
|
||||
|
||||
/* 第二段：后台探测补位后，页数与续读角标出现。 */
|
||||
probe_all_rows(&lib);
|
||||
seen1 = 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(e->has_images == 1 && e->pages == 1, "vol1 probed pages=%d", e->pages);
|
||||
CHECK(strstr(e->subtitle, "page") != NULL, "vol1 keeps pages text: %s", e->subtitle);
|
||||
CHECK(strstr(e->subtitle, "续读 P5") != NULL, "vol1 subtitle=%s", e->subtitle);
|
||||
}
|
||||
if (strcmp(e->name, "vol2") == 0) {
|
||||
seen2 = 1;
|
||||
CHECK(e->has_images == 1 && e->pages == 1, "vol2 probed pages=%d", e->pages);
|
||||
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 after probe");
|
||||
CHECK(seen2 == 1, "vol2 listed after probe");
|
||||
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");
|
||||
probe_all_rows(&lib);
|
||||
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");
|
||||
|
||||
+32
-31
@@ -3,12 +3,14 @@
|
||||
* 覆盖：
|
||||
* T1 自然排序：数字段数值序（page2<page10）、前导零、数字/字母混合、大小写；
|
||||
* T2 扩展名过滤：png/jpg/jpeg/bmp 大小写不敏感，gif/txt 不支持；
|
||||
* T3 目录扫描：只列出含图目录与可导航中间目录；隐藏/系统目录、空目录、无图目录排除；
|
||||
* pages/subdirs/cover/subtitle 正确；父目录路径推导。
|
||||
* T3 目录扫描（M13 单层语义）：只列当前层直接子目录（自然升序），不递归探测子树；
|
||||
* 系统目录/空目录/无图目录都列出；隐藏项/普通文件/符号链接不列；
|
||||
* max_depth 兼容参数被忽略；行初始为「待探测」占位；父目录路径推导；
|
||||
* T4 阅读方向状态（logic/reader.c）。
|
||||
*
|
||||
* 编译（在 tuku/ 下）：
|
||||
* gcc -Wall -Wextra -O1 -I. test/test_library.c logic/library.c logic/reader.c \
|
||||
* -o test/test_library && ./test/test_library
|
||||
* gcc -Wall -Wextra -O1 -I. -I../sdk test/test_library.c logic/library.c logic/reader.c \
|
||||
* test/settings_reader_stub.c -pthread -o build/host/test_library
|
||||
* 或直接 test/run_tests.sh。
|
||||
*/
|
||||
#include "logic/library.h"
|
||||
@@ -148,44 +150,43 @@ static void test_scan(void)
|
||||
snprintf(p, sizeof p, "%s/MeowAPPs", root); mkdir_p(p);
|
||||
snprintf(p, sizeof p, "%s/MeowAPPs/m.png", root); touch_file(p);
|
||||
|
||||
snprintf(p, sizeof p, "%s/root.png", root); touch_file(p); /* 根目录直接图片不成为行 */
|
||||
snprintf(p, sizeof p, "%s/root.png", root); touch_file(p); /* 普通文件不成为行 */
|
||||
|
||||
mr_library lib;
|
||||
memset(&lib, 0, sizeof lib);
|
||||
int n = mr_library_scan(&lib, root, MR_LIB_MAX_DEPTH);
|
||||
CHECK(n == 4, "scan count=%d (want 4)", n);
|
||||
CHECK(n == 7, "scan count=%d (want 7: all direct subdirs)", n);
|
||||
CHECK(lib.count == n, "count matches");
|
||||
if (lib.count == 4) {
|
||||
CHECK(strcmp(lib.items[0].name, "Nested") == 0, "sort[0]=Nested got %s", lib.items[0].name);
|
||||
CHECK(strcmp(lib.items[1].name, "Series 2") == 0, "sort[1]=Series 2 got %s", lib.items[1].name);
|
||||
CHECK(strcmp(lib.items[2].name, "Series 02") == 0, "sort[2]=Series 02 got %s", lib.items[2].name);
|
||||
CHECK(strcmp(lib.items[3].name, "Series 10") == 0, "sort[3]=Series 10 got %s", lib.items[3].name);
|
||||
CHECK(lib.truncated == 0, "not truncated");
|
||||
if (lib.count == 7) {
|
||||
static const char *want[7] = {
|
||||
"Empty", "MeowAPPs", "Nested", "Series 2", "Series 02", "Series 3", "Series 10"
|
||||
};
|
||||
for (int i = 0; i < 7; i++)
|
||||
CHECK(strcmp(lib.items[i].name, want[i]) == 0,
|
||||
"sort[%d]=%s got %s", i, want[i], lib.items[i].name);
|
||||
}
|
||||
|
||||
const mr_library_entry *e = find_entry(&lib, "Series 10");
|
||||
CHECK(e && e->pages == 2 && e->has_images == 1 && e->subdirs == 0, "Series 10 pages=2");
|
||||
CHECK(e && strcmp(e->subtitle, "2 pages") == 0, "Series 10 subtitle '%s'", e ? e->subtitle : "");
|
||||
CHECK(e && strstr(e->cover, "page1.png") != NULL, "Series 10 cover natural-first '%s'",
|
||||
e ? e->cover : "");
|
||||
|
||||
e = find_entry(&lib, "Series 2");
|
||||
CHECK(e && e->pages == 1 && e->has_images == 1, "Series 2 pages=1");
|
||||
|
||||
e = find_entry(&lib, "Nested");
|
||||
CHECK(e && e->pages == 0 && e->has_images == 0 && e->subdirs == 1, "Nested intermediate");
|
||||
CHECK(e && strcmp(e->subtitle, "1 folder") == 0, "Nested subtitle '%s'", e ? e->subtitle : "");
|
||||
CHECK(e && strstr(e->cover, "Deeper/a.png") != NULL, "Nested cover from descendant '%s'",
|
||||
e ? e->cover : "");
|
||||
|
||||
CHECK(find_entry(&lib, "Empty") == NULL, "empty dir excluded");
|
||||
CHECK(find_entry(&lib, "Series 3") == NULL, "gif-only dir excluded");
|
||||
/* 访问放开：系统目录/空目录/无图目录都列出；隐藏项/文件不列。 */
|
||||
CHECK(find_entry(&lib, "MeowAPPs") != NULL, "system dir listed");
|
||||
CHECK(find_entry(&lib, "Empty") != NULL, "empty dir listed");
|
||||
CHECK(find_entry(&lib, "Series 3") != NULL, "no-image dir listed");
|
||||
CHECK(find_entry(&lib, "Nested") != NULL, "intermediate dir listed");
|
||||
CHECK(find_entry(&lib, ".hidden") == NULL, "hidden dir excluded");
|
||||
CHECK(find_entry(&lib, "MeowAPPs") == NULL, "system dir excluded");
|
||||
CHECK(find_entry(&lib, "root.png") == NULL, "loose image file excluded");
|
||||
|
||||
/* 深度 1：Nested 不再可探测到 Deeper 的图，应被排除。 */
|
||||
/* 首帧不做懒判定：所有行待探测（副标题占位）。 */
|
||||
for (int i = 0; i < lib.count; i++) {
|
||||
CHECK(lib.items[i].pages == -1, "%s pages pending", lib.items[i].name);
|
||||
CHECK(lib.items[i].has_images == -1, "%s book state pending", lib.items[i].name);
|
||||
CHECK(lib.items[i].probe_state == MR_LIB_PENDING, "%s probe pending", lib.items[i].name);
|
||||
CHECK(strcmp(lib.items[i].subtitle, "…") == 0, "%s subtitle placeholder", lib.items[i].name);
|
||||
}
|
||||
|
||||
/* max_depth 参数只为兼容旧调用保留：不再递归，结果一致。 */
|
||||
mr_library lib1;
|
||||
memset(&lib1, 0, sizeof lib1);
|
||||
CHECK(mr_library_scan(&lib1, root, 1) == 3, "max_depth=1 excludes Nested");
|
||||
CHECK(mr_library_scan(&lib1, root, 1) == 7, "max_depth ignored (single layer)");
|
||||
mr_library_free(&lib1);
|
||||
|
||||
mr_library_free(&lib);
|
||||
|
||||
@@ -37,8 +37,8 @@ typedef struct mr_page_ctrl {
|
||||
|
||||
/* ---- 书库页（ui/library/library.c） ---- */
|
||||
meow_view *library_view_create(void);
|
||||
int library_at_root(void); /* 1=当前在 MR_ROOT_DIR */
|
||||
int library_go_up(void); /* 返回上一级；1=已上移，0=已在根 */
|
||||
int library_at_root(void); /* 1=当前在书库根（生产=MR_ROOT_DIR，宿主测试可改根） */
|
||||
int library_go_up(void); /* 上溯父目录：1=已上移/提示停留，0=已在文件系统 "/"（app.c 据此退出） */
|
||||
void library_on_tap(int x, int y);
|
||||
void library_on_swipe(int dir, int dist); /* dist=SDK on_swipe 的位移量（UP/DOWN 用） */
|
||||
void library_on_touch_down(int x, int y);
|
||||
|
||||
+479
-120
@@ -1,20 +1,27 @@
|
||||
/* ui/library/library.c — 图库根页（ACT_LIBRARY）：
|
||||
/* ui/library/library.c — 图库浏览页（ACT_LIBRARY）：
|
||||
*
|
||||
* TopAppBar（标题 + 返回 + ⚙ 位图动作）+ meow_listview 虚拟化目录列表。
|
||||
* 任意文件夹可浏览；无元数据但含 PNG/JPEG/BMP 的文件夹即一本书（含图目录=册）；
|
||||
* M11 起 .cbz/.zip 也作为「册」与文件夹并列（行=封面+文件名+页数，点入直接阅读）。
|
||||
* 行数据由 logic/library 扫描并自然排序；档案册页数/首图由 logic/reader 的 zip 页源提供。
|
||||
* TopAppBar（标题 + 返回 + 「TF卡」回根 + ⚙）+ meow_listview（src2 行数据源）。
|
||||
*
|
||||
* 流畅度（用户指令优先）：
|
||||
* - 首帧只绘文字行：bind 不读盘；缩略图请求投递给后台线程（pthread）异步解码，
|
||||
* 完成后在 on_tick 补位并只 invalidate 列表视口；
|
||||
* - 缩略图 meow_img_downscale 到 96px，并落磁盘缓存 MeowData/<pkg>/cache
|
||||
* （BMP 原始缩略图，文件名含源 mtime+size，源文件变化自动失效；≥64 张按
|
||||
* mtime LRU 删除）；档案册封面=档内首图，先解压到同一 cache（page_cache 管 LRU）；
|
||||
* - 列表滚动用 meow_scroll_wrap：跟手 track + 松手 fling + 行高 snap。
|
||||
* 浏览语义（M13，用户要求：性能 + 访问放开）：
|
||||
* - 首帧只做**单层**枚举（logic/library.c：一次 opendir/readdir+lstat），
|
||||
* 不做任何递归「子树含图」探测；列表行 = 当前目录的直接子目录（M11 起还包括
|
||||
* .cbz/.zip 档案册，与目录自然序混排）；
|
||||
* - 系统目录/空目录/无图目录都列出且可进入；可一路向上到文件系统 '/'，
|
||||
* 左缘返回由 app.c 逐级上溯、到 '/' 才退出 App；
|
||||
* - 「直接含图目录=一本书」与档案册页数改为后台懒算：行仍在 PENDING 时副标题「…」，
|
||||
* 后台线程用 mr_library_probe_path（单层 + mtime/size 失效缓存）算出页数/首图，
|
||||
* on_tick 补位后只 invalidate 列表视口——首帧/滚动/命中判定都不读子目录/档案；
|
||||
* - 不可读/不存在的目录：停留在原目录，顶部横幅提示 2.5s。
|
||||
*
|
||||
* 绘制/颜色：SDK 注册表非保留绘制，全部取 meow_theme_get() 语义色；主题切换由 app.c 的
|
||||
* listener 整帧 invalidate。缩略图缓存只在列表重建时释放（避免池内悬垂指针），上限 24 张。
|
||||
* 行绑定（列表 src2 模式）：meow_listview_create(..., rows, lib_src, ...) 每帧/每次
|
||||
* invalidate 对可见行重新取行；lib_src 只读内存里的 g_lib + 缩略图缓存，并把「待探测/
|
||||
* 待缩略图」请求投递到有界队列（不做 IO），因此懒算结果补位后下一帧即可上屏。
|
||||
*
|
||||
* 缩略图：后台线程 meow_img_downscale 到 96px，落磁盘缓存 MeowData/<pkg>/cache
|
||||
* （BMP，文件名含源 mtime+size，源变化自动失效；≥64 张按 mtime LRU 删除）。
|
||||
* 档案册（M11）封面=档内首图：先解压到 page_cache，再按普通图片解码。
|
||||
*
|
||||
* 绘制/颜色全部取 meow_theme_get() 语义色；主题切换由 app.c 的 listener 整帧 invalidate。
|
||||
*/
|
||||
#include "tuku_internal.h"
|
||||
#include "logic/reader/page_source.h"
|
||||
@@ -37,9 +44,13 @@
|
||||
#define MR_TOPAPPBAR_H 56
|
||||
#define MR_DEFAULT_ROW_H 56
|
||||
#define MR_CACHE_MAX_FILES 64
|
||||
#define MR_HINT_H 44
|
||||
#define MR_HINT_MS 2500
|
||||
|
||||
#define MR_REQ_MAX 64
|
||||
#define MR_RES_MAX 16
|
||||
#define MR_TREQ_MAX 64
|
||||
#define MR_TRES_MAX 16
|
||||
#define MR_PQ_MAX 128
|
||||
#define MR_PRES_MAX 48
|
||||
|
||||
typedef struct thumb_req {
|
||||
int gen;
|
||||
@@ -53,14 +64,32 @@ typedef struct thumb_res {
|
||||
meow_img *img;
|
||||
} thumb_res;
|
||||
|
||||
typedef struct probe_job {
|
||||
int gen;
|
||||
int idx;
|
||||
int is_archive;
|
||||
char path[MR_PATH_MAX];
|
||||
} probe_job;
|
||||
|
||||
typedef struct probe_res {
|
||||
int gen;
|
||||
int idx;
|
||||
int is_archive;
|
||||
char path[MR_PATH_MAX];
|
||||
int ok;
|
||||
mr_library_probe probe;
|
||||
} probe_res;
|
||||
|
||||
static mr_page_ctrl g_ctrl;
|
||||
static mr_library g_lib;
|
||||
static char g_cur_dir[MR_PATH_MAX] = MR_ROOT_DIR;
|
||||
static char g_root_dir[MR_PATH_MAX] = MR_ROOT_DIR; /* 「TF卡」回根目标（宿主测试可改） */
|
||||
|
||||
static meow_widget *g_tb;
|
||||
static meow_widget *g_lv;
|
||||
static meow_scroll *g_scroll;
|
||||
static int g_list_x, g_list_y, g_list_w, g_list_h;
|
||||
static int g_tb_home_idx = -1;
|
||||
|
||||
static struct {
|
||||
int idx;
|
||||
@@ -68,7 +97,7 @@ static struct {
|
||||
} g_thumbs[MR_THUMB_MAX];
|
||||
static int g_thumb_n;
|
||||
|
||||
/* ---- 异步缩略图请求/结果队列 ---- */
|
||||
/* ---- 后台工作线程：探测队列（优先）+ 缩略图队列 ---- */
|
||||
static pthread_t g_worker;
|
||||
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static pthread_cond_t g_cv = PTHREAD_COND_INITIALIZER;
|
||||
@@ -76,21 +105,41 @@ static int g_worker_on;
|
||||
static int g_worker_stop;
|
||||
static int g_gen;
|
||||
|
||||
static thumb_req g_req[MR_REQ_MAX];
|
||||
static int g_req_head, g_req_tail, g_req_n;
|
||||
static char g_inflight[MR_PATH_MAX];
|
||||
static probe_job g_pq[MR_PQ_MAX];
|
||||
static int g_pq_head, g_pq_tail, g_pq_n;
|
||||
static char g_probe_inflight[MR_PATH_MAX];
|
||||
|
||||
static thumb_res g_res[MR_RES_MAX];
|
||||
static int g_res_n;
|
||||
static probe_res g_pres[MR_PRES_MAX];
|
||||
static int g_pres_n;
|
||||
|
||||
/* ---- 磁盘缩略图缓存 ---- */
|
||||
static thumb_req g_treq[MR_TREQ_MAX];
|
||||
static int g_treq_head, g_treq_tail, g_treq_n;
|
||||
static char g_thumb_inflight[MR_PATH_MAX];
|
||||
|
||||
static thumb_res g_tres[MR_TRES_MAX];
|
||||
static int g_tres_n;
|
||||
|
||||
/* ---- 磁盘缩略图缓存（与解压页缓存同目录） ---- */
|
||||
static char g_cache_dir[MR_PATH_MAX];
|
||||
static int g_cache_on;
|
||||
|
||||
/* ---- 顶部提示横幅（不可读目录等） ---- */
|
||||
static int g_hint_id;
|
||||
static char g_hint[160];
|
||||
static uint64_t g_hint_until;
|
||||
static int g_hint_x, g_hint_y, g_hint_w, g_hint_h;
|
||||
|
||||
static int g_drag;
|
||||
static int g_dragged;
|
||||
static int g_drag_last_y;
|
||||
|
||||
/* 书库扫描/后台探测的档案册探测（M11 注入）：logic/library 不依赖 zip 容器。 */
|
||||
static int cbz_archive_pages(const char *path, void *ud)
|
||||
{
|
||||
(void)ud;
|
||||
return mr_zip_count_pages(path);
|
||||
}
|
||||
|
||||
/* ============================================================ */
|
||||
/* 磁盘缓存（BMP 原始缩略图；文件名含源 mtime+size 做失效） */
|
||||
/* ============================================================ */
|
||||
@@ -256,34 +305,71 @@ static meow_img *thumb_load(const char *cover)
|
||||
return im;
|
||||
}
|
||||
|
||||
static void *thumb_worker(void *arg)
|
||||
static void probe_push_res_locked(const probe_job *job, int ok, const mr_library_probe *p)
|
||||
{
|
||||
if (g_pres_n >= MR_PRES_MAX) return;
|
||||
probe_res *r = &g_pres[g_pres_n++];
|
||||
r->gen = job->gen;
|
||||
r->idx = job->idx;
|
||||
r->is_archive = job->is_archive;
|
||||
snprintf(r->path, sizeof r->path, "%s", job->path);
|
||||
r->ok = ok;
|
||||
if (ok && p) r->probe = *p;
|
||||
else memset(&r->probe, 0, sizeof r->probe);
|
||||
}
|
||||
|
||||
static void thumb_push_res_locked(const thumb_req *req, meow_img *im)
|
||||
{
|
||||
if (g_tres_n >= MR_TRES_MAX) { meow_img_free(im); return; }
|
||||
thumb_res *r = &g_tres[g_tres_n++];
|
||||
r->gen = req->gen;
|
||||
r->idx = req->idx;
|
||||
r->img = im;
|
||||
}
|
||||
|
||||
static void *lib_worker(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
for (;;) {
|
||||
thumb_req req;
|
||||
int kind = 0; /* 1=探测 2=缩略图 */
|
||||
probe_job pj;
|
||||
thumb_req tr;
|
||||
|
||||
pthread_mutex_lock(&g_lock);
|
||||
while (!g_worker_stop && g_req_n == 0)
|
||||
while (!g_worker_stop && g_pq_n == 0 && g_treq_n == 0)
|
||||
pthread_cond_wait(&g_cv, &g_lock);
|
||||
if (g_worker_stop) { pthread_mutex_unlock(&g_lock); break; }
|
||||
req = g_req[g_req_head];
|
||||
g_req_head = (g_req_head + 1) % MR_REQ_MAX;
|
||||
g_req_n--;
|
||||
snprintf(g_inflight, sizeof g_inflight, "%s", req.cover);
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
|
||||
meow_img *im = thumb_load(req.cover);
|
||||
|
||||
pthread_mutex_lock(&g_lock);
|
||||
g_inflight[0] = '\0';
|
||||
if (im && !g_worker_stop && g_res_n < MR_RES_MAX) {
|
||||
g_res[g_res_n].gen = req.gen;
|
||||
g_res[g_res_n].idx = req.idx;
|
||||
g_res[g_res_n].img = im;
|
||||
g_res_n++;
|
||||
} else if (im) {
|
||||
meow_img_free(im);
|
||||
if (g_pq_n > 0) { /* 探测优先：页数/角标比重缩略图更影响可读性 */
|
||||
kind = 1;
|
||||
pj = g_pq[g_pq_head];
|
||||
g_pq_head = (g_pq_head + 1) % MR_PQ_MAX;
|
||||
g_pq_n--;
|
||||
snprintf(g_probe_inflight, sizeof g_probe_inflight, "%s", pj.path);
|
||||
} else {
|
||||
kind = 2;
|
||||
tr = g_treq[g_treq_head];
|
||||
g_treq_head = (g_treq_head + 1) % MR_TREQ_MAX;
|
||||
g_treq_n--;
|
||||
snprintf(g_thumb_inflight, sizeof g_thumb_inflight, "%s", tr.cover);
|
||||
}
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
|
||||
if (kind == 1) {
|
||||
mr_library_probe p;
|
||||
int ok = (mr_library_probe_path(pj.path, pj.is_archive,
|
||||
cbz_archive_pages, NULL, &p) == 0);
|
||||
pthread_mutex_lock(&g_lock);
|
||||
g_probe_inflight[0] = '\0';
|
||||
if (!g_worker_stop) probe_push_res_locked(&pj, ok, &p);
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
} else {
|
||||
meow_img *im = thumb_load(tr.cover);
|
||||
pthread_mutex_lock(&g_lock);
|
||||
g_thumb_inflight[0] = '\0';
|
||||
if (im && !g_worker_stop) thumb_push_res_locked(&tr, im);
|
||||
else if (im) meow_img_free(im);
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
@@ -292,7 +378,7 @@ static void worker_start(void)
|
||||
{
|
||||
if (g_worker_on) return;
|
||||
g_worker_stop = 0;
|
||||
if (pthread_create(&g_worker, NULL, thumb_worker, NULL) == 0) g_worker_on = 1;
|
||||
if (pthread_create(&g_worker, NULL, lib_worker, NULL) == 0) g_worker_on = 1;
|
||||
}
|
||||
|
||||
static void worker_stop(void)
|
||||
@@ -306,30 +392,57 @@ static void worker_stop(void)
|
||||
g_worker_on = 0;
|
||||
|
||||
pthread_mutex_lock(&g_lock);
|
||||
for (int i = 0; i < g_res_n; i++) meow_img_free(g_res[i].img);
|
||||
g_res_n = 0;
|
||||
g_req_n = 0;
|
||||
g_req_head = g_req_tail = 0;
|
||||
for (int i = 0; i < g_tres_n; i++) meow_img_free(g_tres[i].img);
|
||||
g_tres_n = 0;
|
||||
g_pres_n = 0;
|
||||
g_treq_n = 0;
|
||||
g_treq_head = g_treq_tail = 0;
|
||||
g_pq_n = 0;
|
||||
g_pq_head = g_pq_tail = 0;
|
||||
g_probe_inflight[0] = '\0';
|
||||
g_thumb_inflight[0] = '\0';
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
}
|
||||
|
||||
/* 请求缩略图：bind 只投递，不阻塞首绘/滚动。 */
|
||||
/* 探测请求：只投递（有界队列 + 去重），不做 IO。 */
|
||||
static void probe_enqueue(int idx, const char *path, int is_archive)
|
||||
{
|
||||
if (!g_worker_on || !path || !path[0]) return;
|
||||
pthread_mutex_lock(&g_lock);
|
||||
if (g_worker_stop) { pthread_mutex_unlock(&g_lock); return; }
|
||||
if (strcmp(g_probe_inflight, path) == 0) { pthread_mutex_unlock(&g_lock); return; }
|
||||
for (int i = 0; i < g_pq_n; i++) {
|
||||
int p = (g_pq_head + i) % MR_PQ_MAX;
|
||||
if (strcmp(g_pq[p].path, path) == 0) { pthread_mutex_unlock(&g_lock); return; }
|
||||
}
|
||||
if (g_pq_n >= MR_PQ_MAX) { pthread_mutex_unlock(&g_lock); return; }
|
||||
g_pq[g_pq_tail].gen = g_gen;
|
||||
g_pq[g_pq_tail].idx = idx;
|
||||
g_pq[g_pq_tail].is_archive = is_archive;
|
||||
snprintf(g_pq[g_pq_tail].path, sizeof g_pq[g_pq_tail].path, "%s", path);
|
||||
g_pq_tail = (g_pq_tail + 1) % MR_PQ_MAX;
|
||||
g_pq_n++;
|
||||
pthread_cond_signal(&g_cv);
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
}
|
||||
|
||||
/* 缩略图请求：bind 只投递，不阻塞首绘/滚动。 */
|
||||
static void thumb_enqueue(int idx, const char *cover)
|
||||
{
|
||||
if (!g_worker_on || !cover || !cover[0]) return;
|
||||
pthread_mutex_lock(&g_lock);
|
||||
if (g_worker_stop) { pthread_mutex_unlock(&g_lock); return; }
|
||||
if (strcmp(g_inflight, cover) == 0) { pthread_mutex_unlock(&g_lock); return; }
|
||||
for (int i = 0; i < g_req_n; i++) {
|
||||
int p = (g_req_head + i) % MR_REQ_MAX;
|
||||
if (strcmp(g_req[p].cover, cover) == 0) { pthread_mutex_unlock(&g_lock); return; }
|
||||
if (strcmp(g_thumb_inflight, cover) == 0) { pthread_mutex_unlock(&g_lock); return; }
|
||||
for (int i = 0; i < g_treq_n; i++) {
|
||||
int p = (g_treq_head + i) % MR_TREQ_MAX;
|
||||
if (strcmp(g_treq[p].cover, cover) == 0) { pthread_mutex_unlock(&g_lock); return; }
|
||||
}
|
||||
if (g_req_n >= MR_REQ_MAX) { pthread_mutex_unlock(&g_lock); return; }
|
||||
g_req[g_req_tail].gen = g_gen;
|
||||
g_req[g_req_tail].idx = idx;
|
||||
snprintf(g_req[g_req_tail].cover, sizeof g_req[g_req_tail].cover, "%s", cover);
|
||||
g_req_tail = (g_req_tail + 1) % MR_REQ_MAX;
|
||||
g_req_n++;
|
||||
if (g_treq_n >= MR_TREQ_MAX) { pthread_mutex_unlock(&g_lock); return; }
|
||||
g_treq[g_treq_tail].gen = g_gen;
|
||||
g_treq[g_treq_tail].idx = idx;
|
||||
snprintf(g_treq[g_treq_tail].cover, sizeof g_treq[g_treq_tail].cover, "%s", cover);
|
||||
g_treq_tail = (g_treq_tail + 1) % MR_TREQ_MAX;
|
||||
g_treq_n++;
|
||||
pthread_cond_signal(&g_cv);
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
}
|
||||
@@ -360,38 +473,38 @@ static int thumb_put(int idx, meow_img *im)
|
||||
}
|
||||
|
||||
/* ============================================================ */
|
||||
/* 列表虚拟化数据源 */
|
||||
/* 行数据源（src2：每帧按需取可见行；零 IO，懒算请求只入队） */
|
||||
/* ============================================================ */
|
||||
static int lib_count(void *ctx)
|
||||
{
|
||||
(void)ctx;
|
||||
return g_lib.count;
|
||||
}
|
||||
|
||||
static void lib_bind(int idx, meow_lv_item *item, void *ctx)
|
||||
static int lib_src(int idx, meow_list_item *item, void *ctx)
|
||||
{
|
||||
(void)ctx;
|
||||
memset(item, 0, sizeof *item);
|
||||
if (idx < 0 || idx >= g_lib.count) return;
|
||||
mr_library_entry *e = &g_lib.items[idx];
|
||||
item->title = e->name;
|
||||
item->subtitle = e->subtitle;
|
||||
item->right = MEOW_LIST_RIGHT_ARROW;
|
||||
item->enabled = 1;
|
||||
item->user = e;
|
||||
|
||||
meow_img *im = thumb_find(idx);
|
||||
mr_library_row row;
|
||||
if (!mr_library_row_at(&g_lib, idx, &row)) return 0;
|
||||
item->title = row.title;
|
||||
item->subtitle = row.subtitle;
|
||||
item->enabled = row.disabled ? 0 : 1;
|
||||
if (row.disabled) return 1;
|
||||
|
||||
int i = row.index;
|
||||
mr_library_entry *e = &g_lib.items[i];
|
||||
item->right = row.is_book ? MEOW_LIST_RIGHT_NONE : MEOW_LIST_RIGHT_ARROW;
|
||||
|
||||
meow_img *im = thumb_find(i);
|
||||
if (im) {
|
||||
item->icon_kind = MEOW_LIST_ICON_IMG;
|
||||
item->icon = im;
|
||||
} else {
|
||||
item->icon_kind = e->has_images ? MEOW_LIST_ICON_FILE : MEOW_LIST_ICON_FOLDER;
|
||||
item->icon_kind = row.is_book ? MEOW_LIST_ICON_FILE : MEOW_LIST_ICON_FOLDER;
|
||||
/* 文件夹册用缩略图源图；档案册没有图片文件，用档案路径（worker 解压首图）。 */
|
||||
const char *src = NULL;
|
||||
if (e->cover[0]) src = e->cover;
|
||||
else if (e->has_images && mr_path_is_archive(e->path)) src = e->path;
|
||||
if (src) thumb_enqueue(idx, src);
|
||||
else if (row.is_book && row.is_archive) src = e->path;
|
||||
if (src) thumb_enqueue(i, src);
|
||||
}
|
||||
if (e->probe_state == MR_LIB_PENDING) probe_enqueue(i, e->path, e->is_archive);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* ============================================================ */
|
||||
@@ -402,6 +515,14 @@ static int lib_top_y(void)
|
||||
return meow_ui_statusbar_height() + MR_TOPAPPBAR_H;
|
||||
}
|
||||
|
||||
static void hint_place(void)
|
||||
{
|
||||
g_hint_x = 0;
|
||||
g_hint_y = lib_top_y();
|
||||
g_hint_w = meow_ui_width();
|
||||
g_hint_h = MR_HINT_H;
|
||||
}
|
||||
|
||||
static void list_rebuild(void)
|
||||
{
|
||||
if (g_scroll) { meow_scroll_free(g_scroll); g_scroll = NULL; }
|
||||
@@ -412,16 +533,16 @@ static void list_rebuild(void)
|
||||
g_list_h = meow_ui_height() - g_list_y;
|
||||
if (g_list_h < 1) g_list_h = 1;
|
||||
|
||||
g_lv = meow_listview_create(g_list_x, g_list_y, g_list_w, g_list_h, 0, NULL, NULL,
|
||||
MEOW_LIST_SEL_NONE);
|
||||
int rows = g_lib.count + (g_lib.truncated ? 1 : 0);
|
||||
g_lv = meow_listview_create(g_list_x, g_list_y, g_list_w, g_list_h, rows,
|
||||
lib_src, NULL, MEOW_LIST_SEL_NONE);
|
||||
if (!g_lv) return;
|
||||
meow_listview_set_vsource(g_lv, lib_count, lib_bind, NULL);
|
||||
meow_listview_set_item_renderer(g_lv, 2, 1, 1);
|
||||
meow_listview_set_item_tier(g_lv, 2);
|
||||
/* SDK 默认 container=0（扁平满幅+分隔线）；显式开 MD3 容器模式：
|
||||
* 每行 surfaceContainer 圆角卡 + 行间空隙 + 卡内 tonal 选中。 */
|
||||
meow_listview_set_container(g_lv, 1);
|
||||
meow_listview_set_empty_text(g_lv, "No folders or CBZ books");
|
||||
meow_listview_set_empty_text(g_lv, "空目录（无可进入的子目录）");
|
||||
|
||||
g_scroll = meow_scroll_wrap(g_lv, 1);
|
||||
if (g_scroll) meow_scroll_set_snap(g_scroll, MR_DEFAULT_ROW_H);
|
||||
@@ -431,12 +552,15 @@ static void update_topbar(void)
|
||||
{
|
||||
if (!g_tb) return;
|
||||
const char *title = "图库";
|
||||
if (strcmp(g_cur_dir, MR_ROOT_DIR) != 0) {
|
||||
if (strcmp(g_cur_dir, "/") == 0) {
|
||||
title = "文件系统 /";
|
||||
} else if (strcmp(g_cur_dir, g_root_dir) != 0) {
|
||||
const char *slash = strrchr(g_cur_dir, '/');
|
||||
if (slash && slash[1]) title = slash + 1;
|
||||
}
|
||||
meow_topappbar_set_title(g_tb, title);
|
||||
meow_topappbar_set_back(g_tb, strcmp(g_cur_dir, MR_ROOT_DIR) != 0);
|
||||
/* 可一路向上到文件系统 '/'：到 '/' 才隐藏返回（此时左缘返回=退出 App）。 */
|
||||
meow_topappbar_set_back(g_tb, strcmp(g_cur_dir, "/") != 0);
|
||||
}
|
||||
|
||||
static void list_invalidate(void)
|
||||
@@ -444,61 +568,179 @@ static void list_invalidate(void)
|
||||
meow_ui_invalidate(g_list_x, g_list_y, g_list_w, g_list_h);
|
||||
}
|
||||
|
||||
/* 目录切换：作废旧异步结果、释放内存缩略图、重新扫描、重建列表（新池强制重新 bind）。 */
|
||||
static void hint_invalidate(void)
|
||||
{
|
||||
meow_ui_invalidate(g_hint_x, g_hint_y, g_hint_w, g_hint_h);
|
||||
}
|
||||
|
||||
static void show_hint(const char *msg)
|
||||
{
|
||||
snprintf(g_hint, sizeof g_hint, "%s", msg ? msg : "");
|
||||
g_hint_until = meow_ui_time_ms() + MR_HINT_MS;
|
||||
hint_place();
|
||||
hint_invalidate();
|
||||
}
|
||||
|
||||
/* 顶部横幅绘制物：只在提示有效且本页 active 时输出（custom 绘制物无 owner 闸门，必须自守）。 */
|
||||
static void library_draw_hint(void *ctx)
|
||||
{
|
||||
(void)ctx;
|
||||
if (meow_ui_activity_active() != ACT_LIBRARY) return;
|
||||
if (!g_hint[0]) return;
|
||||
|
||||
const meow_theme *th = meow_theme_get();
|
||||
int x = g_hint_x, y = g_hint_y, w = g_hint_w, h = g_hint_h;
|
||||
if (w < 40 || h < 20) return;
|
||||
meow_ui_fill_rect(x + 8, y + 4, w - 16, h - 8, th->surfaceContainerHighest);
|
||||
meow_ui_draw_rect(x + 8, y + 4, w - 16, h - 8, th->error);
|
||||
int ty = y + (h - meow_ui_text_height(th->font_body)) / 2;
|
||||
meow_ui_text(x + 20, ty, g_hint, th->font_body, th->error);
|
||||
}
|
||||
|
||||
/* 目录切换：作废旧异步结果、释放内存缩略图、重建列表（新池强制重新取行）。 */
|
||||
static void reset_async(void)
|
||||
{
|
||||
pthread_mutex_lock(&g_lock);
|
||||
g_gen++;
|
||||
g_req_n = 0;
|
||||
g_req_head = g_req_tail = 0;
|
||||
for (int i = 0; i < g_res_n; i++) meow_img_free(g_res[i].img);
|
||||
g_res_n = 0;
|
||||
g_pq_n = 0;
|
||||
g_pq_head = g_pq_tail = 0;
|
||||
g_treq_n = 0;
|
||||
g_treq_head = g_treq_tail = 0;
|
||||
g_pres_n = 0;
|
||||
for (int i = 0; i < g_tres_n; i++) meow_img_free(g_tres[i].img);
|
||||
g_tres_n = 0;
|
||||
g_probe_inflight[0] = '\0';
|
||||
g_thumb_inflight[0] = '\0';
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
}
|
||||
|
||||
/* 书库扫描的档案册探测（M11 注入）：logic/library 不依赖 zip 容器。 */
|
||||
static int cbz_archive_pages(const char *path, void *ud)
|
||||
/* 目录切换：成功 1；不可读/不存在 0（提示；首次加载时仍建空列表）。 */
|
||||
static int load_dir(const char *dir)
|
||||
{
|
||||
(void)ud;
|
||||
return mr_zip_count_pages(path);
|
||||
}
|
||||
/* dir 可能指向 g_lib 里的行路径（点击进入子目录）：先拷到本地，
|
||||
* 避免切换后 mr_library_free 释放 g_lib，dir 变成悬垂指针。 */
|
||||
char target[MR_PATH_MAX];
|
||||
if (!dir || !dir[0] || strlen(dir) >= sizeof target) {
|
||||
show_hint("路径无效");
|
||||
return 0;
|
||||
}
|
||||
snprintf(target, sizeof target, "%s", dir);
|
||||
|
||||
mr_library next;
|
||||
memset(&next, 0, sizeof next);
|
||||
|
||||
uint64_t t0 = meow_ui_time_ms();
|
||||
int n = mr_library_scan_ex(&next, target, MR_LIB_MAX_DEPTH,
|
||||
cbz_archive_pages, NULL);
|
||||
uint64_t ms = meow_ui_time_ms() - t0;
|
||||
if (n < 0) {
|
||||
mr_library_free(&next);
|
||||
const char *slash = strrchr(target, '/');
|
||||
const char *name = (slash && slash[1]) ? slash + 1 : target;
|
||||
char msg[200];
|
||||
snprintf(msg, sizeof msg, "无法读取目录：%s", name);
|
||||
show_hint(msg);
|
||||
meow_log(MEOW_LOG_WARN, "library scan failed: %s", target);
|
||||
/* 启动首帧根目录不可读：仍建一个空列表，页面可交互（返回/回根/上溯）。 */
|
||||
if (!g_lv) {
|
||||
mr_library_free(&g_lib);
|
||||
snprintf(g_cur_dir, sizeof g_cur_dir, "%s", target);
|
||||
reset_async();
|
||||
thumbs_free();
|
||||
list_rebuild();
|
||||
update_topbar();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
if (ms > 120)
|
||||
meow_log(MEOW_LOG_WARN, "library scan slow: %s %llums (%d rows)",
|
||||
target, (unsigned long long)ms, n);
|
||||
|
||||
mr_library_free(&g_lib);
|
||||
g_lib = next;
|
||||
snprintf(g_cur_dir, sizeof g_cur_dir, "%s", target);
|
||||
|
||||
static void load_dir(const char *dir)
|
||||
{
|
||||
snprintf(g_cur_dir, sizeof g_cur_dir, "%s", dir);
|
||||
reset_async();
|
||||
thumbs_free();
|
||||
if (mr_library_scan_ex(&g_lib, g_cur_dir, MR_LIB_MAX_DEPTH,
|
||||
cbz_archive_pages, NULL) < 0) {
|
||||
mr_library_free(&g_lib);
|
||||
meow_log(MEOW_LOG_WARN, "library scan failed: %s", g_cur_dir);
|
||||
}
|
||||
list_rebuild();
|
||||
update_topbar();
|
||||
g_drag = 0;
|
||||
g_dragged = 0;
|
||||
if (g_ctrl.active)
|
||||
meow_ui_invalidate(0, 0, meow_ui_width(), meow_ui_height());
|
||||
return 1;
|
||||
}
|
||||
|
||||
int library_at_root(void)
|
||||
{
|
||||
return strcmp(g_cur_dir, MR_ROOT_DIR) == 0;
|
||||
return strcmp(g_cur_dir, g_root_dir) == 0;
|
||||
}
|
||||
|
||||
int library_go_up(void)
|
||||
{
|
||||
if (library_at_root()) return 0;
|
||||
if (strcmp(g_cur_dir, "/") == 0) return 0; /* 到文件系统根：交给 app.c 退出 */
|
||||
char parent[MR_PATH_MAX];
|
||||
if (mr_path_parent(g_cur_dir, parent, (int)sizeof parent) != 0) return 0;
|
||||
/* 不越过书库根（父级仍须在根目录之下或等于根）。 */
|
||||
if (strcmp(parent, MR_ROOT_DIR) != 0 &&
|
||||
strncmp(parent, MR_ROOT_DIR "/", sizeof(MR_ROOT_DIR)) != 0)
|
||||
snprintf(parent, sizeof parent, "%s", MR_ROOT_DIR);
|
||||
load_dir(parent);
|
||||
if (!load_dir(parent)) {
|
||||
/* 父目录不可读 → 提示并停留。特例：父目录是文件系统 "/" 时仍切到 "/" 的空列表，
|
||||
* 让下一次返回=退出 App（Android 沙箱可能读不了 "/"，否则会卡在最后一个可读目录）。 */
|
||||
if (strcmp(parent, "/") == 0) {
|
||||
mr_library_free(&g_lib);
|
||||
snprintf(g_cur_dir, sizeof g_cur_dir, "%s", parent);
|
||||
reset_async();
|
||||
thumbs_free();
|
||||
list_rebuild();
|
||||
update_topbar();
|
||||
if (g_ctrl.active)
|
||||
meow_ui_invalidate(0, 0, meow_ui_width(), meow_ui_height());
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* TopAppBar「TF卡」：回到书库根（已在根则回到列表顶部）。 */
|
||||
static void library_go_tf_root(void)
|
||||
{
|
||||
if (strcmp(g_cur_dir, g_root_dir) == 0) {
|
||||
if (g_scroll) meow_scroll_stop(g_scroll);
|
||||
if (g_lv) meow_listview_set_scroll(g_lv, 0);
|
||||
list_invalidate();
|
||||
return;
|
||||
}
|
||||
load_dir(g_root_dir);
|
||||
}
|
||||
|
||||
/* 点击行：先确保懒判定完成（单层探测，通常已在缓存里），书=进阅读器，否则进目录。 */
|
||||
static void library_open_entry(int idx)
|
||||
{
|
||||
if (idx < 0 || idx >= g_lib.count) return;
|
||||
mr_library_entry *e = &g_lib.items[idx];
|
||||
|
||||
if (e->probe_state == MR_LIB_PENDING) {
|
||||
mr_library_probe p;
|
||||
if (mr_library_probe_path(e->path, e->is_archive, cbz_archive_pages, NULL, &p) == 0)
|
||||
mr_library_apply_probe(&g_lib, idx, &p);
|
||||
else
|
||||
mr_library_mark_error(&g_lib, idx);
|
||||
list_invalidate();
|
||||
}
|
||||
if (e->probe_state == MR_LIB_FAILED) {
|
||||
char msg[200];
|
||||
snprintf(msg, sizeof msg, "无法读取：%s", e->name);
|
||||
show_hint(msg);
|
||||
return;
|
||||
}
|
||||
if (e->has_images == 1) { mr_reader_open_dir(e->path); return; }
|
||||
if (e->is_archive) { /* 档案册但没有图片页（坏档/空档）：不导航 */
|
||||
char msg[200];
|
||||
snprintf(msg, sizeof msg, "无法阅读（档内没有图片页）：%s", e->name);
|
||||
show_hint(msg);
|
||||
return;
|
||||
}
|
||||
load_dir(e->path);
|
||||
}
|
||||
|
||||
/* ============================================================ */
|
||||
/* 事件 */
|
||||
/* ============================================================ */
|
||||
@@ -511,14 +753,15 @@ void library_on_tap(int x, int y)
|
||||
if (g_tb) {
|
||||
int hit = meow_topappbar_hit(g_tb, x, y);
|
||||
if (hit == MEOW_TOPBAR_BACK) { library_go_up(); return; }
|
||||
if (g_tb_home_idx >= 0 && hit == g_tb_home_idx) { library_go_tf_root(); return; }
|
||||
if (hit >= 0) { meow_view_page_push(ACT_SETTINGS); return; }
|
||||
}
|
||||
if (!g_lv) return;
|
||||
int idx = meow_listview_hit(g_lv, x, y);
|
||||
if (idx < 0 || idx >= g_lib.count) return;
|
||||
mr_library_entry *e = &g_lib.items[idx];
|
||||
if (e->has_images) mr_reader_open_dir(e->path);
|
||||
else load_dir(e->path);
|
||||
if (idx < 0) return;
|
||||
mr_library_row row;
|
||||
if (!mr_library_row_at(&g_lib, idx, &row) || row.disabled) return;
|
||||
library_open_entry(row.index);
|
||||
}
|
||||
|
||||
void library_on_swipe(int dir, int dist)
|
||||
@@ -567,19 +810,47 @@ void library_on_touch_move(int x, int y)
|
||||
list_invalidate();
|
||||
}
|
||||
|
||||
/* 16ms tick：收下后台解码好的缩略图并局部补位。 */
|
||||
/* 16ms tick：收下后台探测/缩略图结果并局部补位；提示横幅到期自动清除。 */
|
||||
void library_on_tick(void)
|
||||
{
|
||||
if (!g_ctrl.active) return;
|
||||
thumb_res got[MR_RES_MAX];
|
||||
int n = 0;
|
||||
|
||||
if (g_hint[0] && meow_ui_time_ms() >= g_hint_until) {
|
||||
g_hint[0] = '\0';
|
||||
hint_invalidate();
|
||||
}
|
||||
|
||||
probe_res pres[MR_PRES_MAX];
|
||||
int pn = 0;
|
||||
pthread_mutex_lock(&g_lock);
|
||||
n = g_res_n;
|
||||
for (int i = 0; i < n; i++) got[i] = g_res[i];
|
||||
g_res_n = 0;
|
||||
pn = g_pres_n;
|
||||
for (int i = 0; i < pn; i++) pres[i] = g_pres[i];
|
||||
g_pres_n = 0;
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
|
||||
int changed = 0;
|
||||
for (int i = 0; i < pn; i++) {
|
||||
probe_res *r = &pres[i];
|
||||
if (r->gen != g_gen || r->idx < 0 || r->idx >= g_lib.count) continue;
|
||||
mr_library_entry *e = &g_lib.items[r->idx];
|
||||
if (strcmp(e->path, r->path) != 0) continue;
|
||||
if (r->ok) {
|
||||
if (mr_library_apply_probe(&g_lib, r->idx, &r->probe) && e->cover[0])
|
||||
thumb_enqueue(r->idx, e->cover);
|
||||
} else {
|
||||
mr_library_mark_error(&g_lib, r->idx);
|
||||
}
|
||||
changed = 1;
|
||||
}
|
||||
|
||||
thumb_res got[MR_TRES_MAX];
|
||||
int n = 0;
|
||||
pthread_mutex_lock(&g_lock);
|
||||
n = g_tres_n;
|
||||
for (int i = 0; i < n; i++) got[i] = g_tres[i];
|
||||
g_tres_n = 0;
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (got[i].gen == g_gen && got[i].idx >= 0 && got[i].idx < g_lib.count &&
|
||||
!thumb_find(got[i].idx) && thumb_put(got[i].idx, got[i].img))
|
||||
@@ -605,10 +876,15 @@ static void library_page_create(meow_view *v, void *ctx)
|
||||
int sb = meow_ui_statusbar_height();
|
||||
g_tb = meow_topappbar_create(0, sb, w, MR_TOPAPPBAR_H, "图库");
|
||||
if (g_tb) {
|
||||
g_tb_home_idx = meow_topappbar_add_action(g_tb, "TF卡");
|
||||
int ai = meow_topappbar_add_action(g_tb, "");
|
||||
if (ai >= 0) meow_topappbar_set_item_icon(g_tb, ai, MEOW_ICON_SETTINGS);
|
||||
}
|
||||
load_dir(MR_ROOT_DIR);
|
||||
|
||||
hint_place();
|
||||
g_hint_id = meow_draw_custom_register(MEOW_Z_TOP, g_hint_x, g_hint_y,
|
||||
g_hint_w, g_hint_h, library_draw_hint, NULL);
|
||||
load_dir(g_root_dir);
|
||||
}
|
||||
|
||||
static void library_page_enter(meow_view *v, void *ctx)
|
||||
@@ -632,6 +908,7 @@ static void library_page_enter(meow_view *v, void *ctx)
|
||||
g_list_w = meow_ui_width();
|
||||
g_list_h = h;
|
||||
}
|
||||
hint_place();
|
||||
g_drag = 0;
|
||||
g_dragged = 0;
|
||||
update_topbar();
|
||||
@@ -652,11 +929,13 @@ static void library_page_destroy(meow_view *v, void *ctx)
|
||||
{
|
||||
(void)v; (void)ctx;
|
||||
worker_stop();
|
||||
if (g_hint_id) { meow_draw_unregister(g_hint_id); g_hint_id = 0; }
|
||||
if (g_scroll) { meow_scroll_free(g_scroll); g_scroll = NULL; }
|
||||
if (g_lv) { meow_widget_free(g_lv); g_lv = NULL; }
|
||||
if (g_tb) { meow_widget_free(g_tb); g_tb = NULL; }
|
||||
thumbs_free();
|
||||
mr_library_free(&g_lib);
|
||||
mr_library_probe_cache_clear();
|
||||
}
|
||||
|
||||
meow_view *library_view_create(void)
|
||||
@@ -669,3 +948,83 @@ meow_view *library_view_create(void)
|
||||
};
|
||||
return meow_view_create(ACT_LIBRARY, MEOW_VIEW_ACTIVITY, &h, &g_ctrl);
|
||||
}
|
||||
|
||||
#ifdef MR_LIBRARY_UI_TEST_HOOKS
|
||||
/* 宿主集成测试接缝（只在 -DMR_LIBRARY_UI_TEST_HOOKS 编译时存在；不进交付二进制）。 */
|
||||
int library_test_load(const char *dir)
|
||||
{
|
||||
return load_dir(dir);
|
||||
}
|
||||
|
||||
void library_test_set_root(const char *root)
|
||||
{
|
||||
if (root && root[0]) snprintf(g_root_dir, sizeof g_root_dir, "%s", root);
|
||||
}
|
||||
|
||||
const char *library_test_root(void)
|
||||
{
|
||||
return g_root_dir;
|
||||
}
|
||||
|
||||
const char *library_test_dir(void)
|
||||
{
|
||||
return g_cur_dir;
|
||||
}
|
||||
|
||||
void library_test_set_dir(const char *dir)
|
||||
{
|
||||
if (dir && dir[0]) snprintf(g_cur_dir, sizeof g_cur_dir, "%s", dir);
|
||||
}
|
||||
|
||||
int library_test_rows(void)
|
||||
{
|
||||
return g_lib.count + (g_lib.truncated ? 1 : 0);
|
||||
}
|
||||
|
||||
int library_test_has_list(void)
|
||||
{
|
||||
return g_lv != NULL;
|
||||
}
|
||||
|
||||
int library_test_src(int idx, meow_list_item *item)
|
||||
{
|
||||
return lib_src(idx, item, NULL);
|
||||
}
|
||||
|
||||
int library_test_hint_active(void)
|
||||
{
|
||||
return g_hint[0] != '\0';
|
||||
}
|
||||
|
||||
const char *library_test_hint(void)
|
||||
{
|
||||
return g_hint;
|
||||
}
|
||||
|
||||
int library_test_go_root(void)
|
||||
{
|
||||
library_go_tf_root();
|
||||
return strcmp(g_cur_dir, g_root_dir) == 0;
|
||||
}
|
||||
|
||||
int library_test_go_up(void)
|
||||
{
|
||||
return library_go_up();
|
||||
}
|
||||
|
||||
/* 缩略图 LRU 接缝（M11 P2-1 回归）：指向当前缓存目录并同步跑一次 prune。 */
|
||||
const char *library_test_cache_dir(void)
|
||||
{
|
||||
return g_cache_dir;
|
||||
}
|
||||
|
||||
int library_test_cache_on(void)
|
||||
{
|
||||
return g_cache_on;
|
||||
}
|
||||
|
||||
void library_test_cache_prune(void)
|
||||
{
|
||||
cache_prune();
|
||||
}
|
||||
#endif
|
||||
Reference in new issue
Block a user