#include #include #include #include #include #include #include #include #include #include #include #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "esp_log.h" #include "cJSON.h" #ifdef ESP_PLATFORM #include #endif #define MINIMP3_IMPLEMENTATION #define MINIMP3_NO_SIMD #include "minimp3.h" #define TAG "BookPlayer" #define MP3_INPUT_BUFFER_SIZE 16384 #define MAX_BOOKS 32 #define MAX_PATH 256 #define MAX_TITLE 128 #define MAX_AUTHOR 128 typedef enum { STATE_IDLE, STATE_PLAYING, STATE_PAUSED } PlaybackState; typedef struct { char slug[MAX_PATH]; char title[MAX_TITLE]; char author[MAX_AUTHOR]; } BookMetadata; typedef struct { struct Device* i2s_dev; PlaybackState state; int volume; // Book picker list data BookMetadata books[MAX_BOOKS]; int book_count; // Currently loaded book details char current_book_slug[MAX_PATH]; cJSON* manifest_root; cJSON* pages_array; int page_count; int current_page; int last_pct; // UI elements AppHandle app; lv_obj_t* picker_wrapper; lv_obj_t* lst_books; lv_obj_t* player_wrapper; lv_obj_t* header_bar; lv_obj_t* ctrl_bar; lv_obj_t* lbl_book_title; lv_obj_t* img_page; lv_obj_t* lbl_indicator; lv_obj_t* bar_progress; lv_obj_t* btn_play_pause; lv_obj_t* btn_prev; lv_obj_t* btn_next; // Audio State char current_audio_path[512]; uint8_t* audio_buf; // Shared MP3 input and WAV buffer mp3d_sample_t* pcm_buf; // MP3 decoded pcm buffer TaskHandle_t playback_task_handle; } AppCtx; typedef struct __attribute__((packed)) { char riff[4]; // "RIFF" uint32_t overall_size; // file size - 8 char wave[4]; // "WAVE" char fmt_chunk_marker[4]; // "fmt " uint32_t length_of_fmt; // 16 for PCM uint16_t format_type; // 1 for PCM uint16_t channels; // 1 for mono uint32_t sample_rate; // 16000 uint32_t byterate; // sample_rate * channels * (bits_per_sample / 8) uint16_t block_align; // channels * (bits_per_sample / 8) uint16_t bits_per_sample; // 16 char data_chunk_header[4]; // "data" uint32_t data_size; // data size in bytes } WavHeader; static AppCtx g_ctx; /* ─── Forward Declarations ─── */ static void update_ui(AppCtx* ctx); static void wait_for_playback_task_to_exit(AppCtx* ctx); static void load_page(AppCtx* ctx, int page_index, bool start_audio); static void return_to_picker(AppCtx* ctx); static void audio_playback_task(void* arg); static void play_mp3(AppCtx* ctx); static void play_wav(AppCtx* ctx); static void scan_books(AppCtx* ctx); /* ─── UI Helper to update status labels & button states ─── */ static void update_ui(AppCtx* ctx) { if (!ctx->btn_play_pause) return; lv_obj_t* lbl_play = lv_obj_get_child(ctx->btn_play_pause, 0); // Prev button state if (ctx->current_page <= 0) { lv_obj_add_state(ctx->btn_prev, LV_STATE_DISABLED); } else { lv_obj_clear_state(ctx->btn_prev, LV_STATE_DISABLED); } // Next button state if (ctx->current_page >= ctx->page_count - 1) { lv_obj_add_state(ctx->btn_next, LV_STATE_DISABLED); } else { lv_obj_clear_state(ctx->btn_next, LV_STATE_DISABLED); } switch (ctx->state) { case STATE_PLAYING: if (lbl_play) lv_label_set_text(lbl_play, LV_SYMBOL_PAUSE " Pause"); break; case STATE_PAUSED: if (lbl_play) lv_label_set_text(lbl_play, LV_SYMBOL_PLAY " Play"); break; case STATE_IDLE: default: if (lbl_play) lv_label_set_text(lbl_play, LV_SYMBOL_PLAY " Play"); lv_bar_set_value(ctx->bar_progress, 0, LV_ANIM_OFF); break; } } /* ─── Read entire file to string ─── */ static char* read_full_file(const char* filepath) { FILE* file = fopen(filepath, "rb"); if (!file) { ESP_LOGE(TAG, "Failed to open file: %s", filepath); return NULL; } fseek(file, 0, SEEK_END); long size = ftell(file); if (size <= 0) { fclose(file); return NULL; } fseek(file, 0, SEEK_SET); char* buf = malloc(size + 1); if (!buf) { fclose(file); return NULL; } size_t read_bytes = fread(buf, 1, size, file); buf[read_bytes] = '\0'; fclose(file); return buf; } /* ─── Auto-advance logic using LVGL Timer on main thread ─── */ static void on_auto_advance_timer(lv_timer_t* timer) { AppCtx* ctx = (AppCtx*)lv_timer_get_user_data(timer); if (ctx->current_page + 1 < ctx->page_count) { load_page(ctx, ctx->current_page + 1, true); } } static void handle_audio_finished(AppCtx* ctx) { if (ctx->current_page + 1 < ctx->page_count) { // Create a one-shot timer with repeat count 1 to run on the GUI thread lv_timer_t* timer = lv_timer_create(on_auto_advance_timer, 0, ctx); lv_timer_set_repeat_count(timer, 1); } else { ctx->state = STATE_IDLE; update_ui(ctx); } } /* ─── Helper to wait for playback thread to terminate safely ─── */ static void wait_for_playback_task_to_exit(AppCtx* ctx) { if (ctx->playback_task_handle != NULL) { ctx->state = STATE_IDLE; while (ctx->playback_task_handle != NULL) { tt_lvgl_unlock(); vTaskDelay(pdMS_TO_TICKS(10)); tt_lvgl_lock(portMAX_DELAY); } } } /* ─── Load Page Content (Image, Caption, Audio path) ─── */ static void load_page(AppCtx* ctx, int page_index, bool start_audio) { // 1. Stop current audio if running and wait for thread to finish wait_for_playback_task_to_exit(ctx); if (page_index < 0 || page_index >= ctx->page_count) return; ctx->current_page = page_index; ctx->last_pct = -1; cJSON* page = cJSON_GetArrayItem(ctx->pages_array, page_index); if (!page) return; cJSON* img_item = cJSON_GetObjectItem(page, "image"); cJSON* snd_item = cJSON_GetObjectItem(page, "audio"); // Load Image file if (img_item && img_item->valuestring) { char img_path[512]; snprintf(img_path, sizeof(img_path), "/sdcard/books/%s/%s", ctx->current_book_slug, img_item->valuestring); FILE* img_file = fopen(img_path, "rb"); if (img_file) { fclose(img_file); char lv_img_path[1024]; #ifdef ESP_PLATFORM snprintf(lv_img_path, sizeof(lv_img_path), "A:%s", img_path); #else snprintf(lv_img_path, sizeof(lv_img_path), "A:/%s", img_path); #endif lv_image_set_src(ctx->img_page, lv_img_path); } else { ESP_LOGW(TAG, "Image file not found: %s", img_path); lv_image_set_src(ctx->img_page, LV_SYMBOL_IMAGE); // Show default fallback icon } } else { lv_image_set_src(ctx->img_page, LV_SYMBOL_IMAGE); } // Update Page index indicator (e.g. "1 / 12") char ind_buf[32]; snprintf(ind_buf, sizeof(ind_buf), "%d / %d", page_index + 1, ctx->page_count); lv_label_set_text(ctx->lbl_indicator, ind_buf); // Save audio path if (snd_item && snd_item->valuestring) { snprintf(ctx->current_audio_path, sizeof(ctx->current_audio_path), "/sdcard/books/%s/%s", ctx->current_book_slug, snd_item->valuestring); } else { ctx->current_audio_path[0] = '\0'; } // Update UI states (like Prev/Next buttons) update_ui(ctx); // Start playback if requested and valid if (start_audio && ctx->current_audio_path[0] != '\0') { // Verify audio file exists FILE* audio_file = fopen(ctx->current_audio_path, "rb"); if (audio_file) { fclose(audio_file); ctx->state = STATE_PLAYING; update_ui(ctx); xTaskCreate(audio_playback_task, "audio_play", 4096, ctx, 5, &ctx->playback_task_handle); } else { ESP_LOGE(TAG, "Audio file not found: %s", ctx->current_audio_path); const char* buttons[] = {"OK"}; tt_app_alertdialog_start("Playback Error", "The narration audio file is missing.", buttons, 1); ctx->state = STATE_IDLE; update_ui(ctx); } } else { ctx->state = STATE_IDLE; update_ui(ctx); } } /* ─── Return to Book Picker Screen ─── */ static void return_to_picker(AppCtx* ctx) { wait_for_playback_task_to_exit(ctx); if (ctx->manifest_root) { cJSON_Delete(ctx->manifest_root); ctx->manifest_root = NULL; ctx->pages_array = NULL; } lv_obj_add_flag(ctx->player_wrapper, LV_OBJ_FLAG_HIDDEN); lv_obj_remove_flag(ctx->picker_wrapper, LV_OBJ_FLAG_HIDDEN); } /* ─── Task Selection (MP3 or WAV) ─── */ static void audio_playback_task(void* arg) { AppCtx* ctx = (AppCtx*)arg; size_t len = strlen(ctx->current_audio_path); bool is_wav = false; if (len > 4 && strcasecmp(ctx->current_audio_path + len - 4, ".wav") == 0) { is_wav = true; } if (is_wav) { play_wav(ctx); } else { play_mp3(ctx); } } /* ─── MP3 Decoder Routine ─── */ static void play_mp3(AppCtx* ctx) { // Let the GUI thread load the image from SD first to avoid hardware SD card bus contention vTaskDelay(pdMS_TO_TICKS(400)); FILE* file = fopen(ctx->current_audio_path, "rb"); if (!file) { ESP_LOGE(TAG, "Failed to open file: %s", ctx->current_audio_path); tt_lvgl_lock(portMAX_DELAY); ctx->state = STATE_IDLE; update_ui(ctx); tt_lvgl_unlock(); ctx->playback_task_handle = NULL; vTaskDelete(NULL); return; } fseek(file, 0, SEEK_END); size_t file_size = ftell(file); fseek(file, 0, SEEK_SET); size_t bytes_read_total = 0; #ifdef ESP_PLATFORM mp3dec_t* decoder = (mp3dec_t*)heap_caps_malloc(sizeof(mp3dec_t), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT); #else mp3dec_t* decoder = (mp3dec_t*)malloc(sizeof(mp3dec_t)); #endif if (!decoder) { ESP_LOGE(TAG, "Failed to allocate MP3 decoder!"); fclose(file); ctx->playback_task_handle = NULL; vTaskDelete(NULL); return; } mp3dec_init(decoder); size_t buffered_bytes = 0; bool eof = false; int sample_rate = 0; int channels = 0; ESP_LOGI(TAG, "Starting MP3 playback: %s (%d bytes)", ctx->current_audio_path, file_size); while (ctx->state != STATE_IDLE) { if (ctx->state == STATE_PAUSED) { if (sample_rate != 0) { device_lock(ctx->i2s_dev); i2s_controller_reset(ctx->i2s_dev); device_unlock(ctx->i2s_dev); sample_rate = 0; channels = 0; } vTaskDelay(pdMS_TO_TICKS(50)); continue; } // Fill buffer if (!eof && buffered_bytes < MP3_INPUT_BUFFER_SIZE) { size_t to_read = MP3_INPUT_BUFFER_SIZE - buffered_bytes; size_t read_bytes = fread(ctx->audio_buf + buffered_bytes, 1, to_read, file); buffered_bytes += read_bytes; bytes_read_total += read_bytes; if (read_bytes == 0) eof = true; } if (buffered_bytes == 0 && eof) { ESP_LOGI(TAG, "Reached MP3 EOF"); break; } // Decode one frame mp3dec_frame_info_t info; memset(&info, 0, sizeof(info)); int samples = mp3dec_decode_frame(decoder, ctx->audio_buf, (int)buffered_bytes, ctx->pcm_buf, &info); if (info.frame_bytes <= 0) { if (eof) break; // Resync memmove(ctx->audio_buf, ctx->audio_buf + 1, --buffered_bytes); continue; } size_t consumed = (size_t)info.frame_bytes; buffered_bytes -= consumed; memmove(ctx->audio_buf, ctx->audio_buf + consumed, buffered_bytes); if (samples > 0) { // Configure I2S if (sample_rate != info.hz || channels != info.channels) { struct I2sConfig config = { .communication_format = I2S_FORMAT_STAND_I2S, .sample_rate = (uint32_t)info.hz, .bits_per_sample = 16, .channel_left = 0, .channel_right = (info.channels == 2) ? 1 : I2S_CHANNEL_NONE }; device_lock(ctx->i2s_dev); error_t err = i2s_controller_set_config(ctx->i2s_dev, &config); device_unlock(ctx->i2s_dev); if (err != ERROR_NONE) { ESP_LOGE(TAG, "Failed to configure I2S: %d", err); break; } sample_rate = info.hz; channels = info.channels; } // Adjust Volume int vol = ctx->volume; int16_t* samples_ptr = (int16_t*)ctx->pcm_buf; size_t sample_count = (size_t)samples * info.channels; for (size_t i = 0; i < sample_count; ++i) { int32_t scaled = (int32_t)samples_ptr[i] * vol / 100; samples_ptr[i] = (int16_t)scaled; } // Write PCM to I2S size_t offset = 0; size_t data_size = sample_count * sizeof(int16_t); bool write_err = false; while (offset < data_size && ctx->state == STATE_PLAYING) { size_t written = 0; error_t err = i2s_controller_write(ctx->i2s_dev, (uint8_t*)ctx->pcm_buf + offset, data_size - offset, &written, pdMS_TO_TICKS(250)); if (err != ERROR_NONE || written == 0) { ESP_LOGE(TAG, "I2S write error: %d", err); write_err = true; break; } offset += written; } if (write_err) break; } // Update Progress Bar if (file_size > 0) { int pct = (int)((bytes_read_total - buffered_bytes) * 100 / file_size); if (pct < 0) pct = 0; if (pct > 100) pct = 100; if (pct != ctx->last_pct) { ctx->last_pct = pct; tt_lvgl_lock(portMAX_DELAY); lv_bar_set_value(ctx->bar_progress, pct, LV_ANIM_OFF); tt_lvgl_unlock(); } } taskYIELD(); } fclose(file); if (ctx->i2s_dev) { device_lock(ctx->i2s_dev); i2s_controller_reset(ctx->i2s_dev); device_unlock(ctx->i2s_dev); } bool stopped_externally = (ctx->state == STATE_IDLE); if (!stopped_externally) { tt_lvgl_lock(portMAX_DELAY); handle_audio_finished(ctx); tt_lvgl_unlock(); } #ifdef ESP_PLATFORM heap_caps_free(decoder); #else free(decoder); #endif ctx->playback_task_handle = NULL; vTaskDelete(NULL); } /* ─── WAV Decoder Routine ─── */ static void play_wav(AppCtx* ctx) { // Let the GUI thread load the image from SD first to avoid hardware SD card bus contention vTaskDelay(pdMS_TO_TICKS(400)); FILE* file = fopen(ctx->current_audio_path, "rb"); if (!file) { ESP_LOGE(TAG, "Failed to open WAV: %s", ctx->current_audio_path); tt_lvgl_lock(portMAX_DELAY); ctx->state = STATE_IDLE; update_ui(ctx); tt_lvgl_unlock(); ctx->playback_task_handle = NULL; vTaskDelete(NULL); return; } WavHeader header; if (fread(&header, 1, sizeof(WavHeader), file) != sizeof(WavHeader)) { ESP_LOGE(TAG, "Failed to read WAV header"); fclose(file); tt_lvgl_lock(portMAX_DELAY); ctx->state = STATE_IDLE; update_ui(ctx); tt_lvgl_unlock(); ctx->playback_task_handle = NULL; vTaskDelete(NULL); return; } if (strncmp(header.riff, "RIFF", 4) != 0 || strncmp(header.wave, "WAVE", 4) != 0) { ESP_LOGE(TAG, "Invalid WAV signature"); fclose(file); tt_lvgl_lock(portMAX_DELAY); ctx->state = STATE_IDLE; update_ui(ctx); tt_lvgl_unlock(); ctx->playback_task_handle = NULL; vTaskDelete(NULL); return; } size_t data_size = header.data_size; if (data_size == 0) { fseek(file, 0, SEEK_END); data_size = ftell(file) - sizeof(WavHeader); fseek(file, sizeof(WavHeader), SEEK_SET); } struct I2sConfig config = { .communication_format = I2S_FORMAT_STAND_I2S, .sample_rate = header.sample_rate, .bits_per_sample = header.bits_per_sample, .channel_left = 0, .channel_right = (header.channels == 2) ? 1 : I2S_CHANNEL_NONE }; device_lock(ctx->i2s_dev); error_t err = i2s_controller_set_config(ctx->i2s_dev, &config); device_unlock(ctx->i2s_dev); if (err != ERROR_NONE) { ESP_LOGE(TAG, "Failed to configure WAV I2S: %d", err); fclose(file); ctx->playback_task_handle = NULL; vTaskDelete(NULL); return; } ESP_LOGI(TAG, "Starting WAV playback: %s (%u Hz, %u channels)", ctx->current_audio_path, (unsigned int)header.sample_rate, (unsigned int)header.channels); size_t total_played = 0; bool i2s_configured = true; while (total_played < data_size && ctx->state != STATE_IDLE) { if (ctx->state == STATE_PAUSED) { if (i2s_configured) { device_lock(ctx->i2s_dev); i2s_controller_reset(ctx->i2s_dev); device_unlock(ctx->i2s_dev); i2s_configured = false; } vTaskDelay(pdMS_TO_TICKS(50)); continue; } if (!i2s_configured) { device_lock(ctx->i2s_dev); err = i2s_controller_set_config(ctx->i2s_dev, &config); device_unlock(ctx->i2s_dev); if (err != ERROR_NONE) break; i2s_configured = true; } size_t to_read = (data_size - total_played < MP3_INPUT_BUFFER_SIZE) ? (data_size - total_played) : MP3_INPUT_BUFFER_SIZE; size_t read_bytes = fread(ctx->audio_buf, 1, to_read, file); if (read_bytes == 0) break; // Scaling Volume int vol = ctx->volume; int16_t* samples_ptr = (int16_t*)ctx->audio_buf; size_t sample_count = read_bytes / sizeof(int16_t); for (size_t i = 0; i < sample_count; ++i) { int32_t scaled = (int32_t)samples_ptr[i] * vol / 100; samples_ptr[i] = (int16_t)scaled; } // Play to I2S size_t offset = 0; bool write_err = false; while (offset < read_bytes && ctx->state == STATE_PLAYING) { size_t written = 0; err = i2s_controller_write(ctx->i2s_dev, ctx->audio_buf + offset, read_bytes - offset, &written, pdMS_TO_TICKS(100)); if (err != ERROR_NONE || written == 0) { ESP_LOGE(TAG, "I2S WAV write error: %d", err); write_err = true; break; } offset += written; } if (write_err) break; total_played += read_bytes; // Update progress bar int pct = (int)((total_played * 100) / data_size); if (pct < 0) pct = 0; if (pct > 100) pct = 100; if (pct != ctx->last_pct) { ctx->last_pct = pct; tt_lvgl_lock(portMAX_DELAY); lv_bar_set_value(ctx->bar_progress, pct, LV_ANIM_OFF); tt_lvgl_unlock(); } taskYIELD(); } fclose(file); if (ctx->i2s_dev) { device_lock(ctx->i2s_dev); i2s_controller_reset(ctx->i2s_dev); device_unlock(ctx->i2s_dev); } bool stopped_externally = (ctx->state == STATE_IDLE); if (!stopped_externally) { tt_lvgl_lock(portMAX_DELAY); handle_audio_finished(ctx); tt_lvgl_unlock(); } ctx->playback_task_handle = NULL; vTaskDelete(NULL); } /* ─── Picker events ─── */ static void on_book_selected(lv_event_t* e) { int index = (int)(intptr_t)lv_event_get_user_data(e); AppCtx* ctx = &g_ctx; BookMetadata* book = &ctx->books[index]; strncpy(ctx->current_book_slug, book->slug, sizeof(ctx->current_book_slug) - 1); char manifest_path[512]; snprintf(manifest_path, sizeof(manifest_path), "/sdcard/books/%s/manifest.json", book->slug); char* json_str = read_full_file(manifest_path); if (!json_str) { const char* buttons[] = {"OK"}; tt_app_alertdialog_start("Read Error", "Failed to open the book manifest.", buttons, 1); return; } ctx->manifest_root = cJSON_Parse(json_str); free(json_str); if (!ctx->manifest_root) { const char* buttons[] = {"OK"}; tt_app_alertdialog_start("JSON Error", "The book manifest is not formatted correctly.", buttons, 1); return; } ctx->pages_array = cJSON_GetObjectItem(ctx->manifest_root, "pages"); if (!ctx->pages_array || !cJSON_IsArray(ctx->pages_array)) { const char* buttons[] = {"OK"}; tt_app_alertdialog_start("Format Error", "No pages found in book manifest.", buttons, 1); cJSON_Delete(ctx->manifest_root); ctx->manifest_root = NULL; ctx->pages_array = NULL; return; } ctx->page_count = cJSON_GetArraySize(ctx->pages_array); if (ctx->page_count <= 0) { const char* buttons[] = {"OK"}; tt_app_alertdialog_start("Format Error", "The book does not have pages.", buttons, 1); cJSON_Delete(ctx->manifest_root); ctx->manifest_root = NULL; ctx->pages_array = NULL; return; } lv_label_set_text(ctx->lbl_book_title, book->title); // Switch views lv_obj_add_flag(ctx->picker_wrapper, LV_OBJ_FLAG_HIDDEN); lv_obj_remove_flag(ctx->player_wrapper, LV_OBJ_FLAG_HIDDEN); lv_obj_remove_flag(ctx->header_bar, LV_OBJ_FLAG_HIDDEN); lv_obj_remove_flag(ctx->ctrl_bar, LV_OBJ_FLAG_HIDDEN); lv_obj_remove_flag(ctx->bar_progress, LV_OBJ_FLAG_HIDDEN); // Load first page (no auto-play initially) load_page(ctx, 0, false); } /* ─── Scan Books ─── */ static void scan_books(AppCtx* ctx) { ctx->book_count = 0; lv_obj_clean(ctx->lst_books); DIR* dir = opendir("/sdcard/books"); if (!dir) { ESP_LOGE(TAG, "Failed to scan books: /sdcard/books folder missing."); lv_list_add_text(ctx->lst_books, "No SD card or books directory found."); return; } struct dirent* entry; while ((entry = readdir(dir)) != NULL && ctx->book_count < MAX_BOOKS) { if (entry->d_name[0] == '.') continue; char manifest_path[512]; snprintf(manifest_path, sizeof(manifest_path), "/sdcard/books/%s/manifest.json", entry->d_name); char* json_str = read_full_file(manifest_path); if (json_str) { cJSON* root = cJSON_Parse(json_str); free(json_str); if (root) { cJSON* title_item = cJSON_GetObjectItem(root, "title"); cJSON* author_item = cJSON_GetObjectItem(root, "author"); BookMetadata* book = &ctx->books[ctx->book_count]; strncpy(book->slug, entry->d_name, sizeof(book->slug) - 1); if (title_item && title_item->valuestring) { strncpy(book->title, title_item->valuestring, sizeof(book->title) - 1); } else { strncpy(book->title, entry->d_name, sizeof(book->title) - 1); } if (author_item && author_item->valuestring) { strncpy(book->author, author_item->valuestring, sizeof(book->author) - 1); } else { book->author[0] = '\0'; } cJSON_Delete(root); ctx->book_count++; } } } closedir(dir); if (ctx->book_count == 0) { lv_list_add_text(ctx->lst_books, "No book manifest.json files found."); return; } // Bubble sort by title for (int i = 0; i < ctx->book_count - 1; i++) { for (int j = 0; j < ctx->book_count - i - 1; j++) { if (strcmp(ctx->books[j].title, ctx->books[j + 1].title) > 0) { BookMetadata temp = ctx->books[j]; ctx->books[j] = ctx->books[j + 1]; ctx->books[j + 1] = temp; } } } // Add items to screen list for (int i = 0; i < ctx->book_count; ++i) { char label_text[512]; if (ctx->books[i].author[0] != '\0') { snprintf(label_text, sizeof(label_text), "%s\nby %s", ctx->books[i].title, ctx->books[i].author); } else { snprintf(label_text, sizeof(label_text), "%s", ctx->books[i].title); } lv_obj_t* btn = lv_list_add_button(ctx->lst_books, LV_SYMBOL_DIRECTORY, label_text); lv_obj_add_event_cb(btn, on_book_selected, LV_EVENT_CLICKED, (void*)(intptr_t)i); } } /* ─── Player Control Events ─── */ static void on_play_pause_click(lv_event_t* e) { AppCtx* ctx = (AppCtx*)lv_event_get_user_data(e); if (ctx->current_audio_path[0] == '\0') return; if (ctx->state == STATE_IDLE) { ctx->state = STATE_PLAYING; update_ui(ctx); xTaskCreate(audio_playback_task, "audio_play", 4096, ctx, 5, &ctx->playback_task_handle); } else if (ctx->state == STATE_PLAYING) { ctx->state = STATE_PAUSED; update_ui(ctx); } else if (ctx->state == STATE_PAUSED) { ctx->state = STATE_PLAYING; update_ui(ctx); } } static void on_prev_click(lv_event_t* e) { AppCtx* ctx = (AppCtx*)lv_event_get_user_data(e); if (ctx->current_page > 0) { bool was_playing = (ctx->state == STATE_PLAYING); load_page(ctx, ctx->current_page - 1, was_playing); } } static void on_next_click(lv_event_t* e) { AppCtx* ctx = (AppCtx*)lv_event_get_user_data(e); if (ctx->current_page < ctx->page_count - 1) { bool was_playing = (ctx->state == STATE_PLAYING); load_page(ctx, ctx->current_page + 1, was_playing); } } static void on_image_click(lv_event_t* e) { AppCtx* ctx = (AppCtx*)lv_event_get_user_data(e); if (!ctx) return; bool is_hidden = lv_obj_has_flag(ctx->header_bar, LV_OBJ_FLAG_HIDDEN); if (is_hidden) { lv_obj_remove_flag(ctx->header_bar, LV_OBJ_FLAG_HIDDEN); lv_obj_remove_flag(ctx->ctrl_bar, LV_OBJ_FLAG_HIDDEN); lv_obj_remove_flag(ctx->bar_progress, LV_OBJ_FLAG_HIDDEN); } else { lv_obj_add_flag(ctx->header_bar, LV_OBJ_FLAG_HIDDEN); lv_obj_add_flag(ctx->ctrl_bar, LV_OBJ_FLAG_HIDDEN); lv_obj_add_flag(ctx->bar_progress, LV_OBJ_FLAG_HIDDEN); } } static void on_back_click(lv_event_t* e) { AppCtx* ctx = (AppCtx*)lv_event_get_user_data(e); return_to_picker(ctx); } /* ─── App Lifecycle ─── */ static void onShowApp(AppHandle app, void* data, lv_obj_t* parent) { memset(&g_ctx, 0, sizeof(g_ctx)); g_ctx.app = app; g_ctx.volume = 80; // Allocate shared audio buffers #ifdef ESP_PLATFORM g_ctx.audio_buf = (uint8_t*)heap_caps_malloc(MP3_INPUT_BUFFER_SIZE, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT); g_ctx.pcm_buf = (mp3d_sample_t*)heap_caps_malloc(MINIMP3_MAX_SAMPLES_PER_FRAME * sizeof(mp3d_sample_t), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT); #else g_ctx.audio_buf = (uint8_t*)malloc(MP3_INPUT_BUFFER_SIZE); g_ctx.pcm_buf = (mp3d_sample_t*)malloc(MINIMP3_MAX_SAMPLES_PER_FRAME * sizeof(mp3d_sample_t)); #endif // Find I2S sound device g_ctx.i2s_dev = device_find_by_name("i2s0"); if (!g_ctx.i2s_dev) { ESP_LOGE(TAG, "I2S device 'i2s0' not found!"); } // Create dual layouts // 1. Picker Screen wrapper g_ctx.picker_wrapper = lv_obj_create(parent); lv_obj_set_size(g_ctx.picker_wrapper, LV_PCT(100), LV_PCT(100)); lv_obj_set_style_border_width(g_ctx.picker_wrapper, 0, 0); lv_obj_set_style_pad_all(g_ctx.picker_wrapper, 0, 0); lv_obj_set_style_pad_gap(g_ctx.picker_wrapper, 0, 0); lv_obj_set_style_bg_color(g_ctx.picker_wrapper, lv_color_hex(0x1E1E2E), 0); // Dark background // Toolbar in picker lv_obj_t* toolbar = tt_lvgl_toolbar_create_for_app(g_ctx.picker_wrapper, app); lv_obj_align(toolbar, LV_ALIGN_TOP_MID, 0, 0); // Picker list g_ctx.lst_books = lv_list_create(g_ctx.picker_wrapper); lv_obj_set_width(g_ctx.lst_books, LV_PCT(100)); lv_obj_align_to(g_ctx.lst_books, toolbar, LV_ALIGN_OUT_BOTTOM_MID, 0, 0); int32_t toolbar_height = lv_obj_get_height(toolbar); int32_t parent_height = lv_obj_get_content_height(parent); lv_obj_set_height(g_ctx.lst_books, parent_height - toolbar_height); lv_obj_set_style_bg_color(g_ctx.lst_books, lv_color_hex(0x1E1E2E), 0); lv_obj_set_style_border_color(g_ctx.lst_books, lv_color_hex(0x313244), 0); // 2. Player Screen wrapper (hidden on start) g_ctx.player_wrapper = lv_obj_create(parent); lv_obj_set_size(g_ctx.player_wrapper, LV_PCT(100), LV_PCT(100)); lv_obj_set_style_border_width(g_ctx.player_wrapper, 0, 0); lv_obj_set_style_pad_all(g_ctx.player_wrapper, 0, 0); lv_obj_set_style_pad_gap(g_ctx.player_wrapper, 0, 0); lv_obj_set_style_bg_color(g_ctx.player_wrapper, lv_color_hex(0x1E1E2E), 0); lv_obj_remove_flag(g_ctx.player_wrapper, LV_OBJ_FLAG_SCROLLABLE); // Lock page scrolling lv_obj_add_flag(g_ctx.player_wrapper, LV_OBJ_FLAG_HIDDEN); // Page Image (covers the whole screen as background) g_ctx.img_page = lv_image_create(g_ctx.player_wrapper); lv_obj_align(g_ctx.img_page, LV_ALIGN_CENTER, 0, 0); lv_obj_set_style_bg_opa(g_ctx.img_page, LV_OPA_TRANSP, 0); lv_obj_set_style_pad_all(g_ctx.img_page, 0, 0); lv_obj_set_style_border_width(g_ctx.img_page, 0, 0); lv_obj_remove_flag(g_ctx.img_page, LV_OBJ_FLAG_SCROLLABLE); lv_obj_add_flag(g_ctx.img_page, LV_OBJ_FLAG_CLICKABLE); lv_obj_add_event_cb(g_ctx.img_page, on_image_click, LV_EVENT_CLICKED, &g_ctx); // Custom Player header (Back button, Book Title, Page Indicator) g_ctx.header_bar = lv_obj_create(g_ctx.player_wrapper); lv_obj_t* header_bar = g_ctx.header_bar; lv_obj_set_size(header_bar, LV_PCT(100), 36); lv_obj_align(header_bar, LV_ALIGN_TOP_MID, 0, 0); lv_obj_set_style_radius(header_bar, 0, 0); lv_obj_set_style_bg_color(header_bar, lv_color_hex(0x11111B), 0); lv_obj_set_style_bg_opa(header_bar, LV_OPA_COVER, 0); // Solid header bar lv_obj_set_style_border_color(header_bar, lv_color_hex(0x313244), 0); lv_obj_set_style_border_width(header_bar, 1, LV_PART_MAIN); lv_obj_remove_flag(header_bar, LV_OBJ_FLAG_SCROLLABLE); // Back button lv_obj_t* btn_back = lv_button_create(header_bar); lv_obj_set_size(btn_back, 44, 26); lv_obj_align(btn_back, LV_ALIGN_LEFT_MID, 0, 0); lv_obj_set_style_radius(btn_back, 6, 0); lv_obj_set_style_bg_color(btn_back, lv_color_hex(0x313244), 0); lv_obj_t* lbl_back = lv_label_create(btn_back); lv_label_set_text(lbl_back, LV_SYMBOL_LEFT); lv_obj_center(lbl_back); lv_obj_add_event_cb(btn_back, on_back_click, LV_EVENT_CLICKED, &g_ctx); // Title g_ctx.lbl_book_title = lv_label_create(header_bar); lv_obj_align(g_ctx.lbl_book_title, LV_ALIGN_CENTER, 0, 0); lv_obj_set_width(g_ctx.lbl_book_title, 180); lv_obj_set_style_text_align(g_ctx.lbl_book_title, LV_TEXT_ALIGN_CENTER, 0); lv_obj_set_style_text_color(g_ctx.lbl_book_title, lv_color_hex(0xCDD6F4), 0); lv_label_set_long_mode(g_ctx.lbl_book_title, LV_LABEL_LONG_DOT); // Static text with dots to prevent dynamic redraw overhead // Page Indicator g_ctx.lbl_indicator = lv_label_create(header_bar); lv_obj_align(g_ctx.lbl_indicator, LV_ALIGN_RIGHT_MID, 0, 0); lv_obj_set_style_text_color(g_ctx.lbl_indicator, lv_color_hex(0xA6ADC8), 0); lv_label_set_text(g_ctx.lbl_indicator, "1 / 1"); // Bottom Controls container (overlaying background image) g_ctx.ctrl_bar = lv_obj_create(g_ctx.player_wrapper); lv_obj_t* ctrl_bar = g_ctx.ctrl_bar; lv_obj_set_size(ctrl_bar, LV_PCT(100), 40); lv_obj_align(ctrl_bar, LV_ALIGN_BOTTOM_MID, 0, 0); lv_obj_set_style_radius(ctrl_bar, 0, 0); lv_obj_set_style_bg_color(ctrl_bar, lv_color_hex(0x11111B), 0); lv_obj_set_style_bg_opa(ctrl_bar, LV_OPA_COVER, 0); // Solid control bar lv_obj_set_style_border_width(ctrl_bar, 0, 0); lv_obj_set_style_pad_all(ctrl_bar, 0, 0); lv_obj_set_style_pad_gap(ctrl_bar, 0, 0); lv_obj_set_flex_flow(ctrl_bar, LV_FLEX_FLOW_ROW); lv_obj_set_flex_align(ctrl_bar, LV_FLEX_ALIGN_SPACE_EVENLY, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER); lv_obj_remove_flag(ctrl_bar, LV_OBJ_FLAG_SCROLLABLE); // Progress Bar (thin bar running along the top of control bar) g_ctx.bar_progress = lv_bar_create(g_ctx.player_wrapper); lv_obj_set_size(g_ctx.bar_progress, LV_PCT(100), 4); lv_obj_align_to(g_ctx.bar_progress, ctrl_bar, LV_ALIGN_OUT_TOP_MID, 0, 0); lv_bar_set_range(g_ctx.bar_progress, 0, 100); lv_bar_set_value(g_ctx.bar_progress, 0, LV_ANIM_OFF); lv_obj_set_style_bg_color(g_ctx.bar_progress, lv_color_hex(0x45475A), LV_PART_MAIN); lv_obj_set_style_bg_color(g_ctx.bar_progress, lv_color_hex(0x89B4FA), LV_PART_INDICATOR); // Prev Button g_ctx.btn_prev = lv_button_create(ctrl_bar); lv_obj_set_size(g_ctx.btn_prev, 54, 30); lv_obj_set_style_radius(g_ctx.btn_prev, 15, 0); lv_obj_set_style_bg_color(g_ctx.btn_prev, lv_color_hex(0x313244), 0); lv_obj_t* lbl_prev = lv_label_create(g_ctx.btn_prev); lv_label_set_text(lbl_prev, LV_SYMBOL_PREV); lv_obj_center(lbl_prev); lv_obj_add_event_cb(g_ctx.btn_prev, on_prev_click, LV_EVENT_CLICKED, &g_ctx); // Play/Pause Button g_ctx.btn_play_pause = lv_button_create(ctrl_bar); lv_obj_set_size(g_ctx.btn_play_pause, 94, 30); lv_obj_set_style_radius(g_ctx.btn_play_pause, 15, 0); lv_obj_set_style_bg_color(g_ctx.btn_play_pause, lv_color_hex(0x89B4FA), 0); lv_obj_set_style_text_color(g_ctx.btn_play_pause, lv_color_hex(0x11111B), 0); lv_obj_t* lbl_play_btn = lv_label_create(g_ctx.btn_play_pause); lv_label_set_text(lbl_play_btn, LV_SYMBOL_PLAY " Play"); lv_obj_center(lbl_play_btn); lv_obj_add_event_cb(g_ctx.btn_play_pause, on_play_pause_click, LV_EVENT_CLICKED, &g_ctx); // Next Button g_ctx.btn_next = lv_button_create(ctrl_bar); lv_obj_set_size(g_ctx.btn_next, 54, 30); lv_obj_set_style_radius(g_ctx.btn_next, 15, 0); lv_obj_set_style_bg_color(g_ctx.btn_next, lv_color_hex(0x313244), 0); lv_obj_t* lbl_next = lv_label_create(g_ctx.btn_next); lv_label_set_text(lbl_next, LV_SYMBOL_NEXT); lv_obj_center(lbl_next); lv_obj_add_event_cb(g_ctx.btn_next, on_next_click, LV_EVENT_CLICKED, &g_ctx); // Initial load g_ctx.state = STATE_IDLE; update_ui(&g_ctx); // Scan Books scan_books(&g_ctx); } static void onHideApp(AppHandle app, void* data) { wait_for_playback_task_to_exit(&g_ctx); if (g_ctx.i2s_dev) { device_lock(g_ctx.i2s_dev); i2s_controller_reset(g_ctx.i2s_dev); device_unlock(g_ctx.i2s_dev); } if (g_ctx.manifest_root) { cJSON_Delete(g_ctx.manifest_root); g_ctx.manifest_root = NULL; g_ctx.pages_array = NULL; } #ifdef ESP_PLATFORM if (g_ctx.audio_buf) { heap_caps_free(g_ctx.audio_buf); g_ctx.audio_buf = NULL; } if (g_ctx.pcm_buf) { heap_caps_free(g_ctx.pcm_buf); g_ctx.pcm_buf = NULL; } #else if (g_ctx.audio_buf) { free(g_ctx.audio_buf); g_ctx.audio_buf = NULL; } if (g_ctx.pcm_buf) { free(g_ctx.pcm_buf); g_ctx.pcm_buf = NULL; } #endif } int main(int argc, char* argv[]) { tt_app_register((AppRegistration) { .onShow = onShowApp, .onHide = onHideApp }); return 0; }