refactor(DiscoveryMountain): split monolithic main.c into modular files
- Extracted app_context (global AppCtx G definition) - storage: path helpers, LRU, sort, fmt_time, per-episode resume map, state persistence - network: resolve_host, normalize URL, http_get_raw with growing PSRAM buffer, fetch_data - download: dl_ep_raw with progress tracking, cancel, overlay UI (show/hide/update) - player: audio device, stream, play_task with resume seek, start/select/next/prev with position save/restore - ui: build_ui, timers, season picker, button callbacks, periodic save - main: minimal glue, fetch_task, onShow/onHide, app registration - Preserves all previous fixes: download progress overlay, per-episode resume, robust download handling - Build verified: 111 undef, all exported
This commit is contained in:
Adolfo
@@ -0,0 +1,3 @@
|
||||
#include "app_context.h"
|
||||
|
||||
AppCtx G = {0};
|
||||
@@ -0,0 +1,87 @@
|
||||
#pragma once
|
||||
|
||||
#include <tt_lvgl.h>
|
||||
#include <tt_lvgl_toolbar.h>
|
||||
#include <lvgl.h>
|
||||
#include <tactility/lvgl_fonts.h>
|
||||
#include <tactility/device.h>
|
||||
#include <tactility/drivers/audio_stream.h>
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define TAG "DM"
|
||||
#define PB "http://192.168.68.110:8095"
|
||||
#define DM_DIR "/sdcard/dm"
|
||||
#define STATE_PATH "/sdcard/apps/one.tactility.discoverymountain/userdata/state.json"
|
||||
#define MAX_SEASONS 40
|
||||
#define MAX_EPS 400
|
||||
#define MP3_BUF 16384
|
||||
|
||||
typedef struct { int num; } SeasonInfo;
|
||||
typedef struct {
|
||||
char title[128];
|
||||
char slug[96];
|
||||
int season;
|
||||
int ep_num;
|
||||
char audio_url[256];
|
||||
bool seen;
|
||||
} EpInfo;
|
||||
|
||||
typedef struct { char slug[96]; int pos; } SavedPos;
|
||||
|
||||
typedef struct {
|
||||
SeasonInfo seasons[MAX_SEASONS];
|
||||
int season_cnt;
|
||||
EpInfo eps[MAX_EPS];
|
||||
int ep_cnt;
|
||||
int cur_season;
|
||||
int cur_ep_idx;
|
||||
struct Device* stream_dev;
|
||||
AudioStreamHandle stream_handle;
|
||||
bool is_playing;
|
||||
bool is_paused;
|
||||
bool need_stop;
|
||||
TaskHandle_t play_handle;
|
||||
TaskHandle_t fetch_handle;
|
||||
TaskHandle_t dl_handle;
|
||||
int pos_sec;
|
||||
int total_sec;
|
||||
int volume;
|
||||
int last_pct;
|
||||
lv_obj_t *lbl_title, *lbl_meta, *bar, *lbl_time, *lbl_status, *btn_play;
|
||||
lv_obj_t *overlay, *dropdown;
|
||||
// Download UI
|
||||
lv_obj_t *dl_overlay;
|
||||
lv_obj_t *dl_bar;
|
||||
lv_obj_t *dl_lbl_pct;
|
||||
lv_obj_t *dl_lbl_detail;
|
||||
lv_obj_t *dl_lbl_title;
|
||||
lv_obj_t *dl_lbl_sub;
|
||||
char cur_title[128];
|
||||
char last_slug[96];
|
||||
bool fetching;
|
||||
bool downloading;
|
||||
int dl_total;
|
||||
int dl_expected;
|
||||
int dl_last_ui_update;
|
||||
bool dl_cancel_req;
|
||||
char dl_ep_title[128];
|
||||
char dl_slug[96];
|
||||
int dl_season;
|
||||
int dl_ep_num;
|
||||
int dl_last_pct;
|
||||
// Per-episode resume
|
||||
SavedPos saved_pos[MAX_EPS];
|
||||
int saved_pos_cnt;
|
||||
int last_save_tick;
|
||||
} AppCtx;
|
||||
|
||||
extern AppCtx G;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,393 @@
|
||||
#include "download.h"
|
||||
#include "storage.h"
|
||||
#include "network.h"
|
||||
#include "player.h"
|
||||
#include <tt_lvgl.h>
|
||||
#include <tactility/lvgl_fonts.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <lwip/sockets.h>
|
||||
#include <lwip/inet.h>
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "esp_log.h"
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
|
||||
static void dl_cancel_cb(lv_event_t* e){
|
||||
(void)e;
|
||||
ESP_LOGI(TAG,"DL cancel requested");
|
||||
G.dl_cancel_req=true;
|
||||
if(G.dl_lbl_detail) lv_label_set_text(G.dl_lbl_detail,"Canceling...");
|
||||
}
|
||||
|
||||
void hide_dl_overlay(){
|
||||
if(G.dl_overlay){
|
||||
lv_obj_delete(G.dl_overlay);
|
||||
G.dl_overlay=NULL;
|
||||
G.dl_bar=NULL;
|
||||
G.dl_lbl_pct=NULL;
|
||||
G.dl_lbl_detail=NULL;
|
||||
G.dl_lbl_title=NULL;
|
||||
G.dl_lbl_sub=NULL;
|
||||
}
|
||||
G.downloading=false;
|
||||
}
|
||||
|
||||
void show_dl_overlay_locked(const char* ep_title, const char* slug, int season, int ep_num){
|
||||
if(G.dl_overlay) hide_dl_overlay();
|
||||
|
||||
strncpy(G.dl_ep_title, ep_title ? ep_title : "Episode", sizeof(G.dl_ep_title)-1);
|
||||
strncpy(G.dl_slug, slug ? slug : "", sizeof(G.dl_slug)-1);
|
||||
G.dl_season=season;
|
||||
G.dl_ep_num=ep_num;
|
||||
G.dl_total=0;
|
||||
G.dl_expected=-1;
|
||||
G.dl_last_pct=-1;
|
||||
G.dl_cancel_req=false;
|
||||
G.downloading=true;
|
||||
|
||||
G.dl_overlay = lv_obj_create(lv_scr_act());
|
||||
lv_obj_set_size(G.dl_overlay, LV_PCT(100), LV_PCT(100));
|
||||
lv_obj_set_style_bg_color(G.dl_overlay, lv_color_hex(0x000000), 0);
|
||||
lv_obj_set_style_bg_opa(G.dl_overlay, LV_OPA_70, 0);
|
||||
lv_obj_set_style_border_width(G.dl_overlay, 0, 0);
|
||||
lv_obj_set_style_pad_all(G.dl_overlay, 0, 0);
|
||||
lv_obj_set_style_radius(G.dl_overlay, 0, 0);
|
||||
lv_obj_remove_flag(G.dl_overlay, LV_OBJ_FLAG_SCROLLABLE);
|
||||
|
||||
lv_obj_t* card = lv_obj_create(G.dl_overlay);
|
||||
lv_obj_set_size(card, 220, 210);
|
||||
lv_obj_center(card);
|
||||
lv_obj_set_style_bg_color(card, lv_color_hex(0x1E1E2E), 0);
|
||||
lv_obj_set_style_bg_opa(card, LV_OPA_COVER, 0);
|
||||
lv_obj_set_style_border_color(card, lv_color_hex(0x313244), 0);
|
||||
lv_obj_set_style_border_width(card, 1, 0);
|
||||
lv_obj_set_style_radius(card, 12, 0);
|
||||
lv_obj_set_style_pad_all(card, 12, 0);
|
||||
lv_obj_set_style_pad_row(card, 6, 0);
|
||||
lv_obj_set_flex_flow(card, LV_FLEX_FLOW_COLUMN);
|
||||
lv_obj_set_flex_align(card, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
||||
lv_obj_remove_flag(card, LV_OBJ_FLAG_SCROLLABLE);
|
||||
|
||||
lv_obj_t* lbl_head = lv_label_create(card);
|
||||
lv_label_set_text(lbl_head, "Downloading");
|
||||
lv_obj_set_style_text_color(lbl_head, lv_color_hex(0xCDD6F4), 0);
|
||||
lv_obj_set_style_text_font(lbl_head, lvgl_get_text_font(FONT_SIZE_DEFAULT), 0);
|
||||
|
||||
G.dl_lbl_title = lv_label_create(card);
|
||||
lv_label_set_text(G.dl_lbl_title, G.dl_ep_title);
|
||||
lv_obj_set_width(G.dl_lbl_title, 190);
|
||||
lv_obj_set_style_text_color(G.dl_lbl_title, lv_color_hex(0xFFFFFF), 0);
|
||||
lv_obj_set_style_text_align(G.dl_lbl_title, LV_TEXT_ALIGN_CENTER, 0);
|
||||
lv_label_set_long_mode(G.dl_lbl_title, LV_LABEL_LONG_WRAP);
|
||||
|
||||
G.dl_lbl_sub = lv_label_create(card);
|
||||
char sub[64];
|
||||
snprintf(sub, sizeof(sub), "S%02d E%02d • %s", season, ep_num, slug);
|
||||
lv_label_set_text(G.dl_lbl_sub, sub);
|
||||
lv_obj_set_style_text_color(G.dl_lbl_sub, lv_color_hex(0xA6ADC8), 0);
|
||||
lv_obj_set_style_text_font(G.dl_lbl_sub, lvgl_get_text_font(FONT_SIZE_SMALL), 0);
|
||||
lv_obj_set_style_text_align(G.dl_lbl_sub, LV_TEXT_ALIGN_CENTER, 0);
|
||||
|
||||
G.dl_bar = lv_bar_create(card);
|
||||
lv_obj_set_size(G.dl_bar, 190, 14);
|
||||
lv_bar_set_range(G.dl_bar, 0, 100);
|
||||
lv_bar_set_value(G.dl_bar, 0, LV_ANIM_OFF);
|
||||
lv_obj_set_style_bg_color(G.dl_bar, lv_color_hex(0x45475A), LV_PART_MAIN);
|
||||
lv_obj_set_style_bg_color(G.dl_bar, lv_color_hex(0x89B4FA), LV_PART_INDICATOR);
|
||||
lv_obj_set_style_radius(G.dl_bar, 7, 0);
|
||||
|
||||
G.dl_lbl_pct = lv_label_create(card);
|
||||
lv_label_set_text(G.dl_lbl_pct, "0%");
|
||||
lv_obj_set_style_text_color(G.dl_lbl_pct, lv_color_hex(0xCDD6F4), 0);
|
||||
lv_obj_set_style_text_font(G.dl_lbl_pct, lvgl_get_text_font(FONT_SIZE_DEFAULT), 0);
|
||||
|
||||
G.dl_lbl_detail = lv_label_create(card);
|
||||
lv_label_set_text(G.dl_lbl_detail, "Starting…");
|
||||
lv_obj_set_style_text_color(G.dl_lbl_detail, lv_color_hex(0xA6ADC8), 0);
|
||||
lv_obj_set_style_text_font(G.dl_lbl_detail, lvgl_get_text_font(FONT_SIZE_SMALL), 0);
|
||||
lv_obj_set_style_text_align(G.dl_lbl_detail, LV_TEXT_ALIGN_CENTER, 0);
|
||||
lv_obj_set_width(G.dl_lbl_detail, 190);
|
||||
lv_label_set_long_mode(G.dl_lbl_detail, LV_LABEL_LONG_WRAP);
|
||||
|
||||
lv_obj_t* btn_cancel = lv_button_create(card);
|
||||
lv_obj_set_size(btn_cancel, 90, 32);
|
||||
lv_obj_set_style_radius(btn_cancel, 8, 0);
|
||||
lv_obj_set_style_bg_color(btn_cancel, lv_color_hex(0x313244), 0);
|
||||
lv_obj_t* lbl_c = lv_label_create(btn_cancel);
|
||||
lv_label_set_text(lbl_c, "Cancel");
|
||||
lv_obj_center(lbl_c);
|
||||
lv_obj_add_event_cb(btn_cancel, dl_cancel_cb, LV_EVENT_CLICKED, NULL);
|
||||
}
|
||||
|
||||
void update_dl_overlay_ui(){
|
||||
if(!G.downloading || !G.dl_overlay) return;
|
||||
if(G.dl_bar){
|
||||
int pct=0;
|
||||
if(G.dl_expected>0){
|
||||
pct = (int)((int64_t)G.dl_total * 100 / G.dl_expected);
|
||||
if(pct<0) pct=0;
|
||||
if(pct>100) pct=100;
|
||||
} else {
|
||||
pct = G.dl_last_pct;
|
||||
if(pct<0) pct=0;
|
||||
}
|
||||
if(pct!=G.dl_last_pct){
|
||||
G.dl_last_pct=pct;
|
||||
lv_bar_set_value(G.dl_bar, pct, LV_ANIM_OFF);
|
||||
}
|
||||
}
|
||||
if(G.dl_lbl_pct){
|
||||
char b[16];
|
||||
if(G.dl_expected>0){
|
||||
int pct = (int)((int64_t)G.dl_total * 100 / G.dl_expected);
|
||||
if(pct<0) pct=0;
|
||||
if(pct>100) pct=100;
|
||||
snprintf(b,sizeof(b),"%d%%",pct);
|
||||
} else {
|
||||
snprintf(b,sizeof(b),"%d KB",G.dl_total/1024);
|
||||
}
|
||||
lv_label_set_text(G.dl_lbl_pct,b);
|
||||
}
|
||||
if(G.dl_lbl_detail){
|
||||
char d[64];
|
||||
if(G.dl_expected>0){
|
||||
int total_kb = G.dl_total/1024;
|
||||
int exp_kb = G.dl_expected/1024;
|
||||
if(exp_kb>1024){
|
||||
snprintf(d,sizeof(d),"%d KB / %d KB (%d.%01d MB)", total_kb, exp_kb, exp_kb/1024, (exp_kb%1024)*10/1024);
|
||||
} else {
|
||||
snprintf(d,sizeof(d),"%d / %d KB", total_kb, exp_kb);
|
||||
}
|
||||
} else {
|
||||
snprintf(d,sizeof(d),"%d KB downloaded", G.dl_total/1024);
|
||||
}
|
||||
lv_label_set_text(G.dl_lbl_detail,d);
|
||||
}
|
||||
}
|
||||
|
||||
bool dl_ep_raw(EpInfo* ep){
|
||||
if(!ep) return false;
|
||||
if(strlen(ep->audio_url)==0){ ESP_LOGE(TAG,"dl no url for %s",ep->slug); return false; }
|
||||
|
||||
char url_norm[512];
|
||||
normalize_audio_url(ep->audio_url, url_norm, sizeof(url_norm));
|
||||
ESP_LOGI(TAG,"dl url normalized: %s -> %s", ep->audio_url, url_norm);
|
||||
|
||||
const char* url=url_norm;
|
||||
if(strncmp(url,"http://",7)!=0){
|
||||
ESP_LOGE(TAG,"dl url not http %s",url);
|
||||
return false;
|
||||
}
|
||||
const char* p=url+7;
|
||||
const char* slash=strchr(p,'/');
|
||||
if(!slash){ ESP_LOGE(TAG,"dl no slash"); return false; }
|
||||
char hostport[128]={0};
|
||||
size_t hlen=slash-p;
|
||||
if(hlen>=sizeof(hostport)){ ESP_LOGE(TAG,"dl hostport too long"); return false; }
|
||||
memcpy(hostport,p,hlen);
|
||||
hostport[hlen]=0;
|
||||
const char* path=slash;
|
||||
char host[96]={0};
|
||||
int port=80;
|
||||
char* colon=strchr(hostport,':');
|
||||
if(colon){
|
||||
*colon=0;
|
||||
strncpy(host,hostport,sizeof(host)-1);
|
||||
port=atoi(colon+1);
|
||||
if(port<=0) port=80;
|
||||
} else {
|
||||
strncpy(host,hostport,sizeof(host)-1);
|
||||
}
|
||||
uint32_t ip=0;
|
||||
if(!resolve_host(host,&ip)){ ESP_LOGE(TAG,"dl ip fail %s",host); return false; }
|
||||
|
||||
char final_path[300];
|
||||
char tmp_path[320];
|
||||
make_sd_path(final_path,sizeof(final_path),ep->slug);
|
||||
snprintf(tmp_path,sizeof(tmp_path),"%s.tmp",final_path);
|
||||
unlink(tmp_path);
|
||||
FILE* f=fopen(tmp_path,"wb");
|
||||
if(!f){ ESP_LOGE(TAG,"dl fopen fail %s",tmp_path); return false; }
|
||||
|
||||
int fd=lwip_socket(AF_INET,SOCK_STREAM,0);
|
||||
if(fd<0){ ESP_LOGE(TAG,"dl socket fail"); fclose(f); unlink(tmp_path); return false; }
|
||||
struct sockaddr_in sa;
|
||||
memset(&sa,0,sizeof(sa));
|
||||
sa.sin_family=AF_INET;
|
||||
sa.sin_port=my_htons(port);
|
||||
sa.sin_addr.s_addr=ip;
|
||||
struct timeval tv={15,0};
|
||||
lwip_setsockopt(fd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(tv));
|
||||
lwip_setsockopt(fd,SOL_SOCKET,SO_SNDTIMEO,&tv,sizeof(tv));
|
||||
ESP_LOGI(TAG,"dl connecting %s:%d",host,port);
|
||||
if(lwip_connect(fd,(struct sockaddr*)&sa,sizeof(sa))<0){
|
||||
ESP_LOGE(TAG,"dl connect fail %s:%d errno=%d",host,port,errno);
|
||||
fclose(f); close(fd); unlink(tmp_path); return false;
|
||||
}
|
||||
ESP_LOGI(TAG,"dl connected");
|
||||
|
||||
char req[512];
|
||||
int reqlen=snprintf(req,sizeof(req),"GET %s HTTP/1.0\r\nHost: %s:%d\r\nConnection: close\r\nUser-Agent: TactilityDM/0.1\r\nAccept: */*\r\n\r\n",path,host,port);
|
||||
if(lwip_send(fd,req,reqlen,0)<0){
|
||||
ESP_LOGE(TAG,"dl send fail errno=%d",errno);
|
||||
fclose(f); close(fd); unlink(tmp_path); return false;
|
||||
}
|
||||
ESP_LOGI(TAG,"dl request sent");
|
||||
|
||||
char* hdr=heap_caps_malloc(8192, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
||||
if(!hdr){ fclose(f); close(fd); unlink(tmp_path); return false; }
|
||||
int hdr_len=0;
|
||||
bool header_done=false;
|
||||
int content_len=-1;
|
||||
int total=0;
|
||||
uint8_t* recv_buf=heap_caps_malloc(8192, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
||||
if(!recv_buf){ heap_caps_free(hdr); fclose(f); close(fd); unlink(tmp_path); return false; }
|
||||
|
||||
G.dl_total=0;
|
||||
G.dl_expected=-1;
|
||||
G.dl_last_pct=-1;
|
||||
|
||||
while(!header_done){
|
||||
if(G.dl_cancel_req){ ESP_LOGI(TAG,"dl canceled during header"); heap_caps_free(hdr); heap_caps_free(recv_buf); fclose(f); close(fd); unlink(tmp_path); return false; }
|
||||
int r=lwip_recv(fd,(char*)recv_buf,4096,0);
|
||||
if(r<=0){
|
||||
ESP_LOGE(TAG,"dl recv header fail r=%d errno=%d",r,errno);
|
||||
heap_caps_free(hdr); heap_caps_free(recv_buf); fclose(f); close(fd); unlink(tmp_path); return false;
|
||||
}
|
||||
if(hdr_len+r >= 8191){ ESP_LOGE(TAG,"dl hdr overflow"); heap_caps_free(hdr); heap_caps_free(recv_buf); fclose(f); close(fd); unlink(tmp_path); return false; }
|
||||
memcpy(hdr+hdr_len, recv_buf, r);
|
||||
hdr_len+=r;
|
||||
hdr[hdr_len]=0;
|
||||
char* he=strstr(hdr,"\r\n\r\n");
|
||||
if(he){
|
||||
header_done=true;
|
||||
if(strncmp(hdr,"HTTP/1.1 200",12)!=0 && strncmp(hdr,"HTTP/1.0 200",12)!=0){
|
||||
ESP_LOGE(TAG,"dl not 200: %.120s",hdr);
|
||||
heap_caps_free(hdr); heap_caps_free(recv_buf); fclose(f); close(fd); unlink(tmp_path); return false;
|
||||
}
|
||||
char* cl=strstr(hdr,"Content-Length:");
|
||||
if(!cl) cl=strstr(hdr,"content-length:");
|
||||
if(cl){
|
||||
cl=strchr(cl,':');
|
||||
if(cl){ cl++; while(*cl==' ') cl++; content_len=atoi(cl); }
|
||||
}
|
||||
ESP_LOGI(TAG,"dl header done cl=%d",content_len);
|
||||
G.dl_expected=content_len;
|
||||
int body_start = (he - hdr) + 4;
|
||||
int body_in_buf = hdr_len - body_start;
|
||||
if(body_in_buf>0){
|
||||
fwrite(hdr+body_start,1,body_in_buf,f);
|
||||
total+=body_in_buf;
|
||||
G.dl_total=total;
|
||||
ESP_LOGI(TAG,"dl wrote initial %d",body_in_buf);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG,"dl streaming body cl=%d",content_len);
|
||||
int consecutive_timeouts=0;
|
||||
const int max_timeouts=12;
|
||||
while(1){
|
||||
if(G.dl_cancel_req){
|
||||
ESP_LOGI(TAG,"dl canceled during body total=%d",total);
|
||||
heap_caps_free(hdr);
|
||||
heap_caps_free(recv_buf);
|
||||
close(fd);
|
||||
fclose(f);
|
||||
unlink(tmp_path);
|
||||
return false;
|
||||
}
|
||||
if(content_len>=0 && total>=content_len) break;
|
||||
int r=lwip_recv(fd,(char*)recv_buf,8192,0);
|
||||
if(r<0){
|
||||
if(errno==EAGAIN || errno==EWOULDBLOCK || errno==ETIMEDOUT || errno==0){
|
||||
consecutive_timeouts++;
|
||||
ESP_LOGW(TAG,"dl timeout %d/%d total=%d/%d",consecutive_timeouts,max_timeouts,total,content_len);
|
||||
if(consecutive_timeouts>=max_timeouts){
|
||||
ESP_LOGE(TAG,"dl too many timeouts, aborting");
|
||||
break;
|
||||
}
|
||||
vTaskDelay(pdMS_TO_TICKS(200));
|
||||
continue;
|
||||
} else {
|
||||
ESP_LOGE(TAG,"dl recv error r=%d errno=%d",r,errno);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(r==0){
|
||||
ESP_LOGI(TAG,"dl EOF total=%d expected=%d",total,content_len);
|
||||
break;
|
||||
}
|
||||
consecutive_timeouts=0;
|
||||
fwrite(recv_buf,1,r,f);
|
||||
total+=r;
|
||||
G.dl_total=total;
|
||||
}
|
||||
|
||||
heap_caps_free(hdr);
|
||||
heap_caps_free(recv_buf);
|
||||
close(fd);
|
||||
fclose(f);
|
||||
ESP_LOGI(TAG,"DL done total %d expected %d",total,content_len);
|
||||
if(G.dl_cancel_req){
|
||||
ESP_LOGI(TAG,"DL canceled, removing tmp");
|
||||
unlink(tmp_path);
|
||||
return false;
|
||||
}
|
||||
if(total<1024){ ESP_LOGE(TAG,"dl too small %d",total); unlink(tmp_path); return false; }
|
||||
if(content_len>=0 && total < content_len){
|
||||
if(total < content_len * 95 / 100){
|
||||
ESP_LOGE(TAG,"dl incomplete %d < %d (95%% threshold)",total,content_len);
|
||||
unlink(tmp_path);
|
||||
return false;
|
||||
} else {
|
||||
ESP_LOGW(TAG,"dl size slightly short %d vs %d, accepting",total,content_len);
|
||||
}
|
||||
}
|
||||
if(rename(tmp_path,final_path)!=0){
|
||||
ESP_LOGE(TAG,"rename failed %s -> %s errno=%d",tmp_path,final_path,errno);
|
||||
unlink(tmp_path);
|
||||
return false;
|
||||
}
|
||||
ep->seen=true;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool dl_ep(EpInfo* ep){
|
||||
if(!ep) return false;
|
||||
if(has_slug(ep->slug)) return true;
|
||||
ensure_dir();
|
||||
lru_check();
|
||||
return dl_ep_raw(ep);
|
||||
}
|
||||
|
||||
void dl_task(void* arg){
|
||||
int idx = (int)(intptr_t)arg;
|
||||
G.downloading=true;
|
||||
G.dl_cancel_req=false;
|
||||
if(idx<0||idx>=G.ep_cnt){ G.downloading=false; G.dl_handle=NULL; vTaskDelete(NULL); return; }
|
||||
EpInfo* ep=&G.eps[idx];
|
||||
ESP_LOGI(TAG,"DL start %s url %s",ep->slug,ep->audio_url);
|
||||
bool ok=dl_ep(ep);
|
||||
ESP_LOGI(TAG,"DL end %s ok %d",ep->slug,ok);
|
||||
tt_lvgl_lock(portMAX_DELAY);
|
||||
hide_dl_overlay();
|
||||
if(G.lbl_status){
|
||||
if(ok) lv_label_set_text(G.lbl_status,"DL done, playing...");
|
||||
else {
|
||||
if(G.dl_cancel_req) lv_label_set_text(G.lbl_status,"DL canceled");
|
||||
else lv_label_set_text(G.lbl_status,"DL failed – tap Play to retry");
|
||||
}
|
||||
}
|
||||
tt_lvgl_unlock();
|
||||
G.downloading=false;
|
||||
G.dl_handle=NULL;
|
||||
if(ok){
|
||||
start_idx_internal(idx);
|
||||
}
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
#pragma once
|
||||
|
||||
#include "app_context.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// Raw download to file with progress tracking
|
||||
bool dl_ep_raw(EpInfo* ep);
|
||||
bool dl_ep(EpInfo* ep);
|
||||
|
||||
// Download task
|
||||
void dl_task(void* arg);
|
||||
|
||||
// Download overlay UI
|
||||
void hide_dl_overlay(void);
|
||||
void show_dl_overlay_locked(const char* ep_title, const char* slug, int season, int ep_num);
|
||||
void update_dl_overlay_ui(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,249 @@
|
||||
#include "network.h"
|
||||
#include "storage.h"
|
||||
#include "cJSON.h"
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <lwip/sockets.h>
|
||||
#include <lwip/inet.h>
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "esp_log.h"
|
||||
#include <unistd.h>
|
||||
|
||||
uint16_t my_htons(uint16_t v){ return (v<<8)|(v>>8); }
|
||||
|
||||
bool resolve_host(const char* host, uint32_t* out_ip){
|
||||
if(!host || !out_ip) return false;
|
||||
uint32_t ip = ipaddr_addr(host);
|
||||
if(ip!=0 && ip!=0xFFFFFFFF){
|
||||
*out_ip=ip;
|
||||
return true;
|
||||
}
|
||||
ESP_LOGE(TAG,"resolve fail (DNS not supported) %s",host);
|
||||
return false;
|
||||
}
|
||||
|
||||
void normalize_audio_url(const char* in, char* out, size_t out_len){
|
||||
if(!in || !out) return;
|
||||
if(strncmp(in,"http://",7)==0){
|
||||
strncpy(out,in,out_len-1);
|
||||
out[out_len-1]=0;
|
||||
return;
|
||||
}
|
||||
if(in[0]=='/'){
|
||||
snprintf(out,out_len,"%s%s",PB,in);
|
||||
return;
|
||||
}
|
||||
if(strstr(in,"://")==NULL){
|
||||
if(in[0]=='/') snprintf(out,out_len,"%s%s",PB,in);
|
||||
else snprintf(out,out_len,"%s/%s",PB,in);
|
||||
return;
|
||||
}
|
||||
strncpy(out,in,out_len-1);
|
||||
out[out_len-1]=0;
|
||||
}
|
||||
|
||||
int http_get_raw(const char* url, char** out_body){
|
||||
if(!url || strncmp(url,"http://",7)!=0){ ESP_LOGE(TAG,"http_get url not http %s",url); return -1; }
|
||||
const char* p = url+7;
|
||||
const char* slash = strchr(p,'/');
|
||||
if(!slash){ ESP_LOGE(TAG,"no slash %s",url); return -1; }
|
||||
char hostport[128]={0};
|
||||
size_t hlen=slash-p;
|
||||
if(hlen>=sizeof(hostport)) return -1;
|
||||
memcpy(hostport,p,hlen);
|
||||
hostport[hlen]=0;
|
||||
const char* path=slash;
|
||||
char host[96]={0};
|
||||
int port=80;
|
||||
char* colon=strchr(hostport,':');
|
||||
if(colon){ *colon=0; strncpy(host,hostport,sizeof(host)-1); port=atoi(colon+1); if(port<=0) port=80; } else { strncpy(host,hostport,sizeof(host)-1); }
|
||||
ESP_LOGI(TAG,"GET %s host=%s port=%d",url,host,port);
|
||||
uint32_t ip=0;
|
||||
if(!resolve_host(host,&ip)){ ESP_LOGE(TAG,"ip fail %s",host); return -1; }
|
||||
int fd=lwip_socket(AF_INET,SOCK_STREAM,0);
|
||||
if(fd<0){ ESP_LOGE(TAG,"socket fail"); return -1; }
|
||||
struct sockaddr_in sa; memset(&sa,0,sizeof(sa));
|
||||
sa.sin_family=AF_INET; sa.sin_port=my_htons(port); sa.sin_addr.s_addr=ip;
|
||||
struct timeval tv={8,0};
|
||||
lwip_setsockopt(fd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(tv));
|
||||
lwip_setsockopt(fd,SOL_SOCKET,SO_SNDTIMEO,&tv,sizeof(tv));
|
||||
if(lwip_connect(fd,(struct sockaddr*)&sa,sizeof(sa))<0){ ESP_LOGE(TAG,"connect fail %s:%d",host,port); close(fd); return -1; }
|
||||
char req[512];
|
||||
int reqlen=snprintf(req,sizeof(req),"GET %s HTTP/1.0\r\nHost: %s:%d\r\nConnection: close\r\nUser-Agent: TactilityDM/0.1\r\nAccept: */*\r\n\r\n",path,host,port);
|
||||
if(lwip_send(fd,req,reqlen,0)<0){ ESP_LOGE(TAG,"send fail"); close(fd); return -1; }
|
||||
|
||||
int capacity=65536;
|
||||
char* buf=heap_caps_malloc(capacity, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
||||
if(!buf){ ESP_LOGE(TAG,"PSRAM 64k fail"); close(fd); return -1; }
|
||||
int total=0;
|
||||
char* header_end=NULL;
|
||||
int body_start=0;
|
||||
int content_len=-1;
|
||||
bool is_chunked=false;
|
||||
|
||||
while(1){
|
||||
if(total>=capacity-1){
|
||||
int newcap=capacity*2;
|
||||
if(newcap>600000){ ESP_LOGE(TAG,"too large %d",newcap); heap_caps_free(buf); close(fd); return -1; }
|
||||
char* nb=heap_caps_malloc(newcap, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
||||
if(!nb){ heap_caps_free(buf); close(fd); return -1; }
|
||||
memcpy(nb,buf,total);
|
||||
heap_caps_free(buf);
|
||||
buf=nb;
|
||||
capacity=newcap;
|
||||
}
|
||||
int r=lwip_recv(fd,buf+total,capacity-total-1,0);
|
||||
if(r<=0) break;
|
||||
total+=r;
|
||||
buf[total]=0;
|
||||
if(!header_end){
|
||||
header_end=strstr(buf,"\r\n\r\n");
|
||||
if(header_end){
|
||||
body_start=(header_end-buf)+4;
|
||||
if(strstr(buf,"chunked")) is_chunked=true;
|
||||
char* cl=strstr(buf,"Content-Length:");
|
||||
if(!cl) cl=strstr(buf,"content-length:");
|
||||
if(cl){ cl=strchr(cl,':'); if(cl){ cl++; while(*cl==' ') cl++; content_len=atoi(cl); } }
|
||||
ESP_LOGI(TAG,"header_end chunked=%d cl=%d total=%d",is_chunked,content_len,total);
|
||||
if(content_len>=0 && !is_chunked){
|
||||
if(total-body_start >= content_len) break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if(content_len>=0 && !is_chunked){
|
||||
if(total-body_start >= content_len) break;
|
||||
}
|
||||
}
|
||||
}
|
||||
close(fd);
|
||||
if(!header_end){ ESP_LOGE(TAG,"no header end total=%d",total); heap_caps_free(buf); return -1; }
|
||||
if(strncmp(buf,"HTTP/1.1 200",12)!=0 && strncmp(buf,"HTTP/1.0 200",12)!=0){ ESP_LOGE(TAG,"not 200: %.60s",buf); heap_caps_free(buf); return -1; }
|
||||
|
||||
int raw_len=total-body_start;
|
||||
char* raw=buf+body_start;
|
||||
char* final_body=NULL;
|
||||
int final_len=0;
|
||||
|
||||
if(is_chunked){
|
||||
final_body=heap_caps_malloc(200000, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
||||
if(!final_body){ heap_caps_free(buf); return -1; }
|
||||
int pos=0, out=0;
|
||||
while(pos<raw_len){
|
||||
char* crlf=strstr(raw+pos,"\r\n");
|
||||
if(!crlf) break;
|
||||
int off=crlf-(raw+pos);
|
||||
if(off<=0 || off>16){ pos+=off+2; continue; }
|
||||
char hex[16]={0};
|
||||
memcpy(hex,raw+pos,off);
|
||||
char* semi=strchr(hex,';');
|
||||
if(semi) *semi=0;
|
||||
long sz=strtol(hex,NULL,16);
|
||||
if(sz==0) break;
|
||||
pos+=off+2;
|
||||
if(pos+sz>raw_len) sz=raw_len-pos;
|
||||
if(out+sz>=200000) break;
|
||||
memcpy(final_body+out,raw+pos,sz);
|
||||
out+=sz;
|
||||
pos+=sz;
|
||||
if(pos+1<raw_len && raw[pos]=='\r' && raw[pos+1]=='\n') pos+=2;
|
||||
}
|
||||
final_body[out]=0;
|
||||
final_len=out;
|
||||
} else {
|
||||
int bl=raw_len;
|
||||
if(content_len>=0 && bl>content_len) bl=content_len;
|
||||
final_body=heap_caps_malloc(bl+1, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
||||
if(!final_body){ heap_caps_free(buf); return -1; }
|
||||
memcpy(final_body,raw,bl);
|
||||
final_body[bl]=0;
|
||||
final_len=bl;
|
||||
}
|
||||
heap_caps_free(buf);
|
||||
*out_body=final_body;
|
||||
ESP_LOGI(TAG,"GET ok %d",final_len);
|
||||
return final_len;
|
||||
}
|
||||
|
||||
void fetch_data(){
|
||||
char* js=NULL;
|
||||
char url[256];
|
||||
ESP_LOGI(TAG,"fetch seasons");
|
||||
snprintf(url,sizeof(url),"%s/api/collections/dm_seasons/records?perPage=100&sort=season_num",PB);
|
||||
int len=http_get_raw(url,&js);
|
||||
if(len>0 && js){
|
||||
cJSON* root=cJSON_Parse(js);
|
||||
free(js); js=NULL;
|
||||
if(root){
|
||||
cJSON* items=cJSON_GetObjectItem(root,"items");
|
||||
if(cJSON_IsArray(items)){
|
||||
G.season_cnt=0;
|
||||
int n=cJSON_GetArraySize(items);
|
||||
for(int i=0;i<n&&G.season_cnt<MAX_SEASONS;i++){
|
||||
cJSON* it=cJSON_GetArrayItem(items,i);
|
||||
cJSON* sn=cJSON_GetObjectItem(it,"season_num");
|
||||
if(sn&&cJSON_IsNumber(sn)){ G.seasons[G.season_cnt].num=sn->valueint; G.season_cnt++; }
|
||||
}
|
||||
sort_seasons();
|
||||
}
|
||||
cJSON_Delete(root);
|
||||
}
|
||||
} else {
|
||||
ESP_LOGW(TAG,"seasons fetch failed");
|
||||
}
|
||||
if(G.season_cnt==0){
|
||||
ESP_LOGW(TAG,"seasons fallback");
|
||||
for(int i=1;i<=37;i++) G.seasons[i-1].num=i;
|
||||
G.season_cnt=37;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG,"fetch episodes");
|
||||
snprintf(url,sizeof(url),"%s/api/collections/dm_episodes/records?perPage=400&sort=season_num,episode_num",PB);
|
||||
len=http_get_raw(url,&js);
|
||||
if(len>0 && js){
|
||||
cJSON* root=cJSON_Parse(js);
|
||||
free(js); js=NULL;
|
||||
if(root){
|
||||
cJSON* items=cJSON_GetObjectItem(root,"items");
|
||||
if(cJSON_IsArray(items)){
|
||||
G.ep_cnt=0;
|
||||
int n=cJSON_GetArraySize(items);
|
||||
for(int i=0;i<n&&G.ep_cnt<MAX_EPS;i++){
|
||||
cJSON* it=cJSON_GetArrayItem(items,i);
|
||||
cJSON* t=cJSON_GetObjectItem(it,"title");
|
||||
cJSON* slug=cJSON_GetObjectItem(it,"slug");
|
||||
cJSON* sn=cJSON_GetObjectItem(it,"season_num");
|
||||
cJSON* en=cJSON_GetObjectItem(it,"episode_num");
|
||||
cJSON* au=cJSON_GetObjectItem(it,"audio_url");
|
||||
if(!sn||!en) continue;
|
||||
EpInfo* e=&G.eps[G.ep_cnt];
|
||||
memset(e,0,sizeof(*e));
|
||||
if(t&&cJSON_IsString(t)) strncpy(e->title,t->valuestring,sizeof(e->title)-1);
|
||||
if(slug&&cJSON_IsString(slug)) strncpy(e->slug,slug->valuestring,sizeof(e->slug)-1);
|
||||
else if(t) strncpy(e->slug,t->valuestring,sizeof(e->slug)-1);
|
||||
e->season=sn->valueint;
|
||||
e->ep_num=en->valueint;
|
||||
if(au&&cJSON_IsString(au)) strncpy(e->audio_url,au->valuestring,sizeof(e->audio_url)-1);
|
||||
e->seen=has_slug(e->slug);
|
||||
G.ep_cnt++;
|
||||
}
|
||||
sort_eps();
|
||||
}
|
||||
cJSON_Delete(root);
|
||||
}
|
||||
} else {
|
||||
ESP_LOGW(TAG,"episodes fetch failed");
|
||||
}
|
||||
if(G.ep_cnt==0){
|
||||
ESP_LOGW(TAG,"episodes fallback");
|
||||
for(int i=0;i<6;i++){
|
||||
EpInfo* e=&G.eps[i];
|
||||
snprintf(e->slug,sizeof(e->slug),"S01E%02d",i+1);
|
||||
snprintf(e->title,sizeof(e->title),"Episode %d",i+1);
|
||||
e->season=1; e->ep_num=i+1;
|
||||
}
|
||||
G.ep_cnt=6;
|
||||
}
|
||||
for(int i=0;i<G.ep_cnt;i++) G.eps[i].seen=has_slug(G.eps[i].slug);
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
#pragma once
|
||||
|
||||
#include "app_context.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
uint16_t my_htons(uint16_t v);
|
||||
bool resolve_host(const char* host, uint32_t* out_ip);
|
||||
void normalize_audio_url(const char* in, char* out, size_t out_len);
|
||||
|
||||
// Robust HTTP GET with PSRAM buffer, returns length and allocates *out_body (must be free'd via free/heap_caps_free)
|
||||
int http_get_raw(const char* url, char** out_body);
|
||||
|
||||
// Fetch seasons and episodes from PB
|
||||
void fetch_data(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,344 @@
|
||||
#include "player.h"
|
||||
#include "storage.h"
|
||||
#include "download.h"
|
||||
#include "ui.h"
|
||||
|
||||
#include <tt_lvgl.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <lwip/sockets.h>
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "esp_log.h"
|
||||
#include <unistd.h>
|
||||
|
||||
#define MINIMP3_IMPLEMENTATION
|
||||
#define MINIMP3_NO_SIMD
|
||||
#include "minimp3.h"
|
||||
|
||||
bool find_audio_device(){
|
||||
struct Device* dev=device_find_by_name("audio-stream");
|
||||
if(dev){ G.stream_dev=dev; return true; }
|
||||
dev=device_find_first_by_type(&AUDIO_STREAM_TYPE);
|
||||
if(dev){ G.stream_dev=dev; return true; }
|
||||
return false;
|
||||
}
|
||||
void close_stream(){
|
||||
if(G.stream_handle){
|
||||
audio_stream_close(G.stream_handle);
|
||||
G.stream_handle=NULL;
|
||||
}
|
||||
}
|
||||
bool open_stream(uint32_t sr, uint8_t ch){
|
||||
close_stream();
|
||||
if(!G.stream_dev && !find_audio_device()) return false;
|
||||
struct AudioStreamConfig cfg={ .sample_rate=sr, .bits_per_sample=16, .channels=ch };
|
||||
error_t err=audio_stream_open_output(G.stream_dev,&cfg,&G.stream_handle);
|
||||
return err==ERROR_NONE;
|
||||
}
|
||||
|
||||
void wait_play_exit(){
|
||||
if(G.play_handle){
|
||||
G.need_stop=true;
|
||||
while(G.play_handle!=NULL){
|
||||
tt_lvgl_unlock();
|
||||
vTaskDelay(pdMS_TO_TICKS(10));
|
||||
tt_lvgl_lock(portMAX_DELAY);
|
||||
}
|
||||
}
|
||||
close_stream();
|
||||
}
|
||||
|
||||
void stop_playback_sync(){
|
||||
if(G.play_handle){
|
||||
G.need_stop=true;
|
||||
int tries=200;
|
||||
while(G.play_handle!=NULL && tries-- >0){
|
||||
vTaskDelay(pdMS_TO_TICKS(10));
|
||||
}
|
||||
}
|
||||
close_stream();
|
||||
G.is_playing=false;
|
||||
G.is_paused=false;
|
||||
}
|
||||
|
||||
void play_task(void* arg){
|
||||
(void)arg;
|
||||
int idx=G.cur_ep_idx;
|
||||
if(idx<0||idx>=G.ep_cnt){ G.play_handle=NULL; vTaskDelete(NULL); return; }
|
||||
EpInfo* ep=&G.eps[idx];
|
||||
char path[300];
|
||||
make_sd_path(path,sizeof(path),ep->slug);
|
||||
FILE* file=fopen(path,"rb");
|
||||
if(!file){ ESP_LOGE(TAG,"open fail %s",path); G.is_playing=false; G.play_handle=NULL; vTaskDelete(NULL); return; }
|
||||
fseek(file,0,SEEK_END);
|
||||
long fsize=ftell(file);
|
||||
fseek(file,0,SEEK_SET);
|
||||
if(fsize>0) G.total_sec=(int)(fsize/16000);
|
||||
if(!find_audio_device()){ ESP_LOGE(TAG,"no audio-stream dev"); fclose(file); G.is_playing=false; G.play_handle=NULL; vTaskDelete(NULL); return; }
|
||||
|
||||
uint8_t id3hdr[10];
|
||||
long id3_skip=0;
|
||||
if(fread(id3hdr,1,10,file)==10 && memcmp(id3hdr,"ID3",3)==0){
|
||||
int id3size = (id3hdr[6]&0x7F)<<21 | (id3hdr[7]&0x7F)<<14 | (id3hdr[8]&0x7F)<<7 | (id3hdr[9]&0x7F);
|
||||
ESP_LOGI(TAG,"ID3 found %d, skip",id3size);
|
||||
id3_skip=id3size+10;
|
||||
fseek(file, id3_skip, SEEK_SET);
|
||||
fsize -= id3_skip;
|
||||
if(fsize>0) G.total_sec=(int)(fsize/16000);
|
||||
} else {
|
||||
fseek(file,0,SEEK_SET);
|
||||
}
|
||||
|
||||
int resume_sec = G.pos_sec;
|
||||
if(resume_sec>5){
|
||||
long seek_bytes = (long)resume_sec * 16000;
|
||||
if(seek_bytes < fsize){
|
||||
fseek(file, id3_skip + seek_bytes, SEEK_SET);
|
||||
ESP_LOGI(TAG,"Resuming %s from %d sec (~%ld bytes)", ep->slug, resume_sec, seek_bytes);
|
||||
}
|
||||
}
|
||||
|
||||
mp3dec_t* dec = heap_caps_malloc(sizeof(mp3dec_t), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
||||
if(!dec){ ESP_LOGE(TAG,"dec malloc fail"); fclose(file); G.play_handle=NULL; vTaskDelete(NULL); return; }
|
||||
mp3dec_init(dec);
|
||||
uint8_t* inbuf=malloc(MP3_BUF);
|
||||
int16_t* pcm=malloc(1152*2*2);
|
||||
if(!inbuf||!pcm){ if(inbuf) free(inbuf); if(pcm) free(pcm); fclose(file); heap_caps_free(dec); G.play_handle=NULL; vTaskDelete(NULL); return; }
|
||||
size_t buffered=0;
|
||||
mp3dec_frame_info_t info;
|
||||
memset(&info,0,sizeof(info));
|
||||
bool configured=false;
|
||||
int sr=0, ch=0;
|
||||
size_t r=fread(inbuf,1,MP3_BUF,file);
|
||||
buffered=r;
|
||||
ESP_LOGI(TAG,"play task start %s size %ld resume=%d",path,fsize,resume_sec);
|
||||
long total_decoded_samples = 0;
|
||||
if(resume_sec>5){
|
||||
total_decoded_samples = (long)resume_sec * 16000;
|
||||
}
|
||||
|
||||
while(!G.need_stop){
|
||||
if(G.is_paused){
|
||||
if(configured){
|
||||
close_stream();
|
||||
configured=false;
|
||||
sr=0; ch=0;
|
||||
}
|
||||
vTaskDelay(pdMS_TO_TICKS(100));
|
||||
continue;
|
||||
}
|
||||
int samples=mp3dec_decode_frame(dec,inbuf,(int)buffered,pcm,&info);
|
||||
if(samples>0){
|
||||
total_decoded_samples += samples;
|
||||
if(info.hz>0) G.pos_sec = total_decoded_samples / info.hz;
|
||||
else G.pos_sec = total_decoded_samples / 16000;
|
||||
if(!configured || info.hz!=sr || info.channels!=ch){
|
||||
ESP_LOGI(TAG,"open_stream sr=%d ch=%d",info.hz,info.channels);
|
||||
if(!open_stream((uint32_t)info.hz,(uint8_t)info.channels)){
|
||||
ESP_LOGE(TAG,"open_stream fail %d %d",info.hz,info.channels);
|
||||
break;
|
||||
}
|
||||
ESP_LOGI(TAG,"open_stream ok");
|
||||
sr=info.hz; ch=info.channels;
|
||||
configured=true;
|
||||
if(resume_sec>5 && total_decoded_samples < (long)resume_sec * info.hz + info.hz){
|
||||
total_decoded_samples = (long)resume_sec * info.hz;
|
||||
G.pos_sec = resume_sec;
|
||||
}
|
||||
}
|
||||
float vol=G.volume/100.0f;
|
||||
if(vol<0) vol=0;
|
||||
if(vol>1) vol=1;
|
||||
int total_samples = samples * (info.channels>0?info.channels:1);
|
||||
for(int i=0;i<total_samples;i++){
|
||||
int32_t s=pcm[i];
|
||||
s=(int32_t)(s*vol);
|
||||
if(s>32767) s=32767;
|
||||
if(s<-32768) s=-32768;
|
||||
pcm[i]=(int16_t)s;
|
||||
}
|
||||
size_t to_write = total_samples * sizeof(int16_t);
|
||||
size_t off=0;
|
||||
while(off<to_write && !G.need_stop){
|
||||
if(G.is_paused){
|
||||
if(configured){
|
||||
close_stream();
|
||||
configured=false;
|
||||
sr=0; ch=0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
size_t w=0;
|
||||
error_t e=audio_stream_write(G.stream_handle,(uint8_t*)pcm+off,to_write-off,&w,pdMS_TO_TICKS(500));
|
||||
if(e==ERROR_NONE){
|
||||
off+=w;
|
||||
} else {
|
||||
ESP_LOGW(TAG,"audio_write err %d",e);
|
||||
vTaskDelay(pdMS_TO_TICKS(10));
|
||||
}
|
||||
}
|
||||
if(G.is_paused) continue;
|
||||
}
|
||||
if(info.frame_bytes>0 && info.frame_bytes <= (int)buffered){
|
||||
memmove(inbuf,inbuf+info.frame_bytes,buffered-info.frame_bytes);
|
||||
buffered-=info.frame_bytes;
|
||||
} else {
|
||||
buffered=0;
|
||||
}
|
||||
if(buffered < MP3_BUF/2){
|
||||
size_t nr=fread(inbuf+buffered,1,MP3_BUF-buffered,file);
|
||||
if(nr>0) buffered+=nr;
|
||||
else { if(samples==0) break; }
|
||||
}
|
||||
if(buffered==0) break;
|
||||
}
|
||||
fclose(file);
|
||||
free(inbuf);
|
||||
free(pcm);
|
||||
heap_caps_free(dec);
|
||||
close_stream();
|
||||
bool finished_naturally = !G.need_stop;
|
||||
if(finished_naturally){
|
||||
ESP_LOGI(TAG,"playback finished naturally for %s, clearing saved pos", ep->slug);
|
||||
set_saved_pos_for_slug(ep->slug, 0);
|
||||
G.pos_sec=0;
|
||||
save_state();
|
||||
} else {
|
||||
set_saved_pos_for_slug(ep->slug, G.pos_sec);
|
||||
save_state();
|
||||
}
|
||||
ESP_LOGI(TAG,"play task end finished_naturally=%d", finished_naturally);
|
||||
G.is_playing=false;
|
||||
G.play_handle=NULL;
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
void start_idx_internal(int idx){
|
||||
if(idx<0||idx>=G.ep_cnt) return;
|
||||
EpInfo* ep=&G.eps[idx];
|
||||
if(G.cur_ep_idx!=idx){
|
||||
int saved = get_saved_pos_for_slug(ep->slug);
|
||||
if(saved>5){
|
||||
G.pos_sec=saved;
|
||||
ESP_LOGI(TAG,"Restoring saved pos %d for %s", saved, ep->slug);
|
||||
}
|
||||
G.last_pct=-1;
|
||||
}
|
||||
tt_lvgl_lock(portMAX_DELAY);
|
||||
wait_play_exit();
|
||||
G.cur_ep_idx=idx; G.cur_season=ep->season;
|
||||
strncpy(G.cur_title,ep->title,sizeof(G.cur_title)-1);
|
||||
strncpy(G.last_slug,ep->slug,sizeof(G.last_slug)-1);
|
||||
G.need_stop=false; G.is_paused=false; G.is_playing=true;
|
||||
save_state();
|
||||
tt_lvgl_unlock();
|
||||
xTaskCreate(play_task,"dm_play",16384,NULL,5,&G.play_handle);
|
||||
}
|
||||
|
||||
void start_idx(int idx){
|
||||
if(idx<0||idx>=G.ep_cnt) return;
|
||||
EpInfo* ep=&G.eps[idx];
|
||||
if(!has_slug(ep->slug)){
|
||||
stop_playback_sync();
|
||||
tt_lvgl_lock(portMAX_DELAY);
|
||||
show_dl_overlay_locked(ep->title, ep->slug, ep->season, ep->ep_num);
|
||||
if(G.lbl_status) lv_label_set_text(G.lbl_status,"Downloading…");
|
||||
tt_lvgl_unlock();
|
||||
if(G.dl_handle){ return; }
|
||||
xTaskCreate(dl_task,"dm_dl",16384,(void*)(intptr_t)idx,5,&G.dl_handle);
|
||||
return;
|
||||
}
|
||||
start_idx_internal(idx);
|
||||
}
|
||||
|
||||
void select_ep(int idx){
|
||||
if(idx<0||idx>=G.ep_cnt) return;
|
||||
if(G.cur_ep_idx>=0 && G.cur_ep_idx < G.ep_cnt && G.cur_ep_idx!=idx){
|
||||
save_current_ep_pos();
|
||||
}
|
||||
G.cur_ep_idx=idx;
|
||||
EpInfo* ep=&G.eps[idx];
|
||||
G.cur_season=ep->season;
|
||||
strncpy(G.last_slug, ep->slug, sizeof(G.last_slug)-1);
|
||||
|
||||
int saved = get_saved_pos_for_slug(ep->slug);
|
||||
if(saved>5){
|
||||
G.pos_sec=saved;
|
||||
ESP_LOGI(TAG,"select_ep restore %s pos=%d", ep->slug, saved);
|
||||
} else {
|
||||
G.pos_sec=saved;
|
||||
}
|
||||
G.last_pct=-1;
|
||||
G.total_sec=0;
|
||||
|
||||
tt_lvgl_lock(portMAX_DELAY);
|
||||
if(G.lbl_title) lv_label_set_text(G.lbl_title,ep->title);
|
||||
if(G.lbl_meta){
|
||||
char b[64];
|
||||
if(saved>5){
|
||||
char tbuf[16];
|
||||
fmt_time(tbuf,saved);
|
||||
snprintf(b,sizeof(b),"S%02d E%02d %s • %s",ep->season,ep->ep_num,ep->seen?"*":"",tbuf);
|
||||
} else {
|
||||
snprintf(b,sizeof(b),"S%02d E%02d %s",ep->season,ep->ep_num,ep->seen?"*":"");
|
||||
}
|
||||
lv_label_set_text(G.lbl_meta,b);
|
||||
}
|
||||
if(G.lbl_status){
|
||||
if(saved>5) lv_label_set_text(G.lbl_status,"Resume – tap Play");
|
||||
else lv_label_set_text(G.lbl_status,ep->seen?"On SD – tap Play":"Tap Play to download");
|
||||
}
|
||||
if(G.bar){
|
||||
lv_bar_set_value(G.bar,0,LV_ANIM_OFF);
|
||||
}
|
||||
if(G.lbl_time){
|
||||
if(saved>5){
|
||||
char a[16];
|
||||
fmt_time(a,saved);
|
||||
char buf[40];
|
||||
snprintf(buf,sizeof(buf),"%s / --:--",a);
|
||||
lv_label_set_text(G.lbl_time,buf);
|
||||
} else {
|
||||
lv_label_set_text(G.lbl_time,"0:00 / --:--");
|
||||
}
|
||||
}
|
||||
tt_lvgl_unlock();
|
||||
save_state();
|
||||
}
|
||||
|
||||
void go_next(){
|
||||
if(G.ep_cnt==0) return;
|
||||
save_current_ep_pos();
|
||||
save_state();
|
||||
stop_playback_sync();
|
||||
int n=G.cur_ep_idx+1;
|
||||
if(n>=G.ep_cnt) n=0;
|
||||
select_ep(n);
|
||||
start_idx(n);
|
||||
}
|
||||
void go_prev(){
|
||||
if(G.ep_cnt==0) return;
|
||||
if(G.pos_sec>5){
|
||||
ESP_LOGI(TAG,"go_prev restart current %d sec",G.pos_sec);
|
||||
if(G.cur_ep_idx>=0){
|
||||
set_saved_pos_for_slug(G.eps[G.cur_ep_idx].slug, 0);
|
||||
save_state();
|
||||
}
|
||||
stop_playback_sync();
|
||||
G.pos_sec=0;
|
||||
int cur=G.cur_ep_idx;
|
||||
if(cur<0) cur=0;
|
||||
select_ep(cur);
|
||||
start_idx(cur);
|
||||
return;
|
||||
}
|
||||
save_current_ep_pos();
|
||||
save_state();
|
||||
stop_playback_sync();
|
||||
int p=G.cur_ep_idx-1;
|
||||
if(p<0) p=G.ep_cnt-1;
|
||||
select_ep(p);
|
||||
start_idx(p);
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
#pragma once
|
||||
|
||||
#include "app_context.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
bool find_audio_device(void);
|
||||
void close_stream(void);
|
||||
bool open_stream(uint32_t sr, uint8_t ch);
|
||||
void wait_play_exit(void);
|
||||
void stop_playback_sync(void);
|
||||
|
||||
void play_task(void* arg);
|
||||
void start_idx_internal(int idx);
|
||||
void start_idx(int idx);
|
||||
void select_ep(int idx);
|
||||
void go_next(void);
|
||||
void go_prev(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,203 @@
|
||||
#include "storage.h"
|
||||
#include "cJSON.h"
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <dirent.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
void make_sd_path(char* out, size_t out_len, const char* slug){
|
||||
if(!out || !slug) return;
|
||||
snprintf(out, out_len, "%s/%s.mp3", DM_DIR, slug);
|
||||
}
|
||||
void ensure_dir(){
|
||||
mkdir("/sdcard/apps",0777);
|
||||
mkdir("/sdcard/apps/one.tactility.discoverymountain",0777);
|
||||
mkdir("/sdcard/apps/one.tactility.discoverymountain/userdata",0777);
|
||||
mkdir(DM_DIR,0777);
|
||||
}
|
||||
bool has_slug(const char* slug){
|
||||
char p[300];
|
||||
make_sd_path(p, sizeof(p), slug);
|
||||
struct stat st;
|
||||
return stat(p,&st)==0;
|
||||
}
|
||||
|
||||
void fmt_time(char* o,int s){ snprintf(o,16,"%d:%02d",s/60,s%60); }
|
||||
|
||||
void sort_seasons(){
|
||||
for(int i=0;i<G.season_cnt;i++){
|
||||
for(int j=i+1;j<G.season_cnt;j++){
|
||||
if(G.seasons[j].num < G.seasons[i].num){
|
||||
SeasonInfo t=G.seasons[i]; G.seasons[i]=G.seasons[j]; G.seasons[j]=t;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void sort_eps(){
|
||||
for(int i=0;i<G.ep_cnt;i++){
|
||||
for(int j=i+1;j<G.ep_cnt;j++){
|
||||
EpInfo *a=&G.eps[i], *b=&G.eps[j];
|
||||
bool should_swap=false;
|
||||
if(a->season != b->season) should_swap = (b->season < a->season);
|
||||
else should_swap = (b->ep_num < a->ep_num);
|
||||
if(should_swap){
|
||||
EpInfo t=*a; *a=*b; *b=t;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── Per-episode position helpers ──
|
||||
int find_saved_pos_idx(const char* slug){
|
||||
if(!slug) return -1;
|
||||
for(int i=0;i<G.saved_pos_cnt;i++){
|
||||
if(strcmp(G.saved_pos[i].slug, slug)==0) return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int get_saved_pos_for_slug(const char* slug){
|
||||
int idx=find_saved_pos_idx(slug);
|
||||
if(idx>=0) return G.saved_pos[idx].pos;
|
||||
return 0;
|
||||
}
|
||||
void set_saved_pos_for_slug(const char* slug, int pos){
|
||||
if(!slug || strlen(slug)==0) return;
|
||||
if(pos<0) pos=0;
|
||||
if(G.total_sec>0 && pos>0 && pos >= G.total_sec-10){
|
||||
pos=0;
|
||||
}
|
||||
int idx=find_saved_pos_idx(slug);
|
||||
if(idx>=0){
|
||||
G.saved_pos[idx].pos=pos;
|
||||
return;
|
||||
}
|
||||
if(G.saved_pos_cnt < MAX_EPS){
|
||||
strncpy(G.saved_pos[G.saved_pos_cnt].slug, slug, sizeof(G.saved_pos[G.saved_pos_cnt].slug)-1);
|
||||
G.saved_pos[G.saved_pos_cnt].slug[sizeof(G.saved_pos[G.saved_pos_cnt].slug)-1]=0;
|
||||
G.saved_pos[G.saved_pos_cnt].pos=pos;
|
||||
G.saved_pos_cnt++;
|
||||
}
|
||||
}
|
||||
void save_current_ep_pos(){
|
||||
if(G.cur_ep_idx>=0 && G.cur_ep_idx < G.ep_cnt){
|
||||
const char* slug=G.eps[G.cur_ep_idx].slug;
|
||||
set_saved_pos_for_slug(slug, G.pos_sec);
|
||||
} else if(strlen(G.last_slug)>0){
|
||||
set_saved_pos_for_slug(G.last_slug, G.pos_sec);
|
||||
}
|
||||
}
|
||||
|
||||
void save_state(){
|
||||
if(G.cur_ep_idx>=0 && G.ep_cnt>0){
|
||||
if(G.pos_sec>=0){
|
||||
set_saved_pos_for_slug(G.eps[G.cur_ep_idx].slug, G.pos_sec);
|
||||
}
|
||||
}
|
||||
cJSON* r=cJSON_CreateObject();
|
||||
if(G.ep_cnt>0 && G.cur_ep_idx>=0 && G.cur_ep_idx < G.ep_cnt) cJSON_AddStringToObject(r,"last_slug",G.eps[G.cur_ep_idx].slug);
|
||||
else if(strlen(G.last_slug)>0) cJSON_AddStringToObject(r,"last_slug",G.last_slug);
|
||||
cJSON_AddNumberToObject(r,"last_season",G.cur_season);
|
||||
cJSON_AddNumberToObject(r,"pos_sec",G.pos_sec);
|
||||
if(G.saved_pos_cnt>0){
|
||||
cJSON* pos_obj=cJSON_CreateObject();
|
||||
for(int i=0;i<G.saved_pos_cnt;i++){
|
||||
if(G.saved_pos[i].slug[0]==0) continue;
|
||||
if(G.saved_pos[i].pos>0){
|
||||
cJSON_AddNumberToObject(pos_obj, G.saved_pos[i].slug, G.saved_pos[i].pos);
|
||||
}
|
||||
}
|
||||
cJSON_AddItemToObject(r,"positions",pos_obj);
|
||||
}
|
||||
char* s=cJSON_PrintUnformatted(r);
|
||||
if(s){
|
||||
FILE* f=fopen(STATE_PATH,"w");
|
||||
if(f){ fwrite(s,1,strlen(s),f); fclose(f);}
|
||||
free(s);
|
||||
}
|
||||
cJSON_Delete(r);
|
||||
}
|
||||
|
||||
void load_state(){
|
||||
G.cur_season=1; G.cur_ep_idx=-1; G.pos_sec=0;
|
||||
G.saved_pos_cnt=0;
|
||||
G.last_save_tick=0;
|
||||
memset(G.last_slug,0,sizeof(G.last_slug));
|
||||
memset(G.saved_pos,0,sizeof(G.saved_pos));
|
||||
FILE* f=fopen(STATE_PATH,"r");
|
||||
if(!f) return;
|
||||
fseek(f,0,SEEK_END);
|
||||
long sz=ftell(f);
|
||||
fseek(f,0,SEEK_SET);
|
||||
if(sz<=0||sz>16384){ fclose(f); return;}
|
||||
char* buf=malloc(sz+1);
|
||||
if(!buf){ fclose(f); return; }
|
||||
size_t got=fread(buf,1,sz,f);
|
||||
buf[got]=0;
|
||||
fclose(f);
|
||||
cJSON* r=cJSON_Parse(buf);
|
||||
free(buf);
|
||||
if(!r) return;
|
||||
cJSON* ls=cJSON_GetObjectItem(r,"last_slug");
|
||||
cJSON* lsn=cJSON_GetObjectItem(r,"last_season");
|
||||
cJSON* ps=cJSON_GetObjectItem(r,"pos_sec");
|
||||
if(ps&&cJSON_IsNumber(ps)) G.pos_sec=ps->valueint;
|
||||
if(lsn&&cJSON_IsNumber(lsn)) G.cur_season=lsn->valueint;
|
||||
if(ls&&cJSON_IsString(ls)){
|
||||
strncpy(G.last_slug, ls->valuestring, sizeof(G.last_slug)-1);
|
||||
for(int i=0;i<G.ep_cnt;i++) if(strcmp(G.eps[i].slug,ls->valuestring)==0){ G.cur_ep_idx=i; G.cur_season=G.eps[i].season; break; }
|
||||
}
|
||||
cJSON* poss=cJSON_GetObjectItem(r,"positions");
|
||||
if(poss && cJSON_IsObject(poss)){
|
||||
cJSON* child=NULL;
|
||||
cJSON_ArrayForEach(child, poss){
|
||||
if(cJSON_IsNumber(child) && child->string && G.saved_pos_cnt < MAX_EPS){
|
||||
strncpy(G.saved_pos[G.saved_pos_cnt].slug, child->string, sizeof(G.saved_pos[G.saved_pos_cnt].slug)-1);
|
||||
G.saved_pos[G.saved_pos_cnt].pos=child->valueint;
|
||||
G.saved_pos_cnt++;
|
||||
}
|
||||
}
|
||||
if(strlen(G.last_slug)>0){
|
||||
int sp=get_saved_pos_for_slug(G.last_slug);
|
||||
if(sp>0) G.pos_sec=sp;
|
||||
}
|
||||
}
|
||||
cJSON_Delete(r);
|
||||
}
|
||||
|
||||
void lru_check(){
|
||||
typedef struct{ char path[300]; time_t mt; } FE;
|
||||
FE files[200];
|
||||
int fc=0;
|
||||
DIR* d=opendir(DM_DIR);
|
||||
if(!d) return;
|
||||
struct dirent* de;
|
||||
char cur_path[300]={0};
|
||||
if(G.cur_ep_idx>=0 && G.cur_ep_idx<G.ep_cnt){
|
||||
make_sd_path(cur_path, sizeof(cur_path), G.eps[G.cur_ep_idx].slug);
|
||||
}
|
||||
while((de=readdir(d))!=NULL && fc<200){
|
||||
if(de->d_name[0]=='.') continue;
|
||||
size_t l=strlen(de->d_name);
|
||||
if(l<5) continue;
|
||||
if(strcmp(de->d_name+l-4,".mp3")!=0) continue;
|
||||
char full[300];
|
||||
snprintf(full,sizeof(full),"%s/%.200s",DM_DIR,de->d_name);
|
||||
struct stat st;
|
||||
if(stat(full,&st)!=0) continue;
|
||||
if(cur_path[0] && strcmp(full,cur_path)==0) continue;
|
||||
strncpy(files[fc].path,full,sizeof(files[fc].path)-1);
|
||||
files[fc].mt=st.st_mtime;
|
||||
fc++;
|
||||
}
|
||||
closedir(d);
|
||||
if(fc<12) return;
|
||||
for(int i=0;i<fc;i++){
|
||||
for(int j=i+1;j<fc;j++){
|
||||
if(files[j].mt<files[i].mt){ FE t=files[i]; files[i]=files[j]; files[j]=t; }
|
||||
}
|
||||
}
|
||||
int todel=fc-8;
|
||||
for(int i=0;i<todel;i++) unlink(files[i].path);
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
#pragma once
|
||||
|
||||
#include "app_context.h"
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// Path helpers
|
||||
void make_sd_path(char* out, size_t out_len, const char* slug);
|
||||
void ensure_dir(void);
|
||||
bool has_slug(const char* slug);
|
||||
|
||||
// LRU cache cleanup
|
||||
void lru_check(void);
|
||||
|
||||
// Sorting
|
||||
void sort_seasons(void);
|
||||
void sort_eps(void);
|
||||
|
||||
// Time formatting
|
||||
void fmt_time(char* o, int s);
|
||||
|
||||
// Per-episode resume helpers
|
||||
int find_saved_pos_idx(const char* slug);
|
||||
int get_saved_pos_for_slug(const char* slug);
|
||||
void set_saved_pos_for_slug(const char* slug, int pos);
|
||||
void save_current_ep_pos(void);
|
||||
|
||||
// Persistence
|
||||
void save_state(void);
|
||||
void load_state(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,244 @@
|
||||
#include "ui.h"
|
||||
#include "storage.h"
|
||||
#include "player.h"
|
||||
#include "download.h"
|
||||
|
||||
#include <tt_lvgl.h>
|
||||
#include <tactility/lvgl_fonts.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "esp_log.h"
|
||||
|
||||
void close_overlay(){
|
||||
if(G.overlay){
|
||||
lv_obj_delete(G.overlay);
|
||||
G.overlay=NULL;
|
||||
G.dropdown=NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void dropdown_cb(lv_event_t* e){
|
||||
if(lv_event_get_code(e)!=LV_EVENT_VALUE_CHANGED) return;
|
||||
lv_obj_t* dd = (lv_obj_t*)lv_event_get_target(e);
|
||||
int sel=lv_dropdown_get_selected(dd);
|
||||
if(sel<0||sel>=G.season_cnt) return;
|
||||
int sn=G.seasons[sel].num;
|
||||
close_overlay();
|
||||
int first=-1, first_unseen=-1;
|
||||
for(int i=0;i<G.ep_cnt;i++) if(G.eps[i].season==sn){
|
||||
if(first==-1) first=i;
|
||||
if(!G.eps[i].seen && first_unseen==-1) first_unseen=i;
|
||||
}
|
||||
int tgt=first_unseen!=-1?first_unseen:first;
|
||||
if(tgt!=-1){
|
||||
G.cur_season=sn;
|
||||
select_ep(tgt);
|
||||
}
|
||||
}
|
||||
|
||||
void btn_seasons_cb(lv_event_t* e){
|
||||
(void)e;
|
||||
if(G.downloading) return;
|
||||
if(G.overlay){ close_overlay(); return; }
|
||||
tt_lvgl_lock(portMAX_DELAY);
|
||||
G.overlay=lv_obj_create(lv_scr_act());
|
||||
lv_obj_set_size(G.overlay,240,280);
|
||||
lv_obj_center(G.overlay);
|
||||
lv_obj_set_style_bg_color(G.overlay,lv_color_hex(0x222222),0);
|
||||
lv_obj_set_style_radius(G.overlay,12,0);
|
||||
lv_obj_t* title=lv_label_create(G.overlay);
|
||||
lv_label_set_text(title,"Select Season");
|
||||
lv_obj_align(title,LV_ALIGN_TOP_MID,0,8);
|
||||
|
||||
static char opts[1024];
|
||||
opts[0]=0;
|
||||
for(int i=0;i<G.season_cnt;i++){
|
||||
char line[16];
|
||||
if(i==0) snprintf(opts,sizeof(opts),"S%d",G.seasons[i].num);
|
||||
else { snprintf(line,sizeof(line),"\nS%d",G.seasons[i].num); strncat(opts,line,sizeof(opts)-strlen(opts)-1); }
|
||||
}
|
||||
G.dropdown=lv_dropdown_create(G.overlay);
|
||||
lv_dropdown_set_options(G.dropdown, opts);
|
||||
lv_obj_set_size(G.dropdown,160,40);
|
||||
lv_obj_align(G.dropdown,LV_ALIGN_CENTER,0,10);
|
||||
int sel=0;
|
||||
for(int i=0;i<G.season_cnt;i++) if(G.seasons[i].num==G.cur_season) sel=i;
|
||||
lv_dropdown_set_selected(G.dropdown, sel);
|
||||
lv_obj_add_event_cb(G.dropdown,dropdown_cb,LV_EVENT_VALUE_CHANGED,NULL);
|
||||
|
||||
lv_obj_t* bc=lv_btn_create(G.overlay);
|
||||
lv_obj_set_size(bc,80,32);
|
||||
lv_obj_align(bc,LV_ALIGN_BOTTOM_MID,0,-8);
|
||||
lv_obj_t* lc=lv_label_create(bc);
|
||||
lv_label_set_text(lc,"Close");
|
||||
lv_obj_center(lc);
|
||||
lv_obj_add_event_cb(bc,(lv_event_cb_t)close_overlay,LV_EVENT_CLICKED,NULL);
|
||||
tt_lvgl_unlock();
|
||||
}
|
||||
|
||||
void build_ui(){
|
||||
tt_lvgl_lock(portMAX_DELAY);
|
||||
lv_obj_t* root=lv_obj_create(lv_scr_act());
|
||||
lv_obj_set_size(root,LV_PCT(100),LV_PCT(100));
|
||||
lv_obj_set_style_bg_color(root,lv_color_hex(0x111111),0);
|
||||
lv_obj_set_style_pad_all(root,8,0);
|
||||
lv_obj_set_style_border_width(root,0,0);
|
||||
lv_obj_remove_flag(root, LV_OBJ_FLAG_SCROLLABLE);
|
||||
|
||||
G.lbl_title=lv_label_create(root);
|
||||
lv_label_set_text(G.lbl_title,"Discovery Mountain");
|
||||
lv_obj_set_style_text_font(G.lbl_title, lvgl_get_text_font(FONT_SIZE_DEFAULT), 0);
|
||||
lv_obj_set_width(G.lbl_title,LV_PCT(100));
|
||||
lv_label_set_long_mode(G.lbl_title,LV_LABEL_LONG_WRAP);
|
||||
lv_obj_align(G.lbl_title,LV_ALIGN_TOP_LEFT,0,0);
|
||||
|
||||
G.lbl_meta=lv_label_create(root);
|
||||
lv_label_set_text(G.lbl_meta,"Loading...");
|
||||
lv_obj_set_style_text_color(G.lbl_meta,lv_color_hex(0xAAAAAA),0);
|
||||
lv_obj_align(G.lbl_meta,LV_ALIGN_TOP_LEFT,0,28);
|
||||
|
||||
G.bar=lv_bar_create(root);
|
||||
lv_obj_set_size(G.bar,LV_PCT(100),12);
|
||||
lv_obj_align(G.bar,LV_ALIGN_TOP_LEFT,0,50);
|
||||
lv_bar_set_value(G.bar,0,LV_ANIM_OFF);
|
||||
|
||||
G.lbl_time=lv_label_create(root);
|
||||
lv_label_set_text(G.lbl_time,"0:00 / --:--");
|
||||
lv_obj_align(G.lbl_time,LV_ALIGN_TOP_LEFT,0,66);
|
||||
|
||||
G.lbl_status=lv_label_create(root);
|
||||
lv_label_set_text(G.lbl_status,"Fetching data...");
|
||||
lv_obj_set_style_text_color(G.lbl_status,lv_color_hex(0x888888),0);
|
||||
lv_obj_align(G.lbl_status,LV_ALIGN_TOP_LEFT,0,82);
|
||||
|
||||
lv_obj_t* row=lv_obj_create(root);
|
||||
lv_obj_set_size(row,LV_PCT(100),56);
|
||||
lv_obj_align(row,LV_ALIGN_TOP_LEFT,0,104);
|
||||
lv_obj_set_flex_flow(row,LV_FLEX_FLOW_ROW);
|
||||
lv_obj_set_flex_align(row,LV_FLEX_ALIGN_SPACE_EVENLY,LV_FLEX_ALIGN_CENTER,LV_FLEX_ALIGN_CENTER);
|
||||
lv_obj_set_style_bg_opa(row,LV_OPA_TRANSP,0);
|
||||
lv_obj_set_style_border_width(row,0,0);
|
||||
lv_obj_remove_flag(row, LV_OBJ_FLAG_SCROLLABLE);
|
||||
|
||||
lv_obj_t* b1=lv_btn_create(row);
|
||||
lv_obj_set_size(b1,56,48);
|
||||
lv_obj_t* l1=lv_label_create(b1);
|
||||
lv_label_set_text(l1,LV_SYMBOL_PREV);
|
||||
lv_obj_center(l1);
|
||||
lv_obj_add_event_cb(b1,btn_prev_cb,LV_EVENT_CLICKED,NULL);
|
||||
|
||||
G.btn_play=lv_btn_create(row);
|
||||
lv_obj_set_size(G.btn_play,72,48);
|
||||
lv_obj_set_style_bg_color(G.btn_play,lv_color_hex(0x2E7D32),0);
|
||||
lv_obj_t* l2=lv_label_create(G.btn_play);
|
||||
lv_label_set_text(l2,LV_SYMBOL_PLAY);
|
||||
lv_obj_center(l2);
|
||||
lv_obj_add_event_cb(G.btn_play,btn_play_cb,LV_EVENT_CLICKED,NULL);
|
||||
|
||||
lv_obj_t* b3=lv_btn_create(row);
|
||||
lv_obj_set_size(b3,56,48);
|
||||
lv_obj_t* l3=lv_label_create(b3);
|
||||
lv_label_set_text(l3,LV_SYMBOL_NEXT);
|
||||
lv_obj_center(l3);
|
||||
lv_obj_add_event_cb(b3,btn_next_cb,LV_EVENT_CLICKED,NULL);
|
||||
|
||||
lv_obj_t* row2=lv_obj_create(root);
|
||||
lv_obj_set_size(row2,LV_PCT(100),44);
|
||||
lv_obj_align(row2,LV_ALIGN_BOTTOM_LEFT,0,0);
|
||||
lv_obj_set_flex_flow(row2,LV_FLEX_FLOW_ROW);
|
||||
lv_obj_set_flex_align(row2,LV_FLEX_ALIGN_SPACE_EVENLY,LV_FLEX_ALIGN_CENTER,LV_FLEX_ALIGN_CENTER);
|
||||
lv_obj_set_style_bg_opa(row2,LV_OPA_TRANSP,0);
|
||||
lv_obj_set_style_border_width(row2,0,0);
|
||||
lv_obj_remove_flag(row2, LV_OBJ_FLAG_SCROLLABLE);
|
||||
|
||||
lv_obj_t* bs=lv_btn_create(row2);
|
||||
lv_obj_set_size(bs,LV_PCT(100),36);
|
||||
lv_obj_t* ls=lv_label_create(bs);
|
||||
lv_label_set_text(ls,"Seasons");
|
||||
lv_obj_center(ls);
|
||||
lv_obj_add_event_cb(bs,btn_seasons_cb,LV_EVENT_CLICKED,NULL);
|
||||
|
||||
lv_timer_create(ui_timer,200,NULL);
|
||||
tt_lvgl_unlock();
|
||||
}
|
||||
|
||||
void ui_timer(lv_timer_t* t){
|
||||
(void)t;
|
||||
if(G.downloading){
|
||||
update_dl_overlay_ui();
|
||||
}
|
||||
if(G.bar){
|
||||
if(G.total_sec>0){
|
||||
int pct=G.pos_sec*100/G.total_sec;
|
||||
if(pct>100) pct=100;
|
||||
if(pct!=G.last_pct){
|
||||
G.last_pct=pct;
|
||||
lv_bar_set_value(G.bar,pct,LV_ANIM_OFF);
|
||||
}
|
||||
} else if(G.is_playing){
|
||||
int pct=(G.pos_sec%10)*10;
|
||||
if(pct!=G.last_pct){
|
||||
G.last_pct=pct;
|
||||
lv_bar_set_value(G.bar,pct,LV_ANIM_OFF);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(G.lbl_time){
|
||||
char a[16],b[16];
|
||||
fmt_time(a,G.pos_sec);
|
||||
if(G.total_sec>0) fmt_time(b,G.total_sec);
|
||||
else snprintf(b,sizeof(b),"--:--");
|
||||
char buf[40];
|
||||
snprintf(buf,sizeof(buf),"%s / %s",a,b);
|
||||
lv_label_set_text(G.lbl_time,buf);
|
||||
}
|
||||
if(G.is_playing && G.lbl_status && !G.downloading){
|
||||
const char* cur = lv_label_get_text(G.lbl_status);
|
||||
if(!cur || strcmp(cur,"Playing")!=0) lv_label_set_text(G.lbl_status,"Playing");
|
||||
}
|
||||
if(G.is_playing && !G.is_paused && !G.downloading){
|
||||
G.last_save_tick++;
|
||||
if(G.last_save_tick >= 25){
|
||||
G.last_save_tick=0;
|
||||
save_current_ep_pos();
|
||||
save_state();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void btn_play_cb(lv_event_t* e){
|
||||
(void)e;
|
||||
if(G.downloading){
|
||||
return;
|
||||
}
|
||||
if(G.is_playing && !G.is_paused){
|
||||
G.is_paused=true;
|
||||
save_current_ep_pos();
|
||||
save_state();
|
||||
tt_lvgl_lock(portMAX_DELAY);
|
||||
if(G.lbl_status) lv_label_set_text(G.lbl_status,"Paused");
|
||||
if(G.btn_play){
|
||||
lv_obj_t* ch=lv_obj_get_child(G.btn_play,0);
|
||||
if(ch) lv_label_set_text(ch,LV_SYMBOL_PLAY);
|
||||
}
|
||||
tt_lvgl_unlock();
|
||||
} else if(G.is_paused){
|
||||
G.is_paused=false;
|
||||
tt_lvgl_lock(portMAX_DELAY);
|
||||
if(G.btn_play){
|
||||
lv_obj_t* ch=lv_obj_get_child(G.btn_play,0);
|
||||
if(ch) lv_label_set_text(ch,LV_SYMBOL_PAUSE);
|
||||
}
|
||||
tt_lvgl_unlock();
|
||||
} else {
|
||||
start_idx(G.cur_ep_idx);
|
||||
tt_lvgl_lock(portMAX_DELAY);
|
||||
if(G.btn_play){
|
||||
lv_obj_t* ch=lv_obj_get_child(G.btn_play,0);
|
||||
if(ch) lv_label_set_text(ch,LV_SYMBOL_PAUSE);
|
||||
}
|
||||
tt_lvgl_unlock();
|
||||
}
|
||||
}
|
||||
void btn_prev_cb(lv_event_t* e){ (void)e; if(G.downloading) return; go_prev(); }
|
||||
void btn_next_cb(lv_event_t* e){ (void)e; if(G.downloading) return; go_next(); }
|
||||
@@ -0,0 +1,21 @@
|
||||
#pragma once
|
||||
|
||||
#include "app_context.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void build_ui(void);
|
||||
void ui_timer(lv_timer_t* t);
|
||||
|
||||
void btn_play_cb(lv_event_t* e);
|
||||
void btn_prev_cb(lv_event_t* e);
|
||||
void btn_next_cb(lv_event_t* e);
|
||||
void btn_seasons_cb(lv_event_t* e);
|
||||
void close_overlay(void);
|
||||
void dropdown_cb(lv_event_t* e);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user