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

Merge branch 'feat/m47-settings-bt-and-wifi-true-toggle-sta'

Browse Source
This commit is contained in:
AskaEth committed 2026-11-11 18:20:27 +08:00
2 parents 3f22158fc2 f49585dd62
commit 63644985a6
8 files changed
+785 -73
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

patch_v2/meow_launcherd/bt_page.c
+159 -20
View File
@@ -17,8 +17,14 @@
*
* 【扫描节流（§七）】进页 nm_bt_scan_on、退页/超时 nm_bt_scan_off；7s 节流由 netmgrd 统一控。
*
* 与网络线共用 net.c（net_bt_* 直连回退 + bt_role 角色判定）。开关写 network.bluetooth_enabled +
* netmgrd on/off；连接/断开/配对经 netmgrd（netmgr_ipc.c nm_bt_* 封装）。
* 【M47 开关可信化】顶栏开关的显示态只来自真实态查询（daemon `bt status` 的 powered，
* 不可达时直连 hciconfig 探测），三态：-1 未知 / 0 关 / 1 开；探测失败=未知（画「?」，不当已关）。
* settings 的 network.bluetooth_enabled 降级为「意图持久化」，不再决定开关外观。点击后先出示
* 「正在开启/关闭…（等待设备确认）」，下发命令 → 有界轮询真实态收敛 → 用真实态定稿；失败/超时
* 回滚并弹窗告知（不许乐观显示成功）。
*
* 与网络线共用 net.c（net_bt_* 直连回退 + bt_role 角色判定）。连接/断开/配对经 netmgrd
* （netmgr_ipc.c nm_bt_* 封装）。
*/
#include "meow_launcher_internal.h"
#include <stdio.h>
@@ -42,18 +48,40 @@ typedef struct {
meow_net_t near[S_NET_MAX];
bt_ep_t a2dp[S_NET_MAX];
int conn_n, paired_n, near_n, a2dp_n;
int bt_on;
int bt_on; /* 真实态三态（-1 未知 / 0 关 / 1 开）——只由 bt_state_now() 写 */
unsigned long long bt_on_ts; /* 上面这次查询的时刻（rows/top_sw 同一 tick 只查一次） */
int output_bt; /* 0=DAC/本地，1=蓝牙 */
int full; /* 1=本次 rows() 全量重扫(conn/paired/a2dp)；0=仅附近(缓存)+角色(节流) */
char mode[48]; /* bt_role 中文描述（次行摘要） */
/* 行副文本池：sub_page_t 行 label/sub 为 const char*，跨 rows() 返回后仍须有效（直到下次
* rows() 重填）。本地栈缓冲会悬垂（agent-396 根因同类），故格式化 sub 一律写进本池。 */
char pool[512];
char pool[768];
int pool_off;
} bt_ctx_t;
/* M47：settings 里的网络开关布尔值降级为「用户意图的持久化」，不再参与显示判定；
* 显示态一律来自 nm_bt_power_state()。 */
extern int nm_bt_power_state(void); /* netmgr_ipc.c：daemon 权威 → 直连探测，三态 */
/* 格式化并拷入 ctx 行副文本池（返回稳定指针；溢出则绕回——512B 远超单页行数所需）。 */
/* 开关收敛参数（宿主测试可在 include 前改小，见 test_bt_page.c）。
* 上限从**点击时刻**起算（评审 r1 P2-3），故它约束的是「从点击到出结论」的总时长：
* - 快路径（daemon 正常，`bt status` 本地 IPC 几 ms）：4s 内约 16 次探测，通常 1~2s 收敛；
* - 慢路径（netmgrd 卡住：on/off 读超时 1.5s → 直连 s_net_toggle_bt 的 hciconfig 0.3~2s；
* 之后一次探测 = status 1.5s 超时 + hciconfig 兜底 1.8s ≈ 3.3s）：总阻塞最坏
* ≈3.5s(下发) + 3.3s(最后一次探测) ≈ **7s**，预算内只够 1 次探测。此时能确认的只是
* 「探测超时」，**不能**宣称「设备无响应」——弹窗文案按此区分（「无法确认当前状态」）。
* 250ms 只是快路径的轮询间隔（不 20ms 级忙轮询）；慢路径由探测自身耗时决定。 */
#ifndef BT_TOGGLE_SETTLE_MS
#define BT_TOGGLE_SETTLE_MS 4000
#endif
#ifndef BT_TOGGLE_POLL_MS
#define BT_TOGGLE_POLL_MS 250
#endif
#define BT_STATE_TTL_MS 800 /* 真实态缓存：rows/top_sw 同一帧共用一次查询 */
/* 格式化并拷入 ctx 行副文本池（返回稳定指针；溢出则绕回——768B 远超单页行数所需）。 */
static char *bt_pool(bt_ctx_t *c, const char *fmt, ...)
{
va_list ap; char tmp[128];
@@ -95,27 +123,127 @@ static const char *bt_conn_name(const bt_ctx_t *c, const char *mac)
}
/* 顶栏开关当前值 */
/* ===== M47：开关「意图 → 真实态」收敛判定（纯函数；无 I/O、无 UI、无全局态）=====
* 输入：intent(1=要开/0=要关)、last_real(下发前最后一次可信真实态，-1 未知)、
* dispatch_ok(下发命令是否成功)、probe(有界等待后的探测结果，-1 未知)、
* timed_out(是否已到等待上限)。
* 输出（四个访问器共用同一套判定，拆开只为调用处可读）：
* meow_toggle_display() 应显示的态（-1 未知 / 0 / 1）：**只认 probe**。probe 未知 → -1，
* 不许回退 last_real 冒充确定态（评审 r1 P2-2：从没被确认过的旧值
* 一旦显示成确定态，就与本单「探测失败=未知」的契约自相矛盾）。
* meow_toggle_pending() 1=还要继续等：下发成功、未超时、且 probe 未等于意图。
* 注意「probe 未知」也算没收敛——绝不因为 last_real 恰好等于意图就收工。
* meow_toggle_rollback() 1=意图未达成（显示态 != 意图）→ UI 必须回滚到真实态。
* meow_toggle_error() 1=收尾后仍未确认 → 必须给用户可见的错误提示（不许静默失败）。
* last_real 不参与状态判定：它只由调用方用于弹窗文案（「上次已知为开启，当前无法确认」），
* 以及后续异步化时判断「回滚到哪」；保留在接口里是因为它是本单约定的输入维度。
* 判定矩阵见 test_bt_page.c「收敛矩阵」；wifi_page.c 复用同一实现。 */
static void mtog_calc(int intent, int last_real, int dispatch_ok, int probe, int timed_out,
int *disp, int *pending, int *rollback, int *error)
{
int want = intent ? 1 : 0;
int d = (probe >= 0) ? (probe ? 1 : 0) : -1; /* 未确认 = 未知，绝不拿旧值顶替 */
int confirmed = (probe >= 0) && ((probe ? 1 : 0) == want);
(void)last_real; /* 仅弹窗文案用，见函数头注释 */
*disp = d;
*pending = (dispatch_ok && !timed_out && !confirmed) ? 1 : 0;
*rollback = (d == want) ? 0 : 1;
*error = (!confirmed && !*pending) ? 1 : 0;
}
int meow_toggle_display(int intent, int last_real, int dispatch_ok, int probe, int timed_out)
{
int d, p, r, e;
mtog_calc(intent, last_real, dispatch_ok, probe, timed_out, &d, &p, &r, &e);
return d;
}
int meow_toggle_pending(int intent, int last_real, int dispatch_ok, int probe, int timed_out)
{
int d, p, r, e;
mtog_calc(intent, last_real, dispatch_ok, probe, timed_out, &d, &p, &r, &e);
return p;
}
int meow_toggle_rollback(int intent, int last_real, int dispatch_ok, int probe, int timed_out)
{
int d, p, r, e;
mtog_calc(intent, last_real, dispatch_ok, probe, timed_out, &d, &p, &r, &e);
return r;
}
int meow_toggle_error(int intent, int last_real, int dispatch_ok, int probe, int timed_out)
{
int d, p, r, e;
mtog_calc(intent, last_real, dispatch_ok, probe, timed_out, &d, &p, &r, &e);
return e;
}
/* 真实态（带 800ms 缓存：top_sw 与 rows 在同一帧各查一次，别为同一问题问 daemon 两遍）。 */
static int bt_state_now(bt_ctx_t *c, int force)
{
unsigned long long t = now_ms();
if (!force && c->bt_on_ts && t - c->bt_on_ts < BT_STATE_TTL_MS) return c->bt_on;
c->bt_on = nm_bt_power_state();
c->bt_on_ts = t;
return c->bt_on;
}
/* 顶栏开关当前值：只报真实态（-1=未知，subpage 画「?」第三态） */
static int bt_top_sw(void *ctx, int *on)
{
(void)ctx;
int v = 0;
if (meow_settings_get_bool("network.bluetooth_enabled", &v) != 0) v = 0;
*on = v;
bt_ctx_t *c = ctx;
*on = bt_state_now(c, 0);
return 1;
}
/* 顶栏开关切换：写设置 + on/off（netmgrd IPC，回退直连 hciconfig）+ 触发扫描 + 同步状态栏 */
/* 顶栏开关切换：落盘意图 → 下发 → 有界等待真实态收敛 → 用真实态定稿/回滚 + 可见错误提示。
* 绝不在下发后就直接把 UI 设成用户想要的样子（那是「显示意图」而不是「显示状态」）。 */
static void bt_top_sw_set(void *ctx, int on)
{
(void)ctx;
meow_settings_set_bool("network.bluetooth_enabled", on);
nm_bt_onoff(on);
g_sys.bt_on = on;
bt_role_refresh(1);
paint_sb_right();
bt_ctx_t *c = ctx;
unsigned long long t_click = now_ms(); /* 上限从点击起算（含下发耗时，见参数注释） */
int want = on ? 1 : 0;
int last_real = bt_state_now(c, 0);
meow_settings_set_bool("network.bluetooth_enabled", want); /* 意图持久化 */
meow_settings_save();
if (on) nm_bt_scan_on();
int dispatch_ok = (nm_bt_onoff(want) == MEOW_OK);
unsigned long long deadline = t_click + BT_TOGGLE_SETTLE_MS;
int probe = bt_state_now(c, 1), timed_out = 0;
while (meow_toggle_pending(want, last_real, dispatch_ok, probe, timed_out)) {
if (now_ms() >= deadline) { timed_out = 1; break; }
usleep(BT_TOGGLE_POLL_MS * 1000);
probe = bt_state_now(c, 1);
}
int disp = meow_toggle_display(want, last_real, dispatch_ok, probe, timed_out);
int rb = meow_toggle_rollback(want, last_real, dispatch_ok, probe, timed_out);
int err = meow_toggle_error(want, last_real, dispatch_ok, probe, timed_out);
unsigned long long elapsed = now_ms() - t_click;
c->bt_on = disp; c->bt_on_ts = now_ms();
/* 回滚语义：只在拿到**真实态**时才改写 settings（确认态或确认的相反态）。
* disp == -1（探测未知）时保留用户原意图不动——本键被 notif_center / settings_page 当
* 显示态读、被 app_launcher 用来决定自动拉起 WiFi，写 0 会把「不知道」污染成「确定已关」
* （评审 r1 P2-1）。 */
if (disp >= 0) {
meow_settings_set_bool("network.bluetooth_enabled", disp == 1);
meow_settings_save();
}
bt_role_refresh(1); /* 先刷新角色（它会写 g_sys.bt_on），再用真实态覆盖 */
if (disp >= 0) g_sys.bt_on = disp;
paint_sb_right();
if (disp == 1) nm_bt_scan_on();
logmsg("bt_page: toggle want=%d ok=%d probe=%d to=%d disp=%d rollback=%d err=%d elapsed=%llums",
want, dispatch_ok, probe, timed_out, disp, rb, err, elapsed);
if (err) {
char line[128];
const char *txt[1]; txt[0] = line;
/* 文案必须与结论同义：probe 未知 = 「无法确认」（不冒充未生效/未响应）；
* probe 已知且 != 意图 = 确认未生效。last_real 只在这里出现。 */
if (disp < 0)
snprintf(line, sizeof line, "无法确认当前状态（上次已知：%s）",
last_real < 0 ? "未知" : (last_real ? "开启" : "关闭"));
else
snprintf(line, sizeof line, "切换未生效：当前仍为%s", disp ? "开启" : "关闭");
s_dd_modal("蓝牙", txt, 1, -1);
}
}
@@ -126,7 +254,7 @@ static int bt_rows(void *ctx, sub_row_t *rbuf, int max)
bt_ctx_t *c = ctx;
int full = c->full; c->full = 0; /* 消费一次全量标记 */
c->pool_off = 0; /* 行副文本池绕回（上轮行字符串已被重填替换） */
c->bt_on = nm_bt_powered(); /* IPC status；回退直连 hci_powered() */
c->bt_on = bt_state_now(c, 0); /* 真实态三态（未知名 -1）；见文件头 M47 说明 */
c->output_bt = 0;
if (meow_settings_get_bool("audio.output_bt", &c->output_bt) != 0) c->output_bt = 0;
if (full || c->conn_n < 0) { /* 首次/动作后：全量重扫 conn/paired/a2dp（全权威） */
@@ -148,6 +276,13 @@ static int bt_rows(void *ctx, sub_row_t *rbuf, int max)
rbuf[n].kind = SUB_HDR; rbuf[n].label = "网络管理服务未运行（直连模式）";
rbuf[n].sub = NULL; rbuf[n].on = 0; rbuf[n].act = 0; n++;
}
/* 第三态显式呈现：真实态未知 ≠ 已关。顶栏开关此时也画「?」（subpage.c），这里再给一行
* 文字说明，避免用户把「不知道」读成「关着」。 */
if (c->bt_on < 0 && n < max) {
rbuf[n].kind = SUB_ROW; rbuf[n].label = "蓝牙状态未知";
rbuf[n].sub = "无法读取开关状态（服务/控制器无响应）";
rbuf[n].on = 0; rbuf[n].act = -2; n++;
}
/* ② A2DP 状态摘要（设备名·codec·采样率·输出=蓝牙/DAC） */
{
@@ -270,10 +405,14 @@ static int bt_act(void *ctx, int idx, int act)
char mac[24] = "";
/* 输出目标/编解码器：与本页设备行 act 段（CONN/PAIRED/NEAR base）不冲突，先处理 */
if (act == BT_ACT_OUTPUT) {
/* 注意返回值语义：return 1 = 「请重绘/重填行」，**不是**「切换已生效」。本分支只写
* settings（audiod 仅启动时读 audio.output_bt），在线切需要 MSG_AUDIO_OUTPUT，
* 属 M46 输出目标单的范围（M45 finding: 20261111-survey-m45-btctl-bug-bt-settings-audiod）。
* 这里不假装成功：不发 IPC、不写 g_sys，只落偏好。 */
c->output_bt = !c->output_bt;
meow_settings_set_bool("audio.output_bt", c->output_bt);
meow_settings_save();
logmsg("bt_page: output_target=%s", c->output_bt ? "bt" : "dac");
logmsg("bt_page: output_target=%s (preference only; audiod reads at start)", c->output_bt ? "bt" : "dac");
return 1; /* 重绘 + 重填行 */
}
if (act == BT_ACT_CODEC) {
patch_v2/meow_launcherd/build_launcher.sh
+45 -8
View File
@@ -11,16 +11,53 @@
# - launcher 与 SDK 共用同一 meow_font.o（已打进 meow_ui.a）——不再单独链 meow_font.a。
# - MEOWOS_VERSION 0.7.21 → 0.7.23（M2.28）。
#
# Build（在 patch_v2/meow_launcherd 下）：
# zig-mipsel-cc -I../sdk -Os -static main_menu.c statusbar.c fb_compositor.c settings_page.c \
# power_menu.c notif_center.c app_launcher.c audio.c backlight.c net.c about.c \
# font_theme.c keys.c util.c meow_touch.c meow_settings.c meow_notif.c \
# ../sdk/meow_ui.a <sysroot>/lib/libz.a -lpthread -o meow_launcherd
# 用法（在 patch_v2/meow_launcherd 下或任意目录）：
# bash build_launcher.sh # 交叉编译 meow_launcherd（mipsel 静态）
# bash build_launcher.sh test # 宿主 gcc 跑本目录 affected 单测（test_bt_page / test_netmgr_ipc）
#
# 工具链：优先环境变量 ZIGCC / MIPS_SYSROOT（M47 起），否则退回历史固定路径 $HOME/Project/R3ProII。
# export ZIGCC=$HOME/.tools/zig-mipsel-cc
set -e
cd "$(dirname "$0")"
ROOT="$HOME/Project/R3ProII"
CC="$ROOT/.tools/zig-mipsel-cc"
SYSROOT="$ROOT/.tools/mipsel-linux-muslsf-cross/mipsel-linux-muslsf"
CC="${ZIGCC:-$HOME/.tools/zig-mipsel-cc}"
[ -x "$CC" ] || CC="$HOME/Project/R3ProII/.tools/zig-mipsel-cc"
SYSROOT="${MIPS_SYSROOT:-$HOME/.tools/mipsel-linux-muslsf-cross/mipsel-linux-muslsf}"
[ -f "$SYSROOT/lib/libz.a" ] || SYSROOT="$HOME/Project/R3ProII/.tools/mipsel-linux-muslsf-cross/mipsel-linux-muslsf"
# ---------------- 宿主单测（M47 起提供入口；只跑本目录受影响的测试）----------------
run_tests() {
local HOSTCC="${HOSTCC:-gcc}"
local TMPD rc=0
TMPD="$(mktemp -d "${TMPDIR:-/tmp}/meow_launcher_test.XXXXXX")"
trap 'rm -rf "$TMPD"' EXIT
echo "== host test: test_bt_page =="
if "$HOSTCC" -I"../sdk" -I. -Wall -Wextra -fsanitize=undefined \
test_bt_page.c -o "$TMPD/test_bt_page"; then
"$TMPD/test_bt_page" || rc=1
else
rc=1
fi
echo "== host test: test_netmgr_ipc =="
if "$HOSTCC" -I"../sdk" -I. -Wall -Wextra -c netmgr_ipc.c -o "$TMPD/netmgr_ipc.test.o" \
&& "$HOSTCC" -I"../sdk" -I. -Wall -Wextra \
test_netmgr_ipc.c "$TMPD/netmgr_ipc.test.o" -lpthread -o "$TMPD/test_netmgr_ipc"; then
"$TMPD/test_netmgr_ipc" || rc=1
else
rc=1
fi
if [ $rc -eq 0 ]; then echo "== ALL TESTS PASS =="; else echo "!! TESTS FAILED"; fi
return $rc
}
if [ "$1" = "test" ]; then
run_tests
exit $?
fi
[ -f "../sdk/meow_ui.a" ] || { echo "!! 缺 ../sdk/meow_ui.a，先跑 sdk/build_sdk.sh"; exit 1; }
"$CC" -I"../sdk" -Os -static -Wall -Wextra \
main_menu.c statusbar.c fb_compositor.c settings_page.c power_menu.c \
patch_v2/meow_launcherd/net.c
+144 -8
View File
@@ -128,6 +128,129 @@ char *popen_read_tmo(int tmo_ms, const char *cmd)
}
/* ===== M47：WiFi/BT「真实开/关」三态探测 =========================================
* 背景：设置页两个开关此前把 settings 布尔（用户意图）当显示态，读不到时 WiFi 还默认 1，
* 于是「开关长什么样」与硬件真实态无关（用户无法判断到底开没开）。M47 起 UI 只认真实态，
* 且真实态一律三态：-1=未知 / 0=关 / 1=开。探测失败/解析不出 = 未知，绝不用 0 冒充「已关」，
* 也不许用 1 冒充「已开」。netmgrd 可达时 BT 以 daemon 的 bt status 为准（见 netmgr_ipc.c）；
* 下列函数是「daemon 不可达」时的直连回退，以及 WiFi 的权威探测（netmgrd 的 wifi on/off
* 就是 rfkill wlan block/unblock，而 wifi status 只报 wpa_state、不报射频态）。 */
/* 读一份 sysfs 字符串（去尾部换行）；失败返回 -1，buf 置空。 */
static int net_read_sys(const char *path, char *buf, int n)
{
buf[0] = 0;
int fd = open(path, O_RDONLY);
if (fd < 0) return -1;
ssize_t r = read(fd, buf, (size_t)n - 1);
close(fd);
if (r <= 0) { buf[0] = 0; return -1; }
buf[r] = 0;
while (r > 0 && (buf[r - 1] == '\n' || buf[r - 1] == '\r')) buf[--r] = 0;
return 0;
}
/* 按 rfkill type 读 soft/hard。返回 1=找到 / 0=无该类型 / -1=不可读。
* 本机实测有 2 个 wlan + 2 个 bluetooth 节点（rfkill0..3）：同一 type 只要有一个被 block，
* 射频就不可用，故按「任一 block 即 block」汇总（保守方向：宁可报关，不假装开着）。 */
static int rfkill_state(const char *type, int *soft, int *hard)
{
DIR *d = opendir("/sys/class/rfkill");
if (!d) return -1;
int found = 0, s_any = 0, h_any = 0;
struct dirent *de;
while ((de = readdir(d))) {
if (strncmp(de->d_name, "rfkill", 6) != 0) continue;
char path[128], ty[32];
snprintf(path, sizeof path, "/sys/class/rfkill/%s/type", de->d_name);
if (net_read_sys(path, ty, sizeof ty) != 0) continue;
if (strcmp(ty, type) != 0) continue;
snprintf(path, sizeof path, "/sys/class/rfkill/%s/soft", de->d_name);
int s = read_file_int(path);
snprintf(path, sizeof path, "/sys/class/rfkill/%s/hard", de->d_name);
int h = read_file_int(path);
if (s < 0 || h < 0) continue; /* 读出失败：当作没找到这一类 */
found = 1;
if (s) s_any = 1;
if (h) h_any = 1;
}
closedir(d);
if (!found) return 0;
*soft = s_any; *hard = h_any;
return 1;
}
/* 写 rfkill soft（block=1 关 / 0 开）。返回 0=至少写成功一个；-1=无该类型设备或全写失败。
* 同类多个节点全写（只写第一个会漏掉真正绑定驱动的那个）。netmgrd 的 rfkill_set_block
* 只写首个匹配节点（见 meow_netmgrd.c:992-1016）——已作为 finding 报给塔，不在本单改。
* M47：netmgrd 的 bt on/off 就是「hciconfig + rfkill soft」，直连路径必须写同一份状态，
* 否则「从本页关过蓝牙」之后从别的入口 `hciconfig up` 会被内核 rfkill 拦下（开关失真）。 */
static int rfkill_set_soft(const char *type, int block)
{
DIR *d = opendir("/sys/class/rfkill");
if (!d) return -1;
int rc = -1;
struct dirent *de;
while ((de = readdir(d))) {
if (strncmp(de->d_name, "rfkill", 6) != 0) continue;
char path[128], ty[32];
snprintf(path, sizeof path, "/sys/class/rfkill/%s/type", de->d_name);
if (net_read_sys(path, ty, sizeof ty) != 0) continue;
if (strcmp(ty, type) != 0) continue;
snprintf(path, sizeof path, "/sys/class/rfkill/%s/soft", de->d_name);
int fd = open(path, O_WRONLY);
if (fd < 0) continue;
char v[2] = { block ? '1' : '0', 0 };
if (write(fd, v, 1) == 1) rc = 0; /* 任一成功即视为已下发（不因后一个失败翻回 -1） */
close(fd);
}
closedir(d);
return rc;
}
/* WiFi 射频真实态：-1 未知 / 0 关 / 1 开。
* 1) 有 wlan rfkill 设备（netmgrd 的 wifi on/off 就是写它）：hard/soft 任一 block = 关；
* 未 block 时接口存在才算开（无 wlan0 = 驱动没载，无法判定 → 未知）。
* 2) 无 rfkill 设备：退 wlan0 管理态 IFF_UP（与状态栏 wlan_radio_up 同源）。
* 3) 都读不到 = 未知（不当「已关」）。 */
int net_wifi_power_probe(void)
{
int soft = 0, hard = 0;
int rk = rfkill_state("wlan", &soft, &hard);
if (rk == 1) {
if (hard || soft) return 0;
return access("/sys/class/net/wlan0", F_OK) == 0 ? 1 : -1;
}
if (rk < 0) return -1;
if (access("/sys/class/net/wlan0", F_OK) != 0) return -1;
char b[16];
if (net_read_sys("/sys/class/net/wlan0/flags", b, sizeof b) != 0) return -1;
return (int)(strtoul(b, NULL, 16) & 0x1UL) ? 1 : 0;
}
/* BT 控制器真实态：-1 未知 / 0 关 / 1 开。
* 权威 = hciconfig hci0 的 UP/DOWN 状态行（与 netmgrd bt_status 的回退解析同源）。
* 命令超时/无输出/既无 UP 也无 DOWN（如 hci0 不存在）= 未知。 */
int net_bt_power_probe(void)
{
char *o = popen_read_tmo(1800,
"PATH=/bin:/sbin:/usr/bin:/usr/sbin hciconfig -a hci0 2>/dev/null");
if (!o) return -1;
int r = -1;
char *line = o;
while (line && *line) {
char *eol = strchr(line, '\n'); if (eol) *eol = 0;
char *p = line;
while (*p == ' ' || *p == '\t') p++;
if (!strncmp(p, "DOWN", 4)) { r = 0; break; }
if (!strncmp(p, "UP", 2)) { r = 1; break; }
line = eol ? eol + 1 : NULL;
}
free(o);
return r;
}
/* 十六进制字符值（'0'-'9'/'a'-'f'/'A'-'F'）；非法返回 -1。避免依赖 ctype.h（musl/内存受限）。
* M2.40：wpa_cli 对非 ASCII SSID 输出 "\xNN" 转义文字（`\`+x+两位hex 的纯文字，非真字节），
* 需先还原成真实 UTF-8 字节才能进界面文本。 */
@@ -733,7 +856,11 @@ int s_net_get(const srow_t *r, char *buf, int len)
/* 网络动作开关：wifi/bluetooth 开/关（写 wlan0/hci0；立即生效，异步刷新缓存）。
* 走 system（wifi_up.sh 自身后台化子进程、ip link/hciconfig 均为快 ioctl）。 */
* 走 system（wifi_up.sh 自身后台化子进程、ip link/hciconfig 均为快 ioctl）。
* M47：蓝牙补上 rfkill soft（与 netmgrd 的 bt on/off 同一语义）——此前本函数只发 hciconfig，
* 于是「在蓝牙页关过（rfkill soft=1）→ 再从通知中心/设置主页打开」时 `hciconfig up` 被内核
* rfkill 拦下、settings 却已写 1，开关显示 ON 实际 OFF（M45 盘点的开关失真）。开：先解 rfkill
* 再 up（顺序颠倒会先失败一次）；关：先 down 再 block（与 netmgrd 一致）。 */
void s_net_toggle_wifi(int on)
{
if (on) system("PATH=/bin:/sbin:/usr/bin:/usr/sbin /usr/bin/wifi_up.sh");
@@ -742,24 +869,33 @@ void s_net_toggle_wifi(int on)
void s_net_toggle_bt(int on)
{
if (on) system("hciconfig hci0 up 2>/dev/null");
else system("hciconfig hci0 down 2>/dev/null");
if (on) {
rfkill_set_soft("bluetooth", 0);
system("hciconfig hci0 up 2>/dev/null");
} else {
system("hciconfig hci0 down 2>/dev/null");
rfkill_set_soft("bluetooth", 1);
}
}
/* 进入设置页时把 network.wifi_enabled/bluetooth_enabled 同步为真实硬件态，
* 让开关行反映 reality（仅同步内存 + 刷新缓存；不落盘 —— s_commit 的 save 才真正写）。
* settings 未 init/取值失败则不动（保默认）。 */
* settings 未 init/取值失败则不动（保默认）。
* M47（M45 盘点）：WiFi 判据不再是 wlan_connected()（=operstate up，即「已关联」）——网卡 up
* 但未关联时 operstate=dormant，旧写法会把 key 改成 0、WiFi 页开关显示 OFF 而射频明明开着；
* 改用 net_wifi_power_probe()（rfkill/网卡 up）。BT 改用三态探测：读不到（-1）就不写，
* 不拿 0 猜「已关」。 */
void s_net_sync_from_sys(void)
{
int cur = 0;
if (meow_settings_get_bool("network.wifi_enabled", &cur) == 0) {
int real = wlan_connected() ? 1 : 0;
if (real != cur) meow_settings_set_bool("network.wifi_enabled", real);
int real = net_wifi_power_probe();
if (real >= 0 && real != cur) meow_settings_set_bool("network.wifi_enabled", real);
}
if (meow_settings_get_bool("network.bluetooth_enabled", &cur) == 0) {
int real = hci_powered() ? 1 : 0;
if (real != cur) meow_settings_set_bool("network.bluetooth_enabled", real);
int real = net_bt_power_probe();
if (real >= 0 && real != cur) meow_settings_set_bool("network.bluetooth_enabled", real);
}
/* 只同步开关（快）+ 异步 kick；状态/列表由 run_settings_page 主循环 pump，绝不阻塞入口。 */
s_net_refresh_kick();
patch_v2/meow_launcherd/netmgr_ipc.c
+53 -4
View File
@@ -15,6 +15,11 @@
#define NETMGR_SOCK_DEFAULT "/usr/data/meow_net.sock"
/* NETMGR_UNREACH 定义在 meow_launcher_internal.h（测试/调用方共用） */
/* M47：net.c 的直连三态探测（-1 未知 / 0 关 / 1 开）。声明在此而非头文件——头文件不在本单
* 改动范围；两处定义与用法同属 launcher 网络线。 */
int net_bt_power_probe(void);
int net_wifi_power_probe(void);
/* IPC 读超时（ms）。netmgrd 单线程 poll，connect/connecth 会阻塞 ~10s/~15s 有界等待
* wpa_state=COMPLETED（bug1），scan 内含 1.5s 触发等待（P3）——客户端 per-command 超时需
* 覆盖这些同步等待，其余读级子命令维持 1.5s 不被卡死。 */
@@ -96,9 +101,14 @@ static int nm_hello(int fd)
}
/* 发一条 WIFI_CTL/BT_CTL 子命令，收 RESULT。返回 netmgrd 业务 code；NETMGR_UNREACH=不可达。
* tmo_ms：读超时（connect/connecth/scan 需覆盖 netmgrd 同步等待，见 NM_TMO_*）。 */
static int nm_cmd(uint16_t ctl_type, uint16_t res_type, const char *cmd, const char *arg,
char *text, int tlen, int tmo_ms)
* tmo_ms：读超时（connect/connecth/scan 需覆盖 netmgrd 同步等待，见 NM_TMO_*）。
* read_timeout（可空）：非空时，「帧收发失败/类型不符」这一支只回写 *read_timeout=1 且**不**
* 把可达性缓存打成 down——调用方据此区分「读超时」与「真不可达」。M47 的 BT 状态查询用它：
* netmgrd 单线程忙时（bt status 自己会跑 hciconfig）状态查询可能超过 1.5s，若据此标 down，
* 紧随的 bt_rows 会闪出「服务未运行（直连模式）」并把后续探测切到 1.8s 的 hciconfig
* （评审 r1 观察；global 超时常量不动，WiFi/DNS 路径行为不变）。 */
static int nm_cmd_t(uint16_t ctl_type, uint16_t res_type, const char *cmd, const char *arg,
char *text, int tlen, int tmo_ms, int *read_timeout)
{
m_net_cmd_t q;
memset(&q, 0, sizeof q);
@@ -110,7 +120,10 @@ static int nm_cmd(uint16_t ctl_type, uint16_t res_type, const char *cmd, const c
uint8_t rbuf[MEOW_IPC_MAX]; uint16_t rtype = 0;
memset(rbuf, 0, sizeof rbuf);
if (nm_xchg(fd, ctl_type, 0x101, &q, sizeof q, rbuf, sizeof rbuf, &rtype, tmo_ms) < 0 || rtype != res_type) {
close(fd); nm_cache(0); return NETMGR_UNREACH;
close(fd);
if (read_timeout) *read_timeout = 1;
else nm_cache(0);
return NETMGR_UNREACH;
}
m_net_cmd_result_t res; memcpy(&res, rbuf, sizeof res);
close(fd);
@@ -121,6 +134,12 @@ static int nm_cmd(uint16_t ctl_type, uint16_t res_type, const char *cmd, const c
return (int)res.code;
}
static int nm_cmd(uint16_t ctl_type, uint16_t res_type, const char *cmd, const char *arg,
char *text, int tlen, int tmo_ms)
{
return nm_cmd_t(ctl_type, res_type, cmd, arg, text, tlen, tmo_ms, NULL);
}
int netmgr_wifi_tmo(const char *cmd, const char *arg, char *text, int tlen, int tmo_ms)
{ return nm_cmd(MSG_NET_WIFI_CTL, MSG_NET_WIFI_RESULT, cmd, arg, text, tlen, tmo_ms); }
@@ -552,6 +571,36 @@ int nm_bt_powered(void)
return atoi(v);
}
/* ===== M47：设置页开关的「真实态」三态查询（-1 未知 / 0 关 / 1 开）=====
* 与 nm_bt_powered()/nm_wifi_connected() 的区别：那两个把「问不到」塌缩成 0（看起来像
* 「已关」），正是开关显示不可信的根因之一。M47 起设置页开关只用下面两个函数。 */
int nm_bt_power_state(void)
{
char text[192];
int read_timeout = 0;
/* 状态查询走专用入口：读超时 = 「状态未知」，且不把 netmgrd 标成 down（见 nm_cmd_t 注释）。 */
int rc = nm_cmd_t(MSG_NET_BT_CTL, MSG_NET_BT_RESULT, "status", NULL,
text, sizeof text, NM_TMO_DFL, &read_timeout);
if (read_timeout) return -1;
if (rc == NETMGR_UNREACH) return net_bt_power_probe(); /* 直连回退；失败=未知 */
if (rc != MEOW_OK) return -1; /* daemon 报错：不知道就是不知道 */
char v[8];
nm_val(text, "available=", v, sizeof v, 0);
if (v[0] && atoi(v) == 0) return 0; /* 无控制器 → 必为关 */
nm_val(text, "powered=", v, sizeof v, 0);
if (!v[0]) return -1; /* 无 powered 字段 → 未知 */
return atoi(v) ? 1 : 0;
}
/* WiFi 射频真实态（三态）。netmgrd 的 `wifi status` 只报 wpa_state/连接态，不报射频开关
* （见 meow_netmgrd.c wifi_status，字段仅 state/connected/ssid/ip/rssi），无法据此判断
* 「wifi 开关」；而 daemon 的 wifi on/off 恰好就是 rfkill wlan block/unblock，所以射频态
* 取本地 rfkill（回退 wlan0 IFF_UP）——与 daemon 改的是同一份内核状态，且探测失败=未知。 */
int nm_wifi_power_state(void)
{
return net_wifi_power_probe();
}
int nm_bt_onoff(int on)
{
char text[128];
patch_v2/meow_launcherd/subpage.c
+87 -12
View File
@@ -541,7 +541,8 @@ static sub_page_t *g_sp; /* 当前运行子页（rows/act/detai
static sub_row_t g_rows[SUB_ROWS_MAX]; /* 行缓冲：rows() 一次性填满，listview bind 只读 */
static int g_nrows = 0; /* 当前行数（listview vsource count 实时读） */
static int g_top_sw_en = 0; /* 本页是否显示顶开关 */
static int g_top_on = 0; /* 顶开关当前值 */
static int g_top_on = 0; /* 顶开关当前值（0/1；未知时停 0 并置 g_top_sw_unknown） */
static int g_top_sw_unknown = 0; /* M47 第三态：真实态未知（页回调 top_sw 回 -1） */
static meow_widget *g_tb = NULL; /* topappbar */
static meow_widget *g_sw = NULL; /* 顶开关（仅在有顶开关的页创建/使用） */
@@ -668,22 +669,29 @@ static void sp_widgets_create(void)
g_sp_init = 1;
}
/* 顶开关控件置态（M47：未知 -1 时 SDK 开关只有两态，停在「关」+ 灰色「?」角标区分）。 */
static void sp_top_sw_apply(void)
{
if (g_sw) meow_switch_set(g_sw, g_top_on == 1 ? 1 : 0);
}
/* 逐页配置：topappbar 标题 + 顶开关（按需创建/置态）+ listview 行数。 */
static void sp_configure_page(const sub_page_t *p, int top_sw_en, int top_on)
{
if (p->title && g_tb) meow_topappbar_set_title(g_tb, p->title);
g_top_sw_en = top_sw_en;
g_top_on = top_on;
/* M47：top_sw 回调的 *on 是三态（-1 未知 / 0 / 1），见 bt_page/wifi_page。 */
g_top_sw_unknown = (top_on < 0) ? 1 : 0;
g_top_on = (top_on == 1) ? 1 : 0;
if (top_sw_en) {
if (!g_sw) {
meow_ui_activity_push(SUB_SENTINEL_ACT); /* owner 钉哨兵（命中闸门） */
int swx = fb_xres - SUB_PAD_X - 56; /* meow_switch 固定 56×32 */
int swy = SUB_TB_Y + (SUB_TB_H - SUB_SW_H) / 2;
g_sw = meow_switch_create(swx, swy, top_on);
g_sw = meow_switch_create(swx, swy, g_top_on);
meow_ui_activity_pop();
} else if (g_sw) {
meow_switch_set(g_sw, top_on);
}
sp_top_sw_apply();
}
/* 批③：行完全自绘 on/off —— 页提供 row_draw 用自绘；否则清 NULL 回默认 renderer。 */
if (g_lv) meow_listview_set_item_draw(g_lv, p->row_draw ? sp_lv_draw : NULL, NULL);
@@ -697,7 +705,17 @@ static void sp_paint_page(void)
meow_ui_fill_rect(0, 0, W, H, mt->surface); /* 全屏底 surface */
draw_statusbar();
if (g_tb) meow_widget_draw(g_tb); /* topappbar（含底部分隔线） */
if (g_sw && g_top_sw_en) meow_widget_draw(g_sw); /* 顶开关（叠顶栏右缘） */
if (g_sw && g_top_sw_en) {
meow_widget_draw(g_sw); /* 顶开关（叠顶栏右缘） */
if (g_top_sw_unknown) {
/* M47 第三态：真实态未知。SDK 开关只有开/关两态，故开关停「关」并在左侧画灰色
* 「?」——明确表达「不是关着，是不知道」，而不是拿「关」冒充。 */
int qh = meow_ui_text_height(20);
int qw = ui_width("?", 20);
ui_draw(fb_xres - SUB_PAD_X - 56 - qw - 6,
SUB_TB_Y + (SUB_TB_H - qh) / 2, "?", mt->outline, 20);
}
}
sp_paint_top_action(); /* 批③：顶栏右侧动作按钮 */
int lvx, lvy, lvw, lvh;
sp_lv_rect(&lvx, &lvy, &lvw, &lvh);
@@ -710,13 +728,40 @@ static void sp_paint_page(void)
s_ui_theme()->outline, 18);
}
/* 顶部开关切换：写设置 + 生效 + 触发重扫 + 重填行。 */
/* 顶开关回读真实态（M47：UI 只认权威回调，不做「点了就翻面」的乐观更新）。 */
static void sp_top_sw_resync(void)
{
if (!g_sp || !g_sp->top_sw) return;
int on = 0;
if (!g_sp->top_sw(g_sp->ctx, &on)) { g_top_sw_en = 0; return; }
g_top_sw_en = 1;
g_top_sw_unknown = (on < 0) ? 1 : 0;
g_top_on = (on == 1) ? 1 : 0;
}
/* 「待确认」态：开关保持上一次已确认外观，内容区顶出示同步条——与稳定态肉眼可区分。
* 有界等待期间主循环阻塞在 top_sw_set 内，所以必须先画一帧再下发。 */
static void sp_paint_switching(int want)
{
const meow_theme *mt = meow_theme_get();
char line[64];
snprintf(line, sizeof line, "正在%s…（等待设备确认）", want ? "开启" : "关闭");
int h = 32, y = SUB_CONT_TOP;
meow_ui_fill_rect(0, y, fb_xres, h, mt->surfaceContainerHigh);
meow_ui_text_center(fb_xres / 2, y + (h - meow_ui_text_height(18)) / 2, line, 18, mt->primary);
meow_dirty_full();
meow_ui_flush();
}
/* 顶部开关切换：待确认态 → 页内下发+有界等待+失败弹窗 → 回读真实态 → 重填行。 */
static void sp_top_sw_toggle(void)
{
if (!g_sp || !g_sp->top_sw_set) return;
g_sp->top_sw_set(g_sp->ctx, !g_top_on);
g_top_on = !g_top_on;
if (g_sw) meow_switch_set(g_sw, g_top_on);
int want = (g_top_on == 1) ? 0 : 1; /* 未知(-1) 视同「关」：点一下表示「请打开」 */
sp_paint_switching(want);
g_sp->top_sw_set(g_sp->ctx, want); /* 页内：下发 + 有界轮询真实态 + 失败回滚/弹窗 */
sp_top_sw_resync(); /* 定稿只认真实态 */
sp_top_sw_apply();
if (g_sp->rows) {
g_nrows = g_sp->rows(g_sp->ctx, g_rows, SUB_ROWS_MAX);
if (g_nrows > SUB_ROWS_MAX) g_nrows = SUB_ROWS_MAX;
@@ -977,9 +1022,31 @@ int meow_subpage_run(sub_page_t *p)
}
if (g_top_sw_en && g_sw && meow_widget_hit(g_sw, tx, ty)) {
sp_top_sw_toggle();
last_act = now;
last_act = now_ms(); /* 切换内可能阻塞数秒：取新鲜时刻，
* 否则空闲息屏会按陈旧时刻提前触发 */
/* 评审 r1 P2-4：M47 起顶开关路径也会开 s_dd_modal（切换失败/
* 无法确认）。s_dd_modal 是全屏压暗层，关闭后必须像行命中分支
* 一样排空触摸、复位触摸/按键基线并置 after_modal —— 否则
* 返回脏区不含状态栏(0..27)，会残留压暗到下一次时钟重绘，
* 电源/播放键也可能带进弹窗里的陈旧边沿。 */
if (tfd >= 0) {
unsigned char e[16];
while (read(tfd, e, sizeof e) == 16) {}
usleep(40000);
while (read(tfd, e, sizeof e) == 16) {}
}
td = 0; td_ok = 0; scroll_drag = 0;
drag_last_y = 0;
tdx = tdy = tlx = tly = -1;
touch_cooldown_until = now_ms() + 300;
key_router_rebase();
memset(&kd_pwr, 0, sizeof kd_pwr);
memset(&kd_play, 0, sizeof kd_play);
kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
after_modal = 1;
need_paint = 1;
if (tfd >= 0) { unsigned char e[16]; while (read(tfd, e, sizeof e) == 16) {} }
continue;
}
/* 列表行命中（SDK 命中：含滚动换算 + 越界/禁用行不响应） */
@@ -1035,6 +1102,14 @@ int meow_subpage_run(sub_page_t *p)
/* ---- 周期性重扫（live 页：蓝牙附近扫描等驻留更新）---- */
if (g_sp && g_sp->live && now - last_live >= 2000) {
last_live = now;
/* M47：顶开关也按 live 周期回读真实态——外部（其它页面/守护进程）改了开关，
* 本页驻留期间也要跟着变，而不是停在进入页面时那一刻。 */
int sw_before = g_top_on, unk_before = g_top_sw_unknown;
if (g_top_sw_en) sp_top_sw_resync();
if (g_top_on != sw_before || g_top_sw_unknown != unk_before) {
sp_top_sw_apply();
need_paint = 1;
}
int new_n = g_sp->rows ? g_sp->rows(g_sp->ctx, g_rows, SUB_ROWS_MAX) : 0;
if (new_n > SUB_ROWS_MAX) new_n = SUB_ROWS_MAX;
if (new_n != g_nrows) {
patch_v2/meow_launcherd/test_bt_page.c
+131 -6
View File
@@ -8,16 +8,25 @@
* P2 bt_act 命中 → 正确下发 netmgrd 命令（已连接→disconnect、已配对未连→connect、输出目标
* 切换、编解码器循环）；
* P3 附近设备仅列未配对（已配对者归「已配对设备」）。
* P4 M47 开关三态：真实态未知(-1) → top_sw 回 -1 + 行内「蓝牙状态未知」（不当已关）；
* P5 M47 点击收敛：下发成功且真实态达成 → 定稿、不弹窗；下发失败/超时/未知 → 回滚 + 弹窗；
* P6 M47 收敛矩阵（纯函数 meow_toggle_*，真实态×下发结果×探测 全组合）。
*
* 编译（在 patch_v2/meow_launcherd 下）：
* gcc -I../sdk -I. -Wall -Wextra -fsanitize=undefined test_bt_page.c -o test_bt_page
* 运行：./test_bt_page
* 运行：./test_bt_page（或 `bash build_launcher.sh test`）
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <strings.h>
#include <unistd.h>
#include <time.h>
/* M47：把收敛等待改成宿主可接受的尺度（生产 4000ms/250ms，见 bt_page.c）。 */
#define BT_TOGGLE_SETTLE_MS 80
#define BT_TOGGLE_POLL_MS 10
#include "meow_launcher_internal.h"
#include "bt_page.c" /* bt_rows/bt_act/bt_top_sw/bt_detail 平移到本 TU */
@@ -29,9 +38,12 @@ static bt_ep_t g_eps[8]; static int g_eps_n;
static char g_last_cmd[128]; /* 记录 act 下发命令，如 "disconnect:<mac>" */
static int g_output_bt; /* audio.output_bt 桩值 */
static char g_codec[16] = "auto"; /* bt.codec 桩值 */
static int g_bt_state = 1; /* M47：真实态三态桩（-1 未知 / 0 / 1） */
static int g_onoff_rc = MEOW_OK; /* M47：nm_bt_onoff 下发结果桩 */
static int g_bt_en_setting = 1; /* M47：network.bluetooth_enabled 桩值（意图/回滚观察点） */
int nm_bt_powered(void) { return 1; }
int nm_bt_onoff(int on) { (void)on; return 0; }
int nm_bt_power_state(void) { return g_bt_state; }
int nm_bt_onoff(int on) { (void)on; return g_onoff_rc; }
int nm_bt_connected(meow_net_t *out, int max) {
if (max > g_conn_n) max = g_conn_n;
memcpy(out, g_conn, (size_t)max * sizeof *out); return max;
@@ -65,14 +77,14 @@ void net_bt_mode_str(char *buf, int len) { snprintf(buf, (size_t)len, "主模式
int meow_settings_get_bool(const char *k, int *v)
{
if (v) *v = 0;
if (!strcmp(k, "network.bluetooth_enabled")) { if (v) *v = 1; return 0; }
if (!strcmp(k, "network.bluetooth_enabled")) { if (v) *v = g_bt_en_setting; return 0; }
if (!strcmp(k, "audio.output_bt")) { if (v) *v = g_output_bt; return 0; }
return -1;
}
int meow_settings_set_bool(const char *k, int v)
{
if (!strcmp(k, "audio.output_bt")) { g_output_bt = v; return 0; }
if (!strcmp(k, "network.bluetooth_enabled")) return 0;
if (!strcmp(k, "network.bluetooth_enabled")) { g_bt_en_setting = v; return 0; }
return -1;
}
int meow_settings_get_str(const char *k, char *b, int n)
@@ -91,9 +103,26 @@ void paint_sb_right(void) {}
void logmsg(const char *fmt, ...) { (void)fmt; }
void bt_role_refresh(int force) { (void)force; }
meow_sys_state g_sys;
int s_dd_modal(const char *title, const char *item[S_NET_MAX], int n, int cur) { (void)title; (void)item; (void)n; (void)cur; return -1; }
static int g_modal_n = 0; /* M47：可见错误提示（弹窗）计数 */
static char g_modal_line[128] = "";
int s_dd_modal(const char *title, const char *item[S_NET_MAX], int n, int cur)
{
(void)title; (void)cur;
g_modal_n++;
g_modal_line[0] = 0;
if (item && n > 0 && item[0]) snprintf(g_modal_line, sizeof g_modal_line, "%s", item[0]);
return -1;
}
int meow_subpage_run(sub_page_t *p) { (void)p; return 0; }
/* M47：真实时钟（收敛等待用），毫秒单调。 */
unsigned long long now_ms(void)
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (unsigned long long)ts.tv_sec * 1000ULL + (unsigned long long)(ts.tv_nsec / 1000000);
}
static int g_fail = 0;
#define CHECK(cond, ...) do { if (cond) { printf(" PASS: " __VA_ARGS__); printf("\n"); } \
else { printf(" FAIL: " __VA_ARGS__); printf("\n"); g_fail++; } } while (0)
@@ -111,6 +140,13 @@ static int find_act(const sub_row_t *r, int n, int from, const char *pref)
if (r[i].kind == SUB_ACT && r[i].label && !strncmp(r[i].label, pref, strlen(pref))) return i;
return -1;
}
/* 按 label 精确找任意行（M47 未知态占位行用） */
static int row_label(const sub_row_t *r, int n, const char *lbl)
{
for (int i = 0; i < n; i++)
if (r[i].label && !strcmp(r[i].label, lbl)) return i;
return -1;
}
static void fill_state(void)
{
@@ -230,6 +266,95 @@ int main(void)
bt_act(&c, ci, rows[ci].act);
CHECK(strcmp(g_codec, "SBC") == 0, "编解码器 auto → SBC (实际=%s)", g_codec);
printf("== P4 M47 开关三态（未知 ≠ 已关）==\n");
int sw = 0;
g_bt_state = -1; /* 真实态未知 */
memset(&c, 0, sizeof c); c.full = 1; fill_state();
CHECK(bt_top_sw(&c, &sw) == 1 && sw == -1, "真实态未知 → top_sw *on=-1 (实际=%d)", sw);
n = bt_rows(&c, rows, SUB_ROWS_MAX);
CHECK(row_label(rows, n, "蓝牙状态未知") >= 0, "未知态 → 行内含「蓝牙状态未知」");
g_bt_state = 0; /* 真实态为关 */
memset(&c, 0, sizeof c); c.full = 1;
sw = -2;
bt_top_sw(&c, &sw);
CHECK(sw == 0, "真实态关 → top_sw *on=0 (实际=%d)", sw);
n = bt_rows(&c, rows, SUB_ROWS_MAX);
CHECK(row_label(rows, n, "蓝牙状态未知") < 0, "真实态已知 → 无未知占位行");
printf("== P5 M47 点击收敛：定稿 / 回滚 + 可见错误 ==\n");
/* 5a 下发成功且真实态已达成 → 立即定稿，无弹窗，settings/状态栏=真实态 */
g_bt_state = 1; g_onoff_rc = MEOW_OK; g_modal_n = 0; g_bt_en_setting = 0;
memset(&c, 0, sizeof c);
unsigned long long t0 = now_ms();
bt_top_sw_set(&c, 1);
unsigned long long dt = now_ms() - t0;
CHECK(g_modal_n == 0, "已达成 → 无错误弹窗 (弹窗数=%d)", g_modal_n);
CHECK(g_bt_en_setting == 1, "已达成 → settings 定稿为 1");
CHECK(g_sys.bt_on == 1, "已达成 → 状态栏 g_sys.bt_on=1");
CHECK(dt < BT_TOGGLE_SETTLE_MS, "已达成 → 不必等满超时 (%llums)", dt);
/* 5b 下发失败、真实态仍为开（要求关）→ 回滚到开 + 可见弹窗 */
g_bt_state = 1; g_onoff_rc = MEOW_ERR_NODEV; g_modal_n = 0; g_bt_en_setting = 1;
memset(&c, 0, sizeof c);
bt_top_sw_set(&c, 0);
CHECK(g_modal_n == 1, "下发失败 → 有可见错误弹窗");
CHECK(g_bt_en_setting == 1, "下发失败 → settings 回滚为真实态 1 (实际=%d)", g_bt_en_setting);
CHECK(g_sys.bt_on == 1, "下发失败 → 状态栏仍为真实态 1");
/* 5c 下发成功但真实态不收敛（要求开、真实一直关）→ 等满上限后回滚 + 弹窗 */
g_bt_state = 0; g_onoff_rc = MEOW_OK; g_modal_n = 0; g_bt_en_setting = 1;
memset(&c, 0, sizeof c);
t0 = now_ms();
bt_top_sw_set(&c, 1);
dt = now_ms() - t0;
CHECK(g_modal_n == 1, "超时未收敛 → 有可见错误弹窗（%s）", g_modal_line);
CHECK(g_bt_en_setting == 0, "超时未收敛 → settings 回滚为真实态 0");
CHECK(g_sys.bt_on == 0, "超时未收敛 → 状态栏=真实态 0");
CHECK(dt >= BT_TOGGLE_SETTLE_MS, "确实等满了上限 (%llums)", dt);
/* 5d 真实态未知 → 等满上限后仍是未知 + 弹窗（绝不把未知显示成成功）；
* settings 保留原意图不动（评审 r1 P2-1：写 0 会把「不知道」污染成「确定已关」，
* notif_center/settings_page/app_launcher 都把这个键当显示态/自动拉起依据读）。 */
g_bt_state = -1; g_onoff_rc = MEOW_OK; g_modal_n = 0; g_bt_en_setting = 1;
memset(&c, 0, sizeof c);
bt_top_sw_set(&c, 1);
CHECK(g_modal_n == 1 && strstr(g_modal_line, "无法确认") != NULL,
"未知 → 弹窗明说无法确认 (%s)", g_modal_line);
CHECK(c.bt_on == -1, "未知 → 定稿态仍为 -1 (实际=%d)", c.bt_on);
CHECK(g_bt_en_setting == 1, "未知 → settings 保留原意图 1，不被改写 (实际=%d)", g_bt_en_setting);
printf("== P6 M47 收敛矩阵（真实态 × 下发结果 × 探测 × 超时）==\n");
{
static const struct {
int last, want, ok, probe, to; /* 输入 */
int disp, pend, rb, err; /* 期望输出 */
const char *what;
} m[] = {
{ 1, 1, 1, 1, 0, 1, 0, 0, 0, "真开·下发成功·探测开" },
{ 1, 0, 1, 0, 0, 0, 0, 0, 0, "真开·下发成功·探测关" },
{ 1, 0, 1, 1, 1, 1, 0, 1, 1, "真开·下发成功·未收敛(超时)" },
{ 1, 0, 0, 1, 0, 1, 0, 1, 1, "真开·下发失败·探测仍开" },
{ 1, 0, 0, -1, 0, -1, 0, 1, 1, "真开·下发失败·探测未知 → 未知(不顶替)" },
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, "真开·下发失败但探测已关（不误报）" },
{ 0, 1, 1, 1, 0, 1, 0, 0, 0, "真关·下发成功·探测开" },
{ 0, 1, 1, 0, 1, 0, 0, 1, 1, "真关·下发成功·未收敛(超时)" },
{ 0, 1, 0, 0, 0, 0, 0, 1, 1, "真关·下发失败·仍关" },
{ 1, 0, 1, -1, 0, -1, 1, 1, 0, "真开·下发成功·探测未知（继续等）" },
{ 1, 0, 1, -1, 1, -1, 0, 1, 1, "真开·下发成功·探测未知(超时)→未知，不用 last_real 顶替" },
{-1, 1, 1, -1, 1, -1, 0, 1, 1, "未知·下发成功·探测仍未知(超时)" },
{-1, 1, 1, -1, 0, -1, 1, 1, 0, "未知·下发成功·探测仍未知（继续等）" },
};
for (size_t i = 0; i < sizeof m / sizeof m[0]; i++) {
int d = meow_toggle_display(m[i].want, m[i].last, m[i].ok, m[i].probe, m[i].to);
int p = meow_toggle_pending(m[i].want, m[i].last, m[i].ok, m[i].probe, m[i].to);
int r = meow_toggle_rollback(m[i].want, m[i].last, m[i].ok, m[i].probe, m[i].to);
int e = meow_toggle_error(m[i].want, m[i].last, m[i].ok, m[i].probe, m[i].to);
CHECK(d == m[i].disp && p == m[i].pend && r == m[i].rb && e == m[i].err,
"%s → disp=%d pend=%d rb=%d err=%d (期望 %d/%d/%d/%d)",
m[i].what, d, p, r, e, m[i].disp, m[i].pend, m[i].rb, m[i].err);
}
}
printf(g_fail ? "\nRESULT: %d FAIL(S)\n" : "\nRESULT: ALL PASS\n", g_fail);
return g_fail;
}
patch_v2/meow_launcherd/test_netmgr_ipc.c
+78 -3
View File
@@ -40,8 +40,47 @@ int net_bt_paired(meow_net_t *out, int max) { (void)out; (void)max; return 0; }
void s_net_toggle_wifi(int on) { (void)on; }
void s_net_toggle_bt(int on) { (void)on; }
void net_wifi_scan_trigger(void) {}
int net_bt_connected(meow_net_t *out, int max) { (void)out; (void)max; return 0; }
int net_bt_scan(meow_net_t *out, int max) { (void)out; (void)max; return 0; }
void net_bt_scan_trigger(void) {}
/* UI 桩：wifi_connecting_banner 走 SDK 绘制函数；宿主无 fb，空实现即可（不验证像素）。 */
const meow_ui_theme_t *s_ui_theme(void) { static meow_ui_theme_t th; return &th; }
int meow_ui_width(void) { return 480; }
void meow_ui_fill_rect(int x, int y, int w, int h, uint32_t color)
{ (void)x; (void)y; (void)w; (void)h; (void)color; }
void meow_ui_text_center(int cx, int y, const char *utf8, int size, uint32_t color)
{ (void)cx; (void)y; (void)utf8; (void)size; (void)color; }
int meow_ui_text_height(int size) { return size; }
void meow_dirty_full(void) {}
void meow_ui_flush(void) {}
char *popen_read_tmo(int tmo_ms, const char *cmd)
{ (void)tmo_ms; (void)cmd; return strdup("0\n"); } /* 模拟 wpa_cli add_network 返回 id=0 */
{
(void)tmo_ms;
/* 直连回退（不可达分支）会跑 wpa_cli 剧本：list_networks/add_network/status/save_config。
* 桩按子命令给近似真机的应答——旧桩统一返回 "0\n"，会让 nm_direct_connect_ex 等满 10s
* 再报 MEOW_ERR_NODEV（该断言因此长期失败；M47 顺手把桩修成可收敛）。 */
if (strstr(cmd, " status")) return strdup("wpa_state=COMPLETED\nip_address=192.168.1.5\nssid=Home2G\n");
if (strstr(cmd, "list_networks")) return strdup("network id / ssid / bssid / flags\n0\tHome2G\t00:11:22:33:44:01\t[WPA-PSK-CCMP]\n");
return strdup("OK\n");
}
/* ---------- M47：net.c 三态直连探测桩（daemon 不可达时 nm_*_power_state 落到这里） ---------- */
int nm_bt_power_state(void); /* netmgr_ipc.c（头文件不在本单改动范围） */
static int g_bt_probe = -1, g_wifi_probe = -1;
int net_bt_power_probe(void) { return g_bt_probe; }
int net_wifi_power_probe(void) { return g_wifi_probe; }
/* M47：开关收敛判定纯函数的实现放在 bt_page.c，矩阵测试在 test_bt_page.c；本测试只验
* nm_*_power_state 的解析/回退与 wifi_rows 的未知态渲染，故这里给可链接的最小桩。 */
int meow_toggle_display(int intent, int last, int ok, int probe, int to)
{ (void)intent; (void)ok; (void)to; return (probe >= 0) ? probe : last; }
int meow_toggle_pending(int intent, int last, int ok, int probe, int to)
{ (void)intent; (void)last; (void)ok; (void)probe; (void)to; return 0; }
int meow_toggle_rollback(int intent, int last, int ok, int probe, int to)
{ (void)intent; (void)last; (void)ok; (void)probe; (void)to; return 0; }
int meow_toggle_error(int intent, int last, int ok, int probe, int to)
{ (void)intent; (void)last; (void)ok; (void)probe; (void)to; return 0; }
/* ---------- launcher/UI/IME 桩（wifi_page.c 链接所需；测试不触碰这些路径） ---------- */
static unsigned long long g_test_ms = 0;
@@ -175,7 +214,9 @@ static int row_has_label(const sub_row_t *rows, int n, const char *needle)
int main(void)
{
char sock[110];
snprintf(sock, sizeof sock, "/tmp/meow_net_test_%d.sock", (int)getpid());
/* 宿主 /tmp 可能不可写（Android 上 /tmp 属 shell）：优先 TMPDIR。 */
snprintf(sock, sizeof sock, "%s/meow_net_test_%d.sock",
getenv("TMPDIR") ? getenv("TMPDIR") : "/tmp", (int)getpid());
fake_net_t f;
memset(&f, 0, sizeof f);
@@ -236,7 +277,26 @@ int main(void)
assert(strstr(err, "add_network") && "connect 失败带回原因");
printf("[D] connect 失败: rc=%d err=%s PASS\n", rc, err);
/* ---- ③ 降级占位：MEOW_NET_SOCK 指向不存在路径 ----
/* ---- ③ M47：开关真实态三态查询（daemon 权威解析） ---- */
{
f.bt_status_text = "bt available=1 powered=1 address=00:1A:7D:DA:71:13 paired=2 connected=0";
assert(nm_bt_power_state() == 1 && "bt status powered=1 → 1（开）");
f.bt_status_text = "bt available=1 powered=0 address=00:1A:7D:DA:71:13 paired=2 connected=0";
assert(nm_bt_power_state() == 0 && "bt status powered=0 → 0（关）");
f.bt_status_text = "bt available=0 powered=0 address=- paired=-1 connected=-1";
assert(nm_bt_power_state() == 0 && "无控制器(available=0) → 0");
f.bt_status_text = "bt available=1 address=00:1A:7D:DA:71:13 paired=-1 connected=-1";
assert(nm_bt_power_state() == -1 && "缺 powered 字段 → -1（未知，不猜 0）");
g_wifi_probe = -1;
assert(nm_wifi_power_state() == -1 && "wifi 探测失败 → -1（不再默认已开）");
g_wifi_probe = 1;
assert(nm_wifi_power_state() == 1 && "wifi 探测开 → 1");
g_wifi_probe = 0;
assert(nm_wifi_power_state() == 0 && "wifi 探测关 → 0");
printf("[F] nm_bt_power_state/nm_wifi_power_state 三态解析 PASS\n");
}
/* ---- ④ 降级占位：MEOW_NET_SOCK 指向不存在路径 ----
* 先发一次 netmgr_wifi（内部强制重连，失败 → 置可达缓存=0），再断言 netmgr_ok()。 */
setenv("MEOW_NET_SOCK", "/tmp/meow_net_nonexistent_zz.sock", 1);
assert(netmgr_wifi("status", NULL, err, sizeof err) == NETMGR_UNREACH && "netmgr_wifi=NETMGR_UNREACH");
@@ -254,6 +314,21 @@ int main(void)
printf("[E] 降级: netmgr_ok=0, UNREACH, 回退不崩, 占位渲染 PASS\n");
}
/* ---- ⑤ M47：daemon 不可达时真实态回退直连探测；探测失败=未知（不当已关/已开） ---- */
g_bt_probe = -1;
assert(nm_bt_power_state() == -1 && "BT daemon 不可达 + 直连探测失败 → -1");
g_bt_probe = 0;
assert(nm_bt_power_state() == 0 && "BT daemon 不可达 + 直连探测关 → 0");
g_wifi_probe = -1;
assert(nm_wifi_power_state() == -1 && "WiFi 探测失败 → -1");
{
wifi_ctx_t c; memset(&c, 0, sizeof c);
sub_row_t rows[SUB_ROWS_MAX];
int rn = wifi_rows(&c, rows, SUB_ROWS_MAX);
assert(row_has_label(rows, rn, "WiFi 开关状态未知") && "未知态 → 行内第三态占位");
printf("[G] 不可达回退三态: BT/WiFi 失败=未知, 行内第三态 PASS\n");
}
printf("ALL PASS\n");
unlink(sock);
return 0;
patch_v2/meow_launcherd/wifi_page.c
+88 -12
View File
@@ -11,6 +11,11 @@
* 【M6.0 迁移】全部查询/操作走 netmgr IPC（netmgr_ipc.c 的 nm_* 封装），netmgrd 是 WiFi 权威；
* netmgrd 不可达（NETMGR_UNREACH）→ 自动回退 net.c 直连 wpa_cli（双轨保功能），页面显示降级占位
* 「网络管理服务未运行（直连模式）」。
*
* 【M47 开关可信化】顶栏开关显示态只来自真实态三态查询 nm_wifi_power_state()（rfkill wlan
* soft/hard，回退 wlan0 IFF_UP；探测失败=未知），**读不到不再默认「已开」**；settings 的
* network.wifi_enabled 只承载用户意图。点击先出示「正在开启/关闭…（等待确认）」，下发 → 有界
* 轮询真实态 → 真实态定稿；失败/超时回滚并弹窗（不许乐观显示成功）。
*/
#include "meow_launcher_internal.h"
@@ -27,32 +32,96 @@ typedef struct {
int saved_n, scan_n;
char ssid[64];
int connected; /* nm_wifi_connected()（IPC>直连回退 wlan_connected） */
int wifi_on; /* network.wifi_enabled */
int sw_state; /* 真实射频态三态：-1 未知 / 0 关 / 1 开（M47） */
unsigned long long sw_ts; /* 上面这次查询的时刻（缓存去重） */
long last_scan_ms; /* 扫描触发节流 */
} wifi_ctx_t;
/* M47：开关收敛参数（宿主测试可预先定义改小）。WiFi 走 wifi_up.sh（起 wpa_supplicant +
* 等关联/DHCP），比 BT 慢，所以上限 5s——且从**点击时刻**起算（含下发耗时，评审 r1 P2-3）。
* 快路径（rfkill 写入在 netmgrd 内是毫秒级）5s 内约 20 次探测；慢路径（netmgrd 卡住 →
* on/off 读超时 1.5s → 直连 wifi_up.sh 自身后台化）下探测只剩 1~2 次，此时只能确认
* 「探测超时」，不能宣称「射频无响应」——弹窗文案按此区分。
* 250ms 只是快路径的轮询间隔，不 20ms 级忙轮询。 */
#ifndef WF_TOGGLE_SETTLE_MS
#define WF_TOGGLE_SETTLE_MS 5000
#endif
#ifndef WF_TOGGLE_POLL_MS
#define WF_TOGGLE_POLL_MS 250
#endif
#define WF_STATE_TTL_MS 800
/* 顶栏开关当前值 */
/* 真实态查询（带缓存）。定义见 netmgr_ipc.c：netmgrd 不报射频态，故取 rfkill/wlan0。 */
extern int nm_wifi_power_state(void);
/* 收敛判定纯函数，实现见 bt_page.c（两个页面共用一套；矩阵测试在 test_bt_page.c） */
extern int meow_toggle_display(int intent, int last_real, int dispatch_ok, int probe, int timed_out);
extern int meow_toggle_pending(int intent, int last_real, int dispatch_ok, int probe, int timed_out);
extern int meow_toggle_rollback(int intent, int last_real, int dispatch_ok, int probe, int timed_out);
extern int meow_toggle_error(int intent, int last_real, int dispatch_ok, int probe, int timed_out);
static int wifi_state_now(wifi_ctx_t *c, int force)
{
unsigned long long t = now_ms();
if (!force && c->sw_ts && t - c->sw_ts < WF_STATE_TTL_MS) return c->sw_state;
c->sw_state = nm_wifi_power_state();
c->sw_ts = t;
return c->sw_state;
}
/* 顶栏开关当前值：只报真实态（-1=未知 → subpage 画「?」）。绝不再「读不到就默认 1」。 */
static int wifi_top_sw(void *ctx, int *on)
{
(void)ctx;
int v = 1;
if (meow_settings_get_bool("network.wifi_enabled", &v) != 0) v = 1;
*on = v;
wifi_ctx_t *c = ctx;
*on = wifi_state_now(c, 0);
return 1;
}
/* 顶栏开关切换：写设置 + 开/关网卡（netmgr on/off，回退直连）+ 触发重扫 + 同步状态栏 */
/* 顶栏开关切换：落盘意图 → 开/关网卡（netmgr on/off，回退直连）→ 有界等待真实态收敛 →
* 真实态定稿/回滚 + 可见错误提示。 */
static void wifi_top_sw_set(void *ctx, int on)
{
wifi_ctx_t *c = ctx;
meow_settings_set_bool("network.wifi_enabled", on);
nm_wifi_toggle(on);
g_sys.wifi_on = on;
paint_sb_right(); /* 状态栏 WiFi 图标随开关即时刷新 */
unsigned long long t_click = now_ms(); /* 上限从点击起算（含下发耗时，见参数注释） */
int want = on ? 1 : 0;
int last_real = wifi_state_now(c, 0);
meow_settings_set_bool("network.wifi_enabled", want); /* 意图持久化 */
meow_settings_save();
if (on) { nm_wifi_scan_trigger(); c->last_scan_ms = now_ms(); }
int dispatch_ok = (nm_wifi_toggle(want) == MEOW_OK);
unsigned long long deadline = t_click + WF_TOGGLE_SETTLE_MS;
int probe = wifi_state_now(c, 1), timed_out = 0;
while (meow_toggle_pending(want, last_real, dispatch_ok, probe, timed_out)) {
if (now_ms() >= deadline) { timed_out = 1; break; }
usleep(WF_TOGGLE_POLL_MS * 1000);
probe = wifi_state_now(c, 1);
}
int disp = meow_toggle_display(want, last_real, dispatch_ok, probe, timed_out);
int rb = meow_toggle_rollback(want, last_real, dispatch_ok, probe, timed_out);
int err = meow_toggle_error(want, last_real, dispatch_ok, probe, timed_out);
unsigned long long elapsed = now_ms() - t_click;
c->sw_state = disp; c->sw_ts = now_ms();
/* 只在拿到真实态时改写 settings；disp == -1（探测未知）保留原意图不动——该键被
* notif_center/settings_page 当显示态读，写 0 会把「不知道」污染成「确定已关」（P2-1）。 */
if (disp >= 0) {
meow_settings_set_bool("network.wifi_enabled", disp == 1);
meow_settings_save();
}
if (disp >= 0) g_sys.wifi_on = disp;
paint_sb_right(); /* 状态栏 WiFi 图标随「已确认」状态刷新 */
if (disp == 1) { nm_wifi_scan_trigger(); c->last_scan_ms = now_ms(); }
logmsg("wifi_page: toggle want=%d ok=%d probe=%d to=%d disp=%d rollback=%d err=%d elapsed=%llums",
want, dispatch_ok, probe, timed_out, disp, rb, err, elapsed);
if (err) {
char line[128];
const char *txt[1]; txt[0] = line;
if (disp < 0)
snprintf(line, sizeof line, "无法确认当前状态（上次已知：%s）",
last_real < 0 ? "未知" : (last_real ? "开启" : "关闭"));
else
snprintf(line, sizeof line, "切换未生效：当前仍为%s", disp ? "开启" : "关闭");
s_dd_modal("WiFi", txt, 1, -1);
}
}
@@ -72,6 +141,7 @@ static void wifi_scan(void *ctx)
static int wifi_rows(void *ctx, sub_row_t *rbuf, int max)
{
wifi_ctx_t *c = ctx;
c->sw_state = wifi_state_now(c, 0); /* 真实射频态（三态）；未知时下面显式说明 */
c->connected = nm_wifi_connected();
if (c->connected) {
nm_wifi_ssid(c->ssid, sizeof c->ssid);
@@ -90,6 +160,12 @@ static int wifi_rows(void *ctx, sub_row_t *rbuf, int max)
rbuf[n].kind = SUB_HDR; rbuf[n].label = "网络管理服务未运行（直连模式）";
rbuf[n].sub = NULL; rbuf[n].on = 0; rbuf[n].act = 0; n++;
}
/* 第三态显式呈现（M47）：射频态未知 ≠ 已关；顶栏开关同时画「?」，这里补文字说明。 */
if (c->sw_state < 0 && n < max) {
rbuf[n].kind = SUB_ROW; rbuf[n].label = "WiFi 开关状态未知";
rbuf[n].sub = "无法读取射频状态（rfkill/网卡无响应）";
rbuf[n].on = 0; rbuf[n].act = -2; n++;
}
/* 当前连接 */
if (n < max) { rbuf[n].kind = SUB_HDR; rbuf[n].label = "当前连接"; rbuf[n].sub = NULL; rbuf[n].on = 0; rbuf[n].act = 0; n++; }
if (n < max) {