#include "parent_schedule.h"
|
|
#include "app_task.h"
|
#include "application.h"
|
#include "system.h"
|
|
#include <cJSON.h>
|
#include <esp_log.h>
|
#include <esp_timer.h>
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <strings.h>
|
#include <time.h>
|
|
#define TAG "parent_sched"
|
#define SCHEDULE_PATH MOUNT_POINT "/.parent_schedule.json"
|
#define SCHEDULE_MAX_TASKS 100
|
#define SCHEDULE_ID_MAX 40
|
#define SCHEDULE_APP_MAX 32
|
#define SCHEDULE_PARAMS_MAX 384
|
#define SCHEDULE_TYPE_DAILY 0
|
#define SCHEDULE_TYPE_HOURLY 1
|
#define SCHEDULE_TYPE_INTERVAL 2
|
#define SCHEDULE_END_DEFAULT 0
|
#define SCHEDULE_END_CHAT 1
|
#define SCHEDULE_END_POWER_OFF 2
|
#define SCHEDULE_DUE_WINDOW_SEC 180
|
|
typedef struct {
|
char id[SCHEDULE_ID_MAX];
|
char app_id[SCHEDULE_APP_MAX];
|
char task_id[SCHEDULE_APP_MAX];
|
char params_json[SCHEDULE_PARAMS_MAX];
|
uint8_t enabled;
|
uint8_t type;
|
uint8_t hour;
|
uint8_t min;
|
uint8_t sec;
|
uint8_t weekdays;
|
uint8_t hourly_minute;
|
uint16_t every_minutes;
|
} sched_task_t;
|
|
static sched_task_t s_tasks[SCHEDULE_MAX_TASKS];
|
static int s_task_count = 0;
|
static bool s_loaded = false;
|
|
static char s_next_id[SCHEDULE_ID_MAX];
|
static char s_next_app[SCHEDULE_APP_MAX];
|
static char s_next_task[SCHEDULE_APP_MAX];
|
static char s_next_params[SCHEDULE_PARAMS_MAX];
|
static time_t s_next_unix = 0;
|
static bool s_next_valid = false;
|
|
static bool s_occupying = false;
|
static time_t s_busy_until = 0;
|
static int s_on_complete = SCHEDULE_END_DEFAULT;
|
static bool s_deferred_due = false;
|
static bool s_fire_queued = false;
|
static bool s_wait_lesson_files = false;
|
static bool s_files_poll_queued = false;
|
static time_t s_wait_lesson_files_since = 0;
|
#define CLAIMED_SLOT_MAX 16
|
typedef struct {
|
char id[SCHEDULE_ID_MAX];
|
time_t unix_time;
|
} claimed_slot_t;
|
static claimed_slot_t s_claimed_slots[CLAIMED_SLOT_MAX];
|
static int s_claimed_count = 0;
|
static time_t s_last_started_unix = 0;
|
static char s_pending_app[SCHEDULE_APP_MAX];
|
static char s_pending_task[SCHEDULE_APP_MAX];
|
static char s_pending_params[SCHEDULE_PARAMS_MAX];
|
static bool s_duration_fired = false;
|
static esp_timer_handle_t s_duration_timer = NULL;
|
|
static bool slot_already_claimed(const sched_task_t *task, time_t cand);
|
|
static uint8_t tm_wday_to_repeat_bit(int tm_wday)
|
{
|
switch (tm_wday) {
|
case 1: return ALARM_REPEAT_MON;
|
case 2: return ALARM_REPEAT_TUE;
|
case 3: return ALARM_REPEAT_WED;
|
case 4: return ALARM_REPEAT_THU;
|
case 5: return ALARM_REPEAT_FRI;
|
case 6: return ALARM_REPEAT_SAT;
|
default: return ALARM_REPEAT_SUN;
|
}
|
}
|
|
static bool parse_hhmmss(const char *value, uint8_t *hour, uint8_t *min, uint8_t *sec)
|
{
|
int h = 0, m = 0, s = 0;
|
char tail = 0;
|
if (!value) {
|
return false;
|
}
|
if (sscanf(value, "%2d:%2d:%2d%c", &h, &m, &s, &tail) == 3 ||
|
sscanf(value, "%2d:%2d%c", &h, &m, &tail) == 2) {
|
if (h < 0 || h > 23 || m < 0 || m > 59 || s < 0 || s > 59) {
|
return false;
|
}
|
*hour = (uint8_t)h;
|
*min = (uint8_t)m;
|
*sec = (uint8_t)s;
|
return true;
|
}
|
return false;
|
}
|
|
static uint8_t parse_weekdays(const cJSON *repeat)
|
{
|
uint8_t mask = 0;
|
if (!cJSON_IsArray(repeat) || cJSON_GetArraySize(repeat) == 0) {
|
return ALARM_REPEAT_ALL;
|
}
|
const cJSON *day = NULL;
|
cJSON_ArrayForEach(day, repeat) {
|
int value = cJSON_IsNumber(day) ? day->valueint : 0;
|
switch (value) {
|
case 1: mask |= ALARM_REPEAT_MON; break;
|
case 2: mask |= ALARM_REPEAT_TUE; break;
|
case 3: mask |= ALARM_REPEAT_WED; break;
|
case 4: mask |= ALARM_REPEAT_THU; break;
|
case 5: mask |= ALARM_REPEAT_FRI; break;
|
case 6: mask |= ALARM_REPEAT_SAT; break;
|
case 7: mask |= ALARM_REPEAT_SUN; break;
|
default: break;
|
}
|
}
|
return mask ? mask : ALARM_REPEAT_ALL;
|
}
|
|
static void copy_str(char *dest, size_t dest_size, const char *src)
|
{
|
if (!dest || dest_size == 0) {
|
return;
|
}
|
dest[0] = '\0';
|
if (src && src[0]) {
|
strlcpy(dest, src, dest_size);
|
}
|
}
|
|
static time_t wall_now(struct tm *out)
|
{
|
struct tm now = {};
|
if (!Board_Get_Wall_Clock(&now)) {
|
time_t t = 0;
|
time(&t);
|
localtime_r(&t, &now);
|
}
|
if (out) {
|
*out = now;
|
}
|
now.tm_isdst = -1;
|
return mktime(&now);
|
}
|
|
static int on_complete_from_params(const cJSON *params)
|
{
|
if (!params) {
|
return SCHEDULE_END_DEFAULT;
|
}
|
const cJSON *item = cJSON_GetObjectItem(params, "on_complete");
|
if (cJSON_IsString(item) && item->valuestring) {
|
if (strcmp(item->valuestring, "power_off") == 0) {
|
return SCHEDULE_END_POWER_OFF;
|
}
|
if (strcmp(item->valuestring, "chat") == 0) {
|
return SCHEDULE_END_CHAT;
|
}
|
}
|
const cJSON *power = cJSON_GetObjectItem(params, "power_off_after");
|
if (cJSON_IsTrue(power) || (cJSON_IsNumber(power) && power->valueint != 0)) {
|
return SCHEDULE_END_POWER_OFF;
|
}
|
return SCHEDULE_END_DEFAULT;
|
}
|
|
static int duration_minutes_from_params(const cJSON *params)
|
{
|
if (!params) {
|
return 0;
|
}
|
const cJSON *item = cJSON_GetObjectItem(params, "duration_minutes");
|
if (cJSON_IsNumber(item) && item->valuedouble > 0) {
|
int value = (int)item->valuedouble;
|
if (value > 24 * 60) {
|
value = 24 * 60;
|
}
|
return value;
|
}
|
return 0;
|
}
|
|
static bool parse_one_task(const cJSON *obj, sched_task_t *out)
|
{
|
if (!cJSON_IsObject(obj) || !out) {
|
return false;
|
}
|
memset(out, 0, sizeof(*out));
|
const cJSON *id = cJSON_GetObjectItem(obj, "id");
|
const cJSON *app = cJSON_GetObjectItem(obj, "app_id");
|
const cJSON *task = cJSON_GetObjectItem(obj, "task_id");
|
const cJSON *enabled = cJSON_GetObjectItem(obj, "enabled");
|
const cJSON *params = cJSON_GetObjectItem(obj, "params");
|
const cJSON *schedule = cJSON_GetObjectItem(obj, "schedule");
|
if (!cJSON_IsString(id) || !id->valuestring[0] || !cJSON_IsString(app) || !app->valuestring[0]) {
|
return false;
|
}
|
copy_str(out->id, sizeof(out->id), id->valuestring);
|
copy_str(out->app_id, sizeof(out->app_id), app->valuestring);
|
copy_str(out->task_id, sizeof(out->task_id),
|
(cJSON_IsString(task) && task->valuestring) ? task->valuestring : "");
|
out->enabled = enabled ? !cJSON_IsFalse(enabled) : 1;
|
if (params) {
|
char *printed = cJSON_PrintUnformatted(params);
|
if (printed) {
|
copy_str(out->params_json, sizeof(out->params_json), printed);
|
free(printed);
|
}
|
} else {
|
copy_str(out->params_json, sizeof(out->params_json), "{}");
|
}
|
|
const cJSON *type = schedule ? cJSON_GetObjectItem(schedule, "type") : NULL;
|
const char *type_str = (cJSON_IsString(type) && type->valuestring) ? type->valuestring : "daily";
|
if (strcmp(type_str, "hourly") == 0) {
|
out->type = SCHEDULE_TYPE_HOURLY;
|
const cJSON *minute = cJSON_GetObjectItem(schedule, "minute");
|
int value = cJSON_IsNumber(minute) ? minute->valueint : 0;
|
if (value < 0 || value > 59) {
|
value = 0;
|
}
|
out->hourly_minute = (uint8_t)value;
|
return true;
|
}
|
if (strcmp(type_str, "interval") == 0) {
|
out->type = SCHEDULE_TYPE_INTERVAL;
|
const cJSON *every = cJSON_GetObjectItem(schedule, "every_minutes");
|
int value = cJSON_IsNumber(every) ? every->valueint : 60;
|
if (value < 1) {
|
value = 1;
|
}
|
if (value > 24 * 60) {
|
value = 24 * 60;
|
}
|
out->every_minutes = (uint16_t)value;
|
return true;
|
}
|
out->type = SCHEDULE_TYPE_DAILY;
|
const cJSON *time_value = schedule ? cJSON_GetObjectItem(schedule, "time") : NULL;
|
if (!cJSON_IsString(time_value) ||
|
!parse_hhmmss(time_value->valuestring, &out->hour, &out->min, &out->sec)) {
|
return false;
|
}
|
out->weekdays = parse_weekdays(schedule ? cJSON_GetObjectItem(schedule, "weekdays") : NULL);
|
ESP_LOGI(TAG, "task %s %s/%s daily %02u:%02u:%02u weekdays=0x%02x",
|
out->id, out->app_id, out->task_id, out->hour, out->min, out->sec, out->weekdays);
|
return true;
|
}
|
|
static bool load_from_file(void)
|
{
|
s_task_count = 0;
|
FILE *fp = fopen(SCHEDULE_PATH, "rb");
|
if (!fp) {
|
// SD 还没挂载时不要记成“已经加载且没有计划”，否则开机后不再重读。
|
s_loaded = false;
|
s_task_count = 0;
|
return false;
|
}
|
if (fseek(fp, 0, SEEK_END) != 0) {
|
fclose(fp);
|
return false;
|
}
|
long size = ftell(fp);
|
rewind(fp);
|
if (size <= 0 || size > 49152) {
|
fclose(fp);
|
return false;
|
}
|
char *buf = (char *)malloc((size_t)size + 1);
|
if (!buf) {
|
fclose(fp);
|
return false;
|
}
|
size_t n = fread(buf, 1, (size_t)size, fp);
|
fclose(fp);
|
buf[n] = '\0';
|
cJSON *root = cJSON_Parse(buf);
|
free(buf);
|
if (!root) {
|
return false;
|
}
|
const cJSON *tasks = cJSON_IsArray(root) ? root : cJSON_GetObjectItem(root, "tasks");
|
if (cJSON_IsArray(tasks)) {
|
const cJSON *item = NULL;
|
cJSON_ArrayForEach(item, tasks) {
|
if (s_task_count >= SCHEDULE_MAX_TASKS) {
|
break;
|
}
|
if (parse_one_task(item, &s_tasks[s_task_count])) {
|
s_task_count++;
|
}
|
}
|
}
|
cJSON_Delete(root);
|
s_loaded = true;
|
ESP_LOGI(TAG, "loaded %d scheduled tasks", s_task_count);
|
return true;
|
}
|
|
static bool next_occurrence(const sched_task_t *task, time_t not_before, time_t *out)
|
{
|
if (!task || !out || !task->enabled) {
|
return false;
|
}
|
struct tm now_tm = {};
|
time_t now = wall_now(&now_tm);
|
if (not_before < now) {
|
not_before = now;
|
}
|
|
if (task->type == SCHEDULE_TYPE_HOURLY) {
|
time_t midnight = now - (now_tm.tm_hour * 3600 + now_tm.tm_min * 60 + now_tm.tm_sec);
|
time_t missed = 0;
|
for (int h = 0; h < 24 * 8; ++h) {
|
time_t cand = midnight + h * 3600 + task->hourly_minute * 60;
|
if (cand > not_before) {
|
if (slot_already_claimed(task, cand)) {
|
continue;
|
}
|
if (missed != 0 && not_before <= now) {
|
*out = missed;
|
return true;
|
}
|
*out = cand;
|
return true;
|
}
|
if (not_before <= now && cand <= now && now - cand <= SCHEDULE_DUE_WINDOW_SEC &&
|
!slot_already_claimed(task, cand)) {
|
missed = cand;
|
}
|
}
|
if (missed != 0) {
|
*out = missed;
|
return true;
|
}
|
return false;
|
}
|
if (task->type == SCHEDULE_TYPE_INTERVAL) {
|
int every = task->every_minutes > 0 ? task->every_minutes : 60;
|
time_t step = (time_t)every * 60;
|
if (step < 60) {
|
step = 60;
|
}
|
if (not_before <= now && step > 0) {
|
time_t slot = (now / step) * step;
|
if (slot > 0 && now - slot <= SCHEDULE_DUE_WINDOW_SEC && !slot_already_claimed(task, slot)) {
|
*out = slot;
|
return true;
|
}
|
}
|
time_t cand = ((not_before / step) + 1) * step;
|
if (cand <= not_before) {
|
cand += step;
|
}
|
*out = cand;
|
return true;
|
}
|
|
uint8_t mask = task->weekdays ? task->weekdays : ALARM_REPEAT_ALL;
|
int now_sec = now_tm.tm_hour * 3600 + now_tm.tm_min * 60 + now_tm.tm_sec;
|
int alarm_sec = task->hour * 3600 + task->min * 60 + task->sec;
|
int min_delta = (int)(not_before - now);
|
if (min_delta < 0) {
|
min_delta = 0;
|
}
|
int best_delta = 8 * 24 * 3600;
|
bool found = false;
|
for (int day_offset = 0; day_offset <= 8; ++day_offset) {
|
int tm_wday = (now_tm.tm_wday + day_offset) % 7;
|
if ((mask & tm_wday_to_repeat_bit(tm_wday)) == 0) {
|
continue;
|
}
|
int delta = day_offset * 24 * 3600 + alarm_sec - now_sec;
|
if (delta <= min_delta) {
|
// 刚过点的几分钟内仍算本次（硬件开机、软关机唤醒），不要直接排到下一天。
|
if (min_delta <= 0 && delta >= -SCHEDULE_DUE_WINDOW_SEC &&
|
!slot_already_claimed(task, now + delta)) {
|
best_delta = delta;
|
found = true;
|
}
|
continue;
|
}
|
if (slot_already_claimed(task, now + (time_t)delta)) {
|
continue;
|
}
|
if (found && best_delta <= 0) {
|
break;
|
}
|
if (delta < best_delta) {
|
best_delta = delta;
|
found = true;
|
}
|
}
|
if (!found) {
|
return false;
|
}
|
*out = now + best_delta;
|
return true;
|
}
|
|
static void clear_next(void)
|
{
|
s_next_valid = false;
|
s_next_unix = 0;
|
s_next_id[0] = '\0';
|
s_next_app[0] = '\0';
|
s_next_task[0] = '\0';
|
copy_str(s_next_params, sizeof(s_next_params), "{}");
|
DS2312_Clear_Schedule_Wake();
|
}
|
|
static void cancel_duration_timer(void)
|
{
|
if (s_duration_timer) {
|
esp_timer_stop(s_duration_timer);
|
}
|
}
|
|
static void duration_timer_cb(void *arg)
|
{
|
(void)arg;
|
Application::GetInstance().Schedule([]() {
|
s_duration_fired = true;
|
Board_Schedule_OnNaturalEnd();
|
});
|
}
|
|
static void ensure_duration_timer(void)
|
{
|
if (s_duration_timer) {
|
return;
|
}
|
const esp_timer_create_args_t args = {
|
.callback = duration_timer_cb,
|
.arg = NULL,
|
.dispatch_method = ESP_TIMER_TASK,
|
.name = "sched_dur",
|
.skip_unhandled_events = true,
|
};
|
if (esp_timer_create(&args, &s_duration_timer) != ESP_OK) {
|
s_duration_timer = NULL;
|
}
|
}
|
|
static bool is_playlist_task(const char *task_id)
|
{
|
return task_id && (strcmp(task_id, "repeater") == 0 || strcmp(task_id, "shadowing") == 0);
|
}
|
|
static bool claim_slot_recorded(const char *id, time_t cand)
|
{
|
if (!id || id[0] == '\0' || cand <= 0) {
|
return false;
|
}
|
for (int i = 0; i < s_claimed_count; ++i) {
|
if (s_claimed_slots[i].unix_time == cand && strcmp(s_claimed_slots[i].id, id) == 0) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
static void remember_claim_slot(const char *id, time_t unix_time)
|
{
|
if (!id || id[0] == '\0' || unix_time <= 0 || claim_slot_recorded(id, unix_time)) {
|
if (unix_time > s_last_started_unix) {
|
s_last_started_unix = unix_time;
|
}
|
return;
|
}
|
if (s_claimed_count >= CLAIMED_SLOT_MAX) {
|
memmove(&s_claimed_slots[0], &s_claimed_slots[1],
|
sizeof(claimed_slot_t) * (CLAIMED_SLOT_MAX - 1));
|
s_claimed_count = CLAIMED_SLOT_MAX - 1;
|
}
|
copy_str(s_claimed_slots[s_claimed_count].id, sizeof(s_claimed_slots[s_claimed_count].id), id);
|
s_claimed_slots[s_claimed_count].unix_time = unix_time;
|
s_claimed_count++;
|
if (unix_time > s_last_started_unix) {
|
s_last_started_unix = unix_time;
|
}
|
}
|
|
static bool slot_already_claimed(const sched_task_t *task, time_t cand)
|
{
|
if (!task) {
|
return false;
|
}
|
// 时间已经走到更晚的计划，更早的那次不再回头启动。
|
if (s_last_started_unix > 0 && cand < s_last_started_unix) {
|
return true;
|
}
|
return claim_slot_recorded(task->id, cand);
|
}
|
|
static bool is_chat_task(const char *app_id, const char *task_id)
|
{
|
return app_id && strcmp(app_id, "chat") == 0 &&
|
(!task_id || task_id[0] == '\0' || strcmp(task_id, "conversation") == 0);
|
}
|
|
static void apply_on_complete(bool user_exit)
|
{
|
cancel_duration_timer();
|
s_occupying = false;
|
s_busy_until = 0;
|
int complete = s_on_complete;
|
s_on_complete = SCHEDULE_END_DEFAULT;
|
bool from_duration = s_duration_fired;
|
s_duration_fired = false;
|
Board_Schedule_Recompute();
|
if (!user_exit && s_deferred_due && Board_Schedule_IsDueNow(180)) {
|
s_deferred_due = false;
|
Board_Schedule_OnAlarmFired();
|
return;
|
}
|
s_deferred_due = false;
|
if (!user_exit && complete == SCHEDULE_END_POWER_OFF) {
|
Application::GetInstance().RequestPowerOffStandby();
|
return;
|
}
|
if (!user_exit && from_duration) {
|
Board_StartAppTask("chat", "conversation", "{}", "default_chat");
|
}
|
}
|
|
esp_err_t Board_Schedule_SyncJson(const char *json)
|
{
|
if (!json) {
|
return ESP_ERR_INVALID_ARG;
|
}
|
cJSON *root = cJSON_Parse(json);
|
if (!root) {
|
return ESP_ERR_INVALID_ARG;
|
}
|
const cJSON *tasks = cJSON_IsArray(root) ? root : cJSON_GetObjectItem(root, "tasks");
|
if (tasks && !cJSON_IsArray(tasks)) {
|
cJSON_Delete(root);
|
return ESP_ERR_INVALID_ARG;
|
}
|
if (tasks && cJSON_GetArraySize(tasks) > SCHEDULE_MAX_TASKS) {
|
cJSON_Delete(root);
|
return ESP_ERR_NO_MEM;
|
}
|
cJSON *store = cJSON_CreateObject();
|
if (!store) {
|
cJSON_Delete(root);
|
return ESP_ERR_NO_MEM;
|
}
|
cJSON *copy = tasks ? cJSON_Duplicate(tasks, 1) : cJSON_CreateArray();
|
if (!copy) {
|
cJSON_Delete(store);
|
cJSON_Delete(root);
|
return ESP_ERR_NO_MEM;
|
}
|
cJSON_AddItemToObject(store, "tasks", copy);
|
char *printed = cJSON_PrintUnformatted(store);
|
cJSON_Delete(store);
|
cJSON_Delete(root);
|
if (!printed) {
|
return ESP_ERR_NO_MEM;
|
}
|
FILE *fp = fopen(SCHEDULE_PATH, "wb");
|
if (!fp) {
|
free(printed);
|
return ESP_FAIL;
|
}
|
size_t len = strlen(printed);
|
size_t wrote = fwrite(printed, 1, len, fp);
|
fclose(fp);
|
free(printed);
|
if (wrote != len) {
|
return ESP_FAIL;
|
}
|
s_loaded = false;
|
if (!load_from_file()) {
|
return ESP_FAIL;
|
}
|
for (int i = 0; i < s_task_count; ++i) {
|
if (!s_tasks[i].enabled) {
|
continue;
|
}
|
Board_RememberLastLessonTask(s_tasks[i].task_id, s_tasks[i].params_json);
|
}
|
return Board_Schedule_Recompute();
|
}
|
|
void Board_Schedule_Reload(void)
|
{
|
s_loaded = false;
|
s_task_count = 0;
|
}
|
|
esp_err_t Board_Schedule_Recompute(void)
|
{
|
if (!s_loaded && !load_from_file()) {
|
ESP_LOGW(TAG, "schedule file not ready");
|
return ESP_FAIL;
|
}
|
struct tm now_tm = {};
|
time_t now = wall_now(&now_tm);
|
time_t not_before = now;
|
// 课文计划播完后如果没收到结束回调，不要继续占着下一次闹钟。
|
if (s_occupying && s_busy_until <= now && !Board_IsLessonPlaybackActive()) {
|
s_occupying = false;
|
s_busy_until = 0;
|
}
|
// 只有设定了持续时长才往后推。正在泛听不能把跟读推迟 12 小时。
|
if (s_occupying && s_busy_until > now) {
|
not_before = s_busy_until;
|
}
|
|
int best_index = -1;
|
time_t best_unix = 0;
|
bool best_due = false;
|
for (int i = 0; i < s_task_count; ++i) {
|
time_t cand = 0;
|
if (!next_occurrence(&s_tasks[i], not_before, &cand)) {
|
continue;
|
}
|
bool due = cand <= now;
|
bool take = false;
|
if (best_index < 0) {
|
take = true;
|
} else if (due && !best_due) {
|
take = true;
|
} else if (due && best_due && cand > best_unix) {
|
take = true;
|
} else if (!due && !best_due && cand < best_unix) {
|
take = true;
|
}
|
if (take) {
|
best_index = i;
|
best_unix = cand;
|
best_due = due;
|
}
|
}
|
if (best_index < 0) {
|
ESP_LOGI(TAG, "no upcoming scheduled task");
|
clear_next();
|
return ESP_OK;
|
}
|
|
const sched_task_t *best = &s_tasks[best_index];
|
copy_str(s_next_id, sizeof(s_next_id), best->id);
|
copy_str(s_next_app, sizeof(s_next_app), best->app_id);
|
copy_str(s_next_task, sizeof(s_next_task), best->task_id);
|
copy_str(s_next_params, sizeof(s_next_params), best->params_json[0] ? best->params_json : "{}");
|
s_next_unix = best_unix;
|
s_next_valid = true;
|
|
struct tm fire_tm = {};
|
localtime_r(&best_unix, &fire_tm);
|
uint8_t bit = tm_wday_to_repeat_bit(fire_tm.tm_wday);
|
DS2312_Set_Schedule_Wake(fire_tm.tm_hour, fire_tm.tm_min, fire_tm.tm_sec, bit);
|
ESP_LOGI(TAG, "next schedule id=%s %s/%s at %02d:%02d:%02d unix=%ld",
|
s_next_id, s_next_app, s_next_task, fire_tm.tm_hour, fire_tm.tm_min, fire_tm.tm_sec,
|
(long)best_unix);
|
return ESP_OK;
|
}
|
|
bool Board_Schedule_IsDueNow(int window_sec)
|
{
|
if (!s_next_valid) {
|
if (!s_loaded) {
|
load_from_file();
|
Board_Schedule_Recompute();
|
}
|
if (!s_next_valid) {
|
return false;
|
}
|
}
|
time_t now = wall_now(NULL);
|
if (window_sec < 1) {
|
window_sec = SCHEDULE_DUE_WINDOW_SEC;
|
}
|
time_t late = now - s_next_unix;
|
// 计划时间未到就不要启动，避免下发后提前打断正在进行的对话。
|
if (late < 0) {
|
return false;
|
}
|
return late <= window_sec;
|
}
|
|
bool Board_Schedule_LoadDueTask(char *app_id, size_t app_size, char *task_id, size_t task_size,
|
char *params_json, size_t params_size)
|
{
|
if (!s_next_valid) {
|
return false;
|
}
|
copy_str(app_id, app_size, s_next_app);
|
copy_str(task_id, task_size, s_next_task);
|
copy_str(params_json, params_size, s_next_params[0] ? s_next_params : "{}");
|
return app_id && app_id[0];
|
}
|
|
bool Board_Schedule_ClaimDue(void)
|
{
|
if (!Board_Schedule_IsDueNow(SCHEDULE_DUE_WINDOW_SEC)) {
|
return false;
|
}
|
if (claim_slot_recorded(s_next_id, s_next_unix)) {
|
return false;
|
}
|
remember_claim_slot(s_next_id, s_next_unix);
|
return true;
|
}
|
|
static void remember_claimed_schedule(const char *task_id)
|
{
|
if (!s_next_valid || !task_id || strcmp(task_id, s_next_task) != 0) {
|
return;
|
}
|
if (!Board_Schedule_IsDueNow(SCHEDULE_DUE_WINDOW_SEC)) {
|
return;
|
}
|
remember_claim_slot(s_next_id, s_next_unix);
|
}
|
|
static void arm_wait_lesson_files(const char *app_id, const char *task_id, const char *params)
|
{
|
if (!s_wait_lesson_files) {
|
ESP_LOGW(TAG, "schedule %s/%s files not ready, wait for sync", app_id, task_id);
|
Board_Show_Alert("正在同步", "正在同步课文，请稍候", "cloud_arrow_down");
|
s_wait_lesson_files_since = wall_now(NULL);
|
}
|
s_wait_lesson_files = true;
|
copy_str(s_pending_app, sizeof(s_pending_app), app_id);
|
copy_str(s_pending_task, sizeof(s_pending_task), task_id);
|
copy_str(s_pending_params, sizeof(s_pending_params), (params && params[0]) ? params : "{}");
|
Board_Schedule_Recompute();
|
}
|
|
void Board_Schedule_OnAlarmFired(void)
|
{
|
if (s_fire_queued || s_deferred_due) {
|
return;
|
}
|
s_fire_queued = true;
|
Application::GetInstance().Schedule([]() {
|
s_fire_queued = false;
|
if (!s_next_valid && !Board_Schedule_IsDueNow(SCHEDULE_DUE_WINDOW_SEC)) {
|
Board_Schedule_Recompute();
|
return;
|
}
|
if (!Board_Schedule_IsDueNow(SCHEDULE_DUE_WINDOW_SEC)) {
|
Board_Schedule_Recompute();
|
return;
|
}
|
if (Board_AppTask_CurrentPriority() >= Board_AppTask_SourcePriority("mqtt_immediate")) {
|
ESP_LOGI(TAG, "defer schedule, immediate task running");
|
s_deferred_due = true;
|
return;
|
}
|
char app_id[SCHEDULE_APP_MAX];
|
char task_id[SCHEDULE_APP_MAX];
|
char params[SCHEDULE_PARAMS_MAX];
|
if (!Board_Schedule_LoadDueTask(app_id, sizeof(app_id), task_id, sizeof(task_id),
|
params, sizeof(params))) {
|
Board_Schedule_Recompute();
|
return;
|
}
|
if (is_playlist_task(task_id) && !Board_LessonFilesReady(task_id, params)) {
|
arm_wait_lesson_files(app_id, task_id, params);
|
return;
|
}
|
ESP_LOGI(TAG, "alarm start schedule %s/%s", app_id, task_id);
|
s_deferred_due = false;
|
s_wait_lesson_files = false;
|
s_wait_lesson_files_since = 0;
|
Board_StartAppTask(app_id, task_id, params, "schedule");
|
});
|
}
|
|
void Board_Schedule_OnLessonFilesUpdated(void)
|
{
|
if (!s_wait_lesson_files || s_pending_task[0] == '\0' || s_files_poll_queued) {
|
return;
|
}
|
time_t now = wall_now(NULL);
|
if (s_wait_lesson_files_since > 0 && now > s_wait_lesson_files_since + 15 * 60) {
|
ESP_LOGW(TAG, "lesson files still missing after 15 min, skip %s/%s",
|
s_pending_app, s_pending_task);
|
s_wait_lesson_files = false;
|
s_wait_lesson_files_since = 0;
|
s_pending_task[0] = '\0';
|
Application::GetInstance().Schedule([]() {
|
Board_Schedule_Recompute();
|
});
|
return;
|
}
|
if (!Board_LessonFilesReady(s_pending_task, s_pending_params)) {
|
return;
|
}
|
s_files_poll_queued = true;
|
Application::GetInstance().Schedule([]() {
|
s_files_poll_queued = false;
|
if (!s_wait_lesson_files || s_pending_task[0] == '\0') {
|
return;
|
}
|
char app_id[SCHEDULE_APP_MAX];
|
char task_id[SCHEDULE_APP_MAX];
|
char params[SCHEDULE_PARAMS_MAX];
|
copy_str(app_id, sizeof(app_id), s_pending_app);
|
copy_str(task_id, sizeof(task_id), s_pending_task);
|
copy_str(params, sizeof(params), s_pending_params[0] ? s_pending_params : "{}");
|
if (!Board_LessonFilesReady(task_id, params)) {
|
return;
|
}
|
ESP_LOGI(TAG, "lesson files ready, start schedule %s/%s", app_id, task_id);
|
s_wait_lesson_files = false;
|
s_wait_lesson_files_since = 0;
|
s_pending_task[0] = '\0';
|
Board_StartAppTask(app_id, task_id, params, "schedule");
|
});
|
}
|
|
void Board_Schedule_OnTaskStarted(const char *app_id, const char *task_id, const char *source,
|
const char *params_json)
|
{
|
if (source && strcmp(source, "schedule") == 0) {
|
remember_claimed_schedule(task_id);
|
}
|
cancel_duration_timer();
|
cJSON *params = params_json ? cJSON_Parse(params_json) : NULL;
|
s_on_complete = on_complete_from_params(params);
|
int duration = duration_minutes_from_params(params);
|
if (params) {
|
cJSON_Delete(params);
|
}
|
|
bool chat = is_chat_task(app_id, task_id);
|
bool schedule_or_immediate =
|
source && (strcmp(source, "schedule") == 0 || strcmp(source, "mqtt_immediate") == 0);
|
bool parent_end_to_chat = chat && schedule_or_immediate && duration <= 0;
|
if (chat && (!source || strcmp(source, "voice") == 0 || strcmp(source, "default_chat") == 0
|
|| parent_end_to_chat)) {
|
if (source && (strcmp(source, "voice") == 0 || parent_end_to_chat)) {
|
s_deferred_due = false;
|
}
|
s_occupying = false;
|
s_busy_until = 0;
|
s_on_complete = SCHEDULE_END_DEFAULT;
|
Board_Schedule_Recompute();
|
return;
|
}
|
|
s_occupying = schedule_or_immediate;
|
time_t now = wall_now(NULL);
|
if (schedule_or_immediate && !is_playlist_task(task_id) && duration > 0) {
|
s_busy_until = now + (time_t)duration * 60;
|
ensure_duration_timer();
|
if (s_duration_timer) {
|
esp_timer_stop(s_duration_timer);
|
esp_timer_start_once(s_duration_timer, (uint64_t)duration * 60ULL * 1000000ULL);
|
}
|
} else {
|
s_busy_until = 0;
|
}
|
if (source && strcmp(source, "mqtt_immediate") == 0) {
|
return;
|
}
|
Board_Schedule_Recompute();
|
}
|
|
void Board_Schedule_OnNaturalEnd(void)
|
{
|
apply_on_complete(false);
|
}
|
|
void Board_Schedule_OnUserExit(void)
|
{
|
s_deferred_due = false;
|
apply_on_complete(true);
|
}
|
|
void Board_Schedule_OnEnteringPowerOff(void)
|
{
|
cancel_duration_timer();
|
s_occupying = false;
|
s_busy_until = 0;
|
s_duration_fired = false;
|
Board_Schedule_Recompute();
|
}
|
