Browse Source
standby.h/c: duty-cycle ACTIVE/SLEEP, standby_wait() будит в burst сразу, в SLEEP — до следующего burst; notify_network_activity для раннего пробуждения. Интеграция (по флагу UTUN_HAVE_STANDBY, десктоп без изменений): - conn_mgr: bg_ping/candidate_ping в SLEEP defer через standby_wait - route_connectivity: probe_node откладывается (PROBE_STATUS_DEFERRED) - topo_group_connect: пауза между попытками — активный режим 1с, фон standby_wait - jni_bridge/ConfigProvider/NetworkActivityMonitor: set_active + сетевая активность - chat_setting: standby_active_sec/sleep_sec/min_sleep_sec + юнит-тест test_standby (31 проверок)topo_upd
evgeny
2 months ago
26 changed files with 921 additions and 14 deletions
@ -0,0 +1,48 @@
|
||||
package com.utun.chat.data |
||||
|
||||
import android.content.Context |
||||
import android.net.ConnectivityManager |
||||
import android.os.Build |
||||
import com.utun.chat.ChatApplication |
||||
|
||||
/** |
||||
* Слушатель внешней сетевой активности (ConnectivityManager.OnNetworkActiveListener). |
||||
* |
||||
* Пробуждает standby-ядро досрочно: когда в фазе SLEEP прошёл min_sleep, |
||||
* приход сетевой активности запускает следующий активный цикл раньше. |
||||
* |
||||
* В колбэке не делаем тяжёлую работу — только дёшевый JNI-вызов |
||||
* NativeLib.notifyNetworkActive(), который постит событие на uasync-поток. |
||||
*/ |
||||
object NetworkActivityMonitor { |
||||
private var started = false |
||||
|
||||
private val listener = ConnectivityManager.OnNetworkActiveListener { |
||||
NativeLib.notifyNetworkActive() |
||||
} |
||||
|
||||
fun start() { |
||||
if (started) return |
||||
/* addDefaultNetworkActiveListener доступен с API 28 (P) */ |
||||
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) return |
||||
val ctx = ChatApplication.instance.applicationContext |
||||
val cm = ctx.getSystemService(ConnectivityManager::class.java) ?: return |
||||
cm.addDefaultNetworkActiveListener(listener) |
||||
started = true |
||||
LogManager.addLog("INFO", "NET", "network activity listener started") |
||||
/* Если сеть уже активна в момент запуска — сразу уведомляем */ |
||||
if (cm.isDefaultNetworkActive) { |
||||
NativeLib.notifyNetworkActive() |
||||
} |
||||
} |
||||
|
||||
fun stop() { |
||||
if (!started) return |
||||
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) return |
||||
val ctx = ChatApplication.instance.applicationContext |
||||
val cm = ctx.getSystemService(ConnectivityManager::class.java) ?: return |
||||
cm.removeDefaultNetworkActiveListener(listener) |
||||
started = false |
||||
LogManager.addLog("INFO", "NET", "network activity listener stopped") |
||||
} |
||||
} |
||||
@ -0,0 +1,386 @@
|
||||
/*
|
||||
* standby.c — режим standby с duty-cycle (активный/неактивный интервалы) |
||||
* |
||||
* Синглтон (одна instance на процесс — как instance_lite.c). |
||||
* Таймеры только через uasync. Интервалы читаются лениво из chat_setting, |
||||
* поэтому их изменение через GUI применяется на границе следующей фазы. |
||||
* |
||||
* Duty-cycle: |
||||
* standby включён → фаза ACTIVE на standby_active_sec, затем SLEEP на |
||||
* standby_sleep_sec, и так по кругу, пока standby не выключат. |
||||
* |
||||
* Досрочное пробуждение: |
||||
* в фазе SLEEP первые standby_min_sleep_sec секунд спим безусловно; |
||||
* после них standby_notify_network_activity() (внешняя сетевая активность) |
||||
* пробуждает досрочно — следующий цикл как обычно. |
||||
* |
||||
* Список ожидающих (standby_wait) — двусвязный список, элементы из memory_pool. |
||||
* При выходе из standby (или досрочном пробуждении) все wait-таймеры |
||||
* отменяются, колбэки вызываются сразу. |
||||
*/ |
||||
#include "standby.h" |
||||
#include "chat_setting.h" |
||||
#include "utun_instance.h" |
||||
#include "debug_config.h" |
||||
#include "memory_pool.h" |
||||
|
||||
#define STANDBY_TB_PER_SEC 10000 /* timebase = 0.1ms → 1 сек = 10000 TB */ |
||||
|
||||
#define PHASE_ACTIVE 0 |
||||
#define PHASE_SLEEP 1 |
||||
|
||||
struct standby_wait_entry { |
||||
struct standby_wait_entry* prev; |
||||
struct standby_wait_entry* next; |
||||
void* timer_id; /* handle uasync_set_timeout */ |
||||
void (*cb)(void* arg); |
||||
void* arg; |
||||
}; |
||||
|
||||
static struct UASYNC* g_ua = NULL; |
||||
static int g_enabled = 0; |
||||
static int g_phase = PHASE_ACTIVE; |
||||
static uint64_t g_phase_start_tb = 0; /* начало текущей фазы */ |
||||
static uint64_t g_phase_end_tb = 0; /* дедлайн текущей фазы */ |
||||
static uint64_t g_min_sleep_end_tb = 0; /* до этой точки спим безусловно */ |
||||
static void* g_phase_timer = NULL; |
||||
static void (*g_switch_cb)(int enabled, void* arg) = NULL; |
||||
static void* g_switch_arg = NULL; |
||||
|
||||
static struct memory_pool* g_wait_pool = NULL; |
||||
static struct standby_wait_entry* g_wait_head = NULL; |
||||
static struct standby_wait_entry* g_wait_tail = NULL; |
||||
|
||||
/* счётчики для диагностики */ |
||||
static uint32_t g_cnt_wakes_timer = 0; |
||||
static uint32_t g_cnt_wakes_early = 0; |
||||
static uint32_t g_cnt_sleeps = 0; |
||||
static uint32_t g_cnt_net_events = 0; |
||||
static uint32_t g_cnt_net_ignored = 0; |
||||
|
||||
static int standby_active_sec(void) { |
||||
return chat_setting_get_int("standby_active_sec", 2); |
||||
} |
||||
|
||||
static int standby_sleep_sec(void) { |
||||
return chat_setting_get_int("standby_sleep_sec", 60); |
||||
} |
||||
|
||||
static int standby_min_sleep_sec(void) { |
||||
int m = chat_setting_get_int("standby_min_sleep_sec", 15); |
||||
if (m < 0) m = 0; |
||||
int s = standby_sleep_sec(); |
||||
if (m > s) m = s; |
||||
return m; |
||||
} |
||||
|
||||
/* override интервалов (мс) для тестов: 0 = использовать chat_setting */ |
||||
static int g_override = 0; |
||||
static int g_active_ms = 0; |
||||
static int g_sleep_ms = 0; |
||||
static int g_min_sleep_ms = 0; |
||||
|
||||
static int standby_active_tb(void) { |
||||
return g_override ? g_active_ms * 10 : standby_active_sec() * STANDBY_TB_PER_SEC; |
||||
} |
||||
|
||||
static int standby_sleep_tb(void) { |
||||
return g_override ? g_sleep_ms * 10 : standby_sleep_sec() * STANDBY_TB_PER_SEC; |
||||
} |
||||
|
||||
static int standby_min_sleep_tb(void) { |
||||
int m = g_override ? g_min_sleep_ms * 10 : standby_min_sleep_sec() * STANDBY_TB_PER_SEC; |
||||
if (m < 0) m = 0; |
||||
int s = standby_sleep_tb(); |
||||
if (m > s) m = s; |
||||
return m; |
||||
} |
||||
|
||||
/* ── фазовый таймер ── */ |
||||
|
||||
static void standby_phase_timer_cb(void* arg); |
||||
|
||||
static void standby_arm_phase(void) { |
||||
int dur_tb = (g_phase == PHASE_ACTIVE) ? standby_active_tb() : standby_sleep_tb(); |
||||
g_phase_start_tb = get_time_tb(); |
||||
g_phase_end_tb = g_phase_start_tb + (uint64_t)dur_tb; |
||||
g_min_sleep_end_tb = (g_phase == PHASE_SLEEP) |
||||
? g_phase_start_tb + (uint64_t)standby_min_sleep_tb() |
||||
: 0; |
||||
g_phase_timer = uasync_set_timeout(g_ua, dur_tb, NULL, standby_phase_timer_cb, "standby_phase"); |
||||
if (!g_phase_timer) { |
||||
DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "standby: failed to arm phase timer"); |
||||
} |
||||
} |
||||
|
||||
static void standby_phase_timer_cb(void* arg) { |
||||
(void)arg; |
||||
g_phase_timer = NULL; |
||||
if (!g_enabled) return; |
||||
uint64_t elapsed = get_time_tb() - g_phase_start_tb; |
||||
g_phase = (g_phase == PHASE_ACTIVE) ? PHASE_SLEEP : PHASE_ACTIVE; |
||||
if (g_phase == PHASE_SLEEP) { |
||||
g_cnt_sleeps++; |
||||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, |
||||
"standby: SLEEP (active done in %d.%ds, sleep=%dms min_sleep=%dms)", |
||||
(int)(elapsed / STANDBY_TB_PER_SEC), (int)((elapsed % STANDBY_TB_PER_SEC) / 1000), |
||||
standby_sleep_tb() / 10, standby_min_sleep_tb() / 10); |
||||
} else { |
||||
g_cnt_wakes_timer++; |
||||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "standby: WAKE (timer), slept %d.%ds", |
||||
(int)(elapsed / STANDBY_TB_PER_SEC), (int)((elapsed % STANDBY_TB_PER_SEC) / 1000)); |
||||
} |
||||
standby_arm_phase(); |
||||
} |
||||
|
||||
/* ── список ожидающих ── */ |
||||
|
||||
static struct standby_wait_entry* wait_entry_alloc(void) { |
||||
if (!g_wait_pool) { |
||||
g_wait_pool = memory_pool_init(sizeof(struct standby_wait_entry), "standby_pool"); |
||||
if (!g_wait_pool) return NULL; |
||||
} |
||||
return (struct standby_wait_entry*)memory_pool_alloc(g_wait_pool); |
||||
} |
||||
|
||||
static void wait_entry_free(struct standby_wait_entry* e) { |
||||
memory_pool_free(g_wait_pool, e); |
||||
} |
||||
|
||||
static void wait_list_remove(struct standby_wait_entry* e) { |
||||
if (e->prev) e->prev->next = e->next; else g_wait_head = e->next; |
||||
if (e->next) e->next->prev = e->prev; else g_wait_tail = e->prev; |
||||
e->prev = e->next = NULL; |
||||
} |
||||
|
||||
static void wait_list_push(struct standby_wait_entry* e) { |
||||
e->prev = g_wait_tail; |
||||
e->next = NULL; |
||||
if (g_wait_tail) g_wait_tail->next = e; else g_wait_head = e; |
||||
g_wait_tail = e; |
||||
} |
||||
|
||||
/* Отменяет все wait-таймеры и вызывает их колбэки немедленно.
|
||||
* Сначала отцепляем весь список — новые регистрации в колбэках |
||||
* (standby_wait) попадут в свежий список и не будут задеты этим проходом. */ |
||||
static void standby_wake_all_waiters(void) { |
||||
struct standby_wait_entry* list = g_wait_head; |
||||
g_wait_head = g_wait_tail = NULL; |
||||
while (list) { |
||||
struct standby_wait_entry* e = list; |
||||
list = e->next; |
||||
e->prev = e->next = NULL; |
||||
if (e->timer_id) { |
||||
uasync_cancel_timeout(g_ua, e->timer_id); |
||||
e->timer_id = NULL; |
||||
} |
||||
void (*cb)(void*) = e->cb; |
||||
void* arg = e->arg; |
||||
wait_entry_free(e); |
||||
cb(arg); |
||||
} |
||||
} |
||||
|
||||
static void standby_wait_timer_cb(void* arg) { |
||||
struct standby_wait_entry* e = (struct standby_wait_entry*)arg; |
||||
e->timer_id = NULL; |
||||
wait_list_remove(e); |
||||
void (*cb)(void*) = e->cb; |
||||
void* user_arg = e->arg; |
||||
wait_entry_free(e); |
||||
cb(user_arg); |
||||
} |
||||
|
||||
/* ── публичный API ── */ |
||||
|
||||
void standby_init(struct UASYNC* ua) { |
||||
g_ua = ua; |
||||
g_enabled = 0; |
||||
g_phase = PHASE_ACTIVE; |
||||
g_phase_timer = NULL; |
||||
g_cnt_wakes_timer = g_cnt_wakes_early = 0; |
||||
g_cnt_sleeps = g_cnt_net_events = g_cnt_net_ignored = 0; |
||||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "standby: init (active=%dms sleep=%dms min_sleep=%dms)", |
||||
standby_active_tb() / 10, standby_sleep_tb() / 10, standby_min_sleep_tb() / 10); |
||||
} |
||||
|
||||
void standby_deinit(void) { |
||||
if (!g_enabled && !g_phase_timer && !g_wait_head && !g_wait_pool) { |
||||
g_ua = NULL; |
||||
return; |
||||
} |
||||
if (g_phase_timer && g_ua) { |
||||
uasync_cancel_timeout(g_ua, g_phase_timer); |
||||
g_phase_timer = NULL; |
||||
} |
||||
while (g_wait_head) { |
||||
struct standby_wait_entry* e = g_wait_head; |
||||
if (e->timer_id && g_ua) uasync_cancel_timeout(g_ua, e->timer_id); |
||||
wait_list_remove(e); |
||||
wait_entry_free(e); |
||||
} |
||||
if (g_wait_pool) { |
||||
memory_pool_destroy(g_wait_pool); |
||||
g_wait_pool = NULL; |
||||
} |
||||
g_enabled = 0; |
||||
g_ua = NULL; |
||||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "standby: deinit (wakes_timer=%u wakes_early=%u sleeps=%u net=%u ignored=%u)", |
||||
g_cnt_wakes_timer, g_cnt_wakes_early, g_cnt_sleeps, g_cnt_net_events, g_cnt_net_ignored); |
||||
} |
||||
|
||||
void standby_set_enabled(struct UTUN_INSTANCE* inst, int enabled) { |
||||
if (!g_ua) { |
||||
DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "standby: set_enabled(%d) but not initialized", enabled); |
||||
return; |
||||
} |
||||
if (g_enabled == enabled) return; |
||||
|
||||
if (enabled) { |
||||
g_enabled = 1; |
||||
g_phase = PHASE_ACTIVE; |
||||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "standby: ENTER (app background, active=%dms sleep=%dms min_sleep=%dms)", |
||||
standby_active_tb() / 10, standby_sleep_tb() / 10, standby_min_sleep_tb() / 10); |
||||
standby_arm_phase(); |
||||
} else { |
||||
g_enabled = 0; |
||||
if (g_phase_timer) { |
||||
uasync_cancel_timeout(g_ua, g_phase_timer); |
||||
g_phase_timer = NULL; |
||||
} |
||||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "standby: EXIT (app foreground, wakes_timer=%u wakes_early=%u sleeps=%u net=%u ignored=%u)", |
||||
g_cnt_wakes_timer, g_cnt_wakes_early, g_cnt_sleeps, g_cnt_net_events, g_cnt_net_ignored); |
||||
standby_wake_all_waiters(); |
||||
} |
||||
|
||||
if (inst) inst->standby_enabled = (uint8_t)enabled; |
||||
if (g_switch_cb) g_switch_cb(enabled, g_switch_arg); |
||||
} |
||||
|
||||
int standby_is_enabled(void) { |
||||
return g_enabled; |
||||
} |
||||
|
||||
void standby_set_switch_callback(void (*cb)(int enabled, void* arg), void* arg) { |
||||
g_switch_cb = cb; |
||||
g_switch_arg = arg; |
||||
} |
||||
|
||||
int standby_get_sleep_tb(void) { |
||||
if (!g_enabled) return 0; |
||||
if (g_phase == PHASE_ACTIVE) return 0; |
||||
uint64_t now = get_time_tb(); |
||||
if (now >= g_phase_end_tb) return 0; |
||||
return (int)(g_phase_end_tb - now); |
||||
} |
||||
|
||||
int standby_get_active_remaining_tb(void) { |
||||
if (!g_enabled) return 0; |
||||
if (g_phase == PHASE_SLEEP) return 0; |
||||
uint64_t now = get_time_tb(); |
||||
if (now >= g_phase_end_tb) return 0; |
||||
return (int)(g_phase_end_tb - now); |
||||
} |
||||
|
||||
void* standby_wait(void* arg, void (*cb)(void* arg)) { |
||||
if (!cb) return NULL; |
||||
if (!g_ua) { |
||||
DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "standby: wait() but not initialized"); |
||||
return NULL; |
||||
} |
||||
if (!g_enabled) { |
||||
/* standby выключен → будим сразу (отложенно, чтобы не было рекурсии) */ |
||||
uasync_call_soon(g_ua, arg, (timeout_callback_t)cb); |
||||
return NULL; |
||||
} |
||||
|
||||
struct standby_wait_entry* e = wait_entry_alloc(); |
||||
if (!e) { |
||||
DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "standby: wait_entry_alloc failed"); |
||||
cb(arg); |
||||
return NULL; |
||||
} |
||||
e->cb = cb; |
||||
e->arg = arg; |
||||
|
||||
/* время до начала следующего активного интервала:
|
||||
* SLEEP — ждём до конца фазы; ACTIVE — уже бодрствуем, будим сразу. */ |
||||
uint64_t now = get_time_tb(); |
||||
uint64_t tb; |
||||
if (g_phase == PHASE_SLEEP) { |
||||
tb = (now < g_phase_end_tb) ? (g_phase_end_tb - now) : 0; |
||||
} else { |
||||
tb = 0; |
||||
} |
||||
|
||||
e->timer_id = uasync_set_timeout(g_ua, (int)tb, e, standby_wait_timer_cb, "standby_wait"); |
||||
if (!e->timer_id) { |
||||
DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "standby: uasync_set_timeout failed"); |
||||
wait_entry_free(e); |
||||
cb(arg); |
||||
return NULL; |
||||
} |
||||
wait_list_push(e); |
||||
return e; |
||||
} |
||||
|
||||
void standby_wait_cancel(void* handle) { |
||||
if (!handle) return; |
||||
struct standby_wait_entry* e = (struct standby_wait_entry*)handle; |
||||
if (e->timer_id && g_ua) { |
||||
uasync_cancel_timeout(g_ua, e->timer_id); |
||||
e->timer_id = NULL; |
||||
} |
||||
wait_list_remove(e); |
||||
wait_entry_free(e); |
||||
} |
||||
|
||||
/* ── внешняя сетевая активность ── */ |
||||
|
||||
void standby_notify_network_activity(void) { |
||||
g_cnt_net_events++; |
||||
if (!g_enabled) { |
||||
DEBUG_DEBUG(DEBUG_CATEGORY_GENERAL, "standby: network activity ignored (standby off)"); |
||||
return; |
||||
} |
||||
if (g_phase != PHASE_SLEEP) { |
||||
DEBUG_DEBUG(DEBUG_CATEGORY_GENERAL, "standby: network activity ignored (phase=ACTIVE)"); |
||||
return; |
||||
} |
||||
|
||||
uint64_t now = get_time_tb(); |
||||
uint64_t slept = now - g_phase_start_tb; |
||||
if (now < g_min_sleep_end_tb) { |
||||
g_cnt_net_ignored++; |
||||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, |
||||
"standby: network activity caught, min_sleep not elapsed (%d.%ds left)", |
||||
(int)((g_min_sleep_end_tb - now) / STANDBY_TB_PER_SEC), |
||||
(int)(((g_min_sleep_end_tb - now) % STANDBY_TB_PER_SEC) / 1000)); |
||||
return; |
||||
} |
||||
|
||||
g_cnt_wakes_early++; |
||||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, |
||||
"standby: WAKE early (network activity), slept %d.%ds min_sleep=%dms", |
||||
(int)(slept / STANDBY_TB_PER_SEC), (int)((slept % STANDBY_TB_PER_SEC) / 1000), |
||||
standby_min_sleep_tb() / 10); |
||||
|
||||
if (g_phase_timer) { |
||||
uasync_cancel_timeout(g_ua, g_phase_timer); |
||||
g_phase_timer = NULL; |
||||
} |
||||
g_phase = PHASE_ACTIVE; |
||||
standby_arm_phase(); |
||||
standby_wake_all_waiters(); |
||||
} |
||||
|
||||
void standby_set_intervals_ms(int active_ms, int sleep_ms, int min_sleep_ms) { |
||||
if (active_ms <= 0 || sleep_ms <= 0) { |
||||
g_override = 0; |
||||
return; |
||||
} |
||||
g_override = 1; |
||||
g_active_ms = active_ms; |
||||
g_sleep_ms = sleep_ms; |
||||
g_min_sleep_ms = min_sleep_ms < 0 ? 0 : min_sleep_ms; |
||||
} |
||||
@ -0,0 +1,61 @@
|
||||
/*
|
||||
* standby.h — режим standby с duty-cycle (активный/неактивный интервалы) |
||||
* |
||||
* Для chatgui-android: когда приложение в фоне, вместо постоянной работы |
||||
* узел периодически просыпается: ACTIVE (X сек) → SLEEP (Y сек) → ACTIVE ... |
||||
* |
||||
* Потребители периодической работы используют standby_wait(): колбэк |
||||
* срабатывает на старте следующего активного интервала, а при выходе из |
||||
* standby (приложение вернулось в форграунд) — немедленно. |
||||
*/ |
||||
#ifndef STANDBY_H |
||||
#define STANDBY_H |
||||
|
||||
#include "u_async.h" |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
struct UTUN_INSTANCE; |
||||
|
||||
/* Привязать модуль к uasync. Вызывается после каждого uasync_create(). */ |
||||
void standby_init(struct UASYNC* ua); |
||||
|
||||
/* Отмена таймеров и освобождение пула (без вызова колбэков). */ |
||||
void standby_deinit(void); |
||||
|
||||
/* Включить/выключить standby-режим. Логирует вход/выход (GENERAL info)
|
||||
* и вызывает switch-callback. Флаг дублируется в inst->standby_enabled. */ |
||||
void standby_set_enabled(struct UTUN_INSTANCE* inst, int enabled); |
||||
int standby_is_enabled(void); |
||||
|
||||
/* Колбэк, вызываемый при каждом переключении standby-режима. */ |
||||
void standby_set_switch_callback(void (*cb)(int enabled, void* arg), void* arg); |
||||
|
||||
/* Сколько TB спать сейчас (0 = активный интервал или standby выключен). */ |
||||
int standby_get_sleep_tb(void); |
||||
|
||||
/* Сколько TB осталось активного режима (0 = спим или standby выключен). */ |
||||
int standby_get_active_remaining_tb(void); |
||||
|
||||
/* Ждёт до начала следующего активного интервала (как uasync timeout).
|
||||
* При выходе из standby таймер отменяется и cb вызывается немедленно. |
||||
* Возвращает handle для standby_wait_cancel(). */ |
||||
void* standby_wait(void* arg, void (*cb)(void* arg)); |
||||
void standby_wait_cancel(void* handle); |
||||
|
||||
/* Уведомление о внешней сетевой активности (Android ConnectivityManager).
|
||||
* В фазе SLEEP после min_sleep пробуждает досрочно; иначе игнорируется. |
||||
* Вызывается на uasync-потоке. */ |
||||
void standby_notify_network_activity(void); |
||||
|
||||
/* Переопределить интервалы (мс), минуя chat_setting. Для тестов.
|
||||
* active_ms/sleep_ms <= 0 → вернуться к chat_setting. |
||||
* min_sleep_ms может быть 0 (реагировать на сетевую активность сразу). */ |
||||
void standby_set_intervals_ms(int active_ms, int sleep_ms, int min_sleep_ms); |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
#endif /* STANDBY_H */ |
||||
@ -0,0 +1,7 @@
|
||||
cmake_minimum_required(VERSION 3.16) |
||||
|
||||
add_executable(test_standby |
||||
test_standby.c |
||||
) |
||||
|
||||
target_link_libraries(test_standby PRIVATE utun_lite pthread) |
||||
@ -0,0 +1,216 @@
|
||||
/*
|
||||
* test_standby.c — юнит-тест модуля standby (chatgui-android) |
||||
* |
||||
* Покрывает все сценарии: init, ENTER/EXIT, смену фаз ACTIVE↔SLEEP, |
||||
* standby_wait во всех фазах, cancel, сетевую активность (игнор/раннее |
||||
* пробуждение), clamp min_sleep и re-entry в wake_all_waiters. |
||||
* |
||||
* Интервалы задаются через standby_set_intervals_ms() (быстрые: 100-300мс). |
||||
* Время продвигается через uasync_poll(ua, -1) (до ближайшего таймера) |
||||
* и uasync_poll(ua, X) (частичное ожидание). |
||||
*/ |
||||
#include "standby.h" |
||||
#include "debug_config.h" |
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
|
||||
static int g_failures = 0; |
||||
static int g_checks = 0; |
||||
|
||||
#define CHECK(cond, ...) do { \ |
||||
g_checks++; \
|
||||
if (!(cond)) { \
|
||||
g_failures++; \
|
||||
printf(" FAIL: "); printf(__VA_ARGS__); printf("\n"); \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
static struct UASYNC* g_ua = NULL; |
||||
|
||||
/* ── колбэки для standby_wait и switch ── */ |
||||
|
||||
static int g_wait_calls = 0; |
||||
static void wait_cb(void* arg) { |
||||
(void)arg; |
||||
g_wait_calls++; |
||||
} |
||||
|
||||
static int g_switch_calls = 0; |
||||
static int g_switch_last_enabled = -1; |
||||
static void switch_cb(int enabled, void* arg) { |
||||
(void)arg; |
||||
g_switch_calls++; |
||||
g_switch_last_enabled = enabled; |
||||
} |
||||
|
||||
/* re-entry waiter: в колбэке снова регистрирует себя (ровно один раз) */ |
||||
static int g_reentry_calls = 0; |
||||
static void reentry_cb(void* arg) { |
||||
(void)arg; |
||||
g_reentry_calls++; |
||||
if (g_reentry_calls == 1) standby_wait(NULL, reentry_cb); |
||||
} |
||||
|
||||
/* ── хелперы ── */ |
||||
|
||||
static void reset_standby(void) { |
||||
standby_deinit(); |
||||
standby_set_intervals_ms(200, 300, 100); /* active=200ms sleep=300ms min_sleep=100ms */ |
||||
standby_init(g_ua); |
||||
g_wait_calls = 0; |
||||
g_switch_calls = 0; |
||||
g_switch_last_enabled = -1; |
||||
g_reentry_calls = 0; |
||||
standby_set_switch_callback(switch_cb, NULL); |
||||
} |
||||
|
||||
/* продвинуть время до ближайшего таймера (фаза переключится) */ |
||||
static void run_to_next_phase(void) { |
||||
uasync_poll(g_ua, -1); |
||||
} |
||||
|
||||
int main(void) { |
||||
debug_config_init(); |
||||
debug_set_level(DEBUG_LEVEL_INFO); |
||||
|
||||
g_ua = uasync_create(); |
||||
if (!g_ua) { printf("uasync_create failed\n"); return 1; } |
||||
|
||||
printf("=== standby unit test ===\n"); |
||||
|
||||
/* ── 1. init ── */ |
||||
reset_standby(); |
||||
CHECK(standby_is_enabled() == 0, "init: should be disabled"); |
||||
CHECK(standby_get_sleep_tb() == 0, "init: sleep_tb should be 0"); |
||||
CHECK(standby_get_active_remaining_tb() == 0, "init: active_remaining should be 0"); |
||||
|
||||
/* ── 2. ENTER ── */ |
||||
standby_set_enabled(NULL, 1); |
||||
CHECK(standby_is_enabled() == 1, "ENTER: should be enabled"); |
||||
CHECK(standby_get_sleep_tb() == 0, "ENTER: active phase → sleep_tb 0"); |
||||
CHECK(standby_get_active_remaining_tb() > 0, "ENTER: active phase → active_remaining > 0"); |
||||
CHECK(g_switch_calls == 1 && g_switch_last_enabled == 1, "ENTER: switch_cb(1) once"); |
||||
|
||||
/* ── 3. ACTIVE → SLEEP ── */ |
||||
run_to_next_phase(); |
||||
CHECK(standby_get_sleep_tb() > 0, "ACTIVE→SLEEP: sleep_tb > 0"); |
||||
CHECK(standby_get_active_remaining_tb() == 0, "ACTIVE→SLEEP: active_remaining == 0"); |
||||
|
||||
/* ── 4. SLEEP → ACTIVE (по таймеру) ── */ |
||||
run_to_next_phase(); |
||||
CHECK(standby_get_sleep_tb() == 0, "SLEEP→ACTIVE: sleep_tb == 0"); |
||||
CHECK(standby_get_active_remaining_tb() > 0, "SLEEP→ACTIVE: active_remaining > 0"); |
||||
|
||||
/* ── 5. EXIT ── */ |
||||
standby_set_enabled(NULL, 0); |
||||
CHECK(standby_is_enabled() == 0, "EXIT: should be disabled"); |
||||
CHECK(standby_get_sleep_tb() == 0, "EXIT: sleep_tb == 0"); |
||||
CHECK(g_switch_calls == 2 && g_switch_last_enabled == 0, "EXIT: switch_cb(0)"); |
||||
|
||||
/* ── 6. standby_wait при выключенном → сразу ── */ |
||||
reset_standby(); |
||||
standby_wait(NULL, wait_cb); |
||||
uasync_poll(g_ua, 0); /* обработать call_soon */ |
||||
CHECK(g_wait_calls == 1, "wait(disabled): cb fired immediately"); |
||||
|
||||
/* ── 7. standby_wait в ACTIVE → будит сразу (burst, без паузы) ── */ |
||||
reset_standby(); |
||||
standby_set_enabled(NULL, 1); |
||||
standby_wait(NULL, wait_cb); /* ACTIVE → tb=0, immediate */ |
||||
uasync_poll(g_ua, 0); |
||||
CHECK(g_wait_calls == 1, "wait(ACTIVE): fired immediately (burst)"); |
||||
standby_set_enabled(NULL, 0); |
||||
|
||||
/* ── 8. standby_wait в SLEEP → ждёт конца сна ── */ |
||||
reset_standby(); |
||||
standby_set_enabled(NULL, 1); |
||||
run_to_next_phase(); /* → SLEEP */ |
||||
CHECK(standby_get_sleep_tb() > 0, "wait(SLEEP): in sleep"); |
||||
standby_wait(NULL, wait_cb); |
||||
uasync_poll(g_ua, -1); /* конец сна */ |
||||
uasync_poll(g_ua, 0); |
||||
CHECK(g_wait_calls == 1, "wait(SLEEP): fired at sleep end"); |
||||
standby_set_enabled(NULL, 0); |
||||
|
||||
/* ── 9. standby_wait_cancel ── */ |
||||
reset_standby(); |
||||
standby_set_enabled(NULL, 1); |
||||
run_to_next_phase(); /* → SLEEP */ |
||||
void* h = standby_wait(NULL, wait_cb); |
||||
standby_wait_cancel(h); |
||||
uasync_poll(g_ua, -1); /* конец сна */ |
||||
uasync_poll(g_ua, 0); |
||||
CHECK(g_wait_calls == 0, "wait_cancel: cb not called"); |
||||
standby_set_enabled(NULL, 0); |
||||
|
||||
/* ── 10. notify при standby off → игнор ── */ |
||||
reset_standby(); |
||||
standby_notify_network_activity(); |
||||
CHECK(standby_is_enabled() == 0, "notify(off): still disabled"); |
||||
|
||||
/* ── 11. notify в ACTIVE → игнор ── */ |
||||
standby_set_enabled(NULL, 1); |
||||
CHECK(standby_get_active_remaining_tb() > 0, "notify(ACTIVE): in active"); |
||||
standby_notify_network_activity(); |
||||
CHECK(standby_get_active_remaining_tb() > 0, "notify(ACTIVE): still active"); |
||||
standby_set_enabled(NULL, 0); |
||||
|
||||
/* ── 12. notify в SLEEP до min_sleep → игнор ── */ |
||||
reset_standby(); |
||||
standby_set_enabled(NULL, 1); |
||||
run_to_next_phase(); /* → SLEEP */ |
||||
CHECK(standby_get_sleep_tb() > 0, "notify(min_sleep): in sleep"); |
||||
standby_notify_network_activity(); /* сразу — ещё < min_sleep(100ms) */ |
||||
CHECK(standby_get_sleep_tb() > 0, "notify(<min_sleep): still sleeping"); |
||||
|
||||
/* ── 13. notify в SLEEP после min_sleep → раннее пробуждение ── */ |
||||
uasync_poll(g_ua, 2000); /* +200ms → прошло min_sleep(100ms) */ |
||||
standby_notify_network_activity(); |
||||
CHECK(standby_get_sleep_tb() == 0, "notify(>min_sleep): woke → sleep_tb 0"); |
||||
CHECK(standby_get_active_remaining_tb() > 0, "notify(>min_sleep): woke → active_remaining > 0"); |
||||
standby_set_enabled(NULL, 0); |
||||
|
||||
/* ── 14. раннее пробуждение будит waiters ── */ |
||||
reset_standby(); |
||||
standby_set_enabled(NULL, 1); |
||||
run_to_next_phase(); /* → SLEEP */ |
||||
standby_wait(NULL, wait_cb); |
||||
uasync_poll(g_ua, 2000); /* +200ms → min_sleep прошёл */ |
||||
standby_notify_network_activity(); |
||||
uasync_poll(g_ua, 0); |
||||
CHECK(g_wait_calls == 1, "early wake: waiter fired immediately"); |
||||
standby_set_enabled(NULL, 0); |
||||
|
||||
/* ── 15. clamp min_sleep ≥ sleep → notify всегда игнор ── */ |
||||
reset_standby(); |
||||
standby_set_intervals_ms(200, 300, 500); /* min_sleep(500) > sleep(300) → clamp */ |
||||
standby_init(g_ua); |
||||
standby_set_switch_callback(switch_cb, NULL); |
||||
standby_set_enabled(NULL, 1); |
||||
run_to_next_phase(); /* → SLEEP */ |
||||
uasync_poll(g_ua, 2000); /* +200ms */ |
||||
standby_notify_network_activity(); |
||||
CHECK(standby_get_sleep_tb() > 0, "clamp: min_sleep==sleep → notify ignored"); |
||||
standby_set_enabled(NULL, 0); |
||||
|
||||
/* ── 16. re-entry: waiter перерегистрируется, без бесконечного цикла ── */ |
||||
reset_standby(); |
||||
standby_set_enabled(NULL, 1); |
||||
run_to_next_phase(); /* → SLEEP */ |
||||
standby_wait(NULL, reentry_cb); |
||||
uasync_poll(g_ua, 2000); /* +200ms → min_sleep прошёл */ |
||||
standby_notify_network_activity(); /* раннее пробуждение → wake_all_waiters */ |
||||
CHECK(g_reentry_calls == 1, "re-entry: wake fired waiter once (no infinite loop)"); |
||||
CHECK(standby_is_enabled() == 1, "re-entry: still enabled after early wake"); |
||||
standby_set_enabled(NULL, 0); /* EXIT → будит перерегистрированного ещё раз */ |
||||
CHECK(g_reentry_calls == 2, "re-entry: exit fired re-registered waiter once more"); |
||||
|
||||
/* ── итог ── */ |
||||
standby_deinit(); |
||||
uasync_destroy(g_ua, 0); |
||||
|
||||
printf("=== standby unit test: %d checks, %d failures ===\n", g_checks, g_failures); |
||||
if (g_failures == 0) printf("PASS\n"); |
||||
else printf("FAIL\n"); |
||||
return g_failures ? 1 : 0; |
||||
} |
||||
Loading…
Reference in new issue