rasmus/MTGcompanion
1
0
Fork 0
Code Issues 1 Pull Requests 1 Actions Packages Projects Releases 1 Wiki Activity

Phase 5: Wi-Fi manager w/ reconnect, Scryfall HTTPS client + cJSON caching to /spiffs on net_task (Core 0)

Browse Source
This commit is contained in:
Rasmus
2026-09-09 17:53:41 +02:00
parent e09ec04946
commit 58b15869e2
8 changed files with 671 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

422
main/scryfall_client.c Normal file
View File

@@ -0,0 +1,422 @@
/*
* MTG RFID Companion - Scryfall API client (Core 0)
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "esp_log.h"
#include "esp_http_client.h"
#include "esp_crt_bundle.h"
#include "cJSON.h"
#include "wifi_manager.h"
#include "storage_manager.h"
#include "rfid_manager.h"
#include "scryfall_client.h"
static const char *TAG = "scryfall";
#define NET_TASK_STACK (10 * 1024)
#define NET_TASK_PRIO (3)
#define NET_CORE (0)
#define FETCH_QUEUE_LEN (8)
#define HTTP_TIMEOUT_MS (20000)
#define MAX_ATTEMPTS (2)
#define JSON_BUF_MAX (128 * 1024)
#define NAME_MAX (128)
#define UID_MAX (24)
#define FIELD_STR_MAX (256)
#define ORACLE_MAX (768)
#define IMAGE_URL_MAX (512)
#define EVT_CARD_CACHED (1U << 0)
typedef struct {
char name[NAME_MAX];
char uid[UID_MAX];
} fetch_request_t;
static QueueHandle_t s_fetch_queue;
static TaskHandle_t s_net_task;
static uint32_t s_result_bits = 0;
static char s_last_uid[UID_MAX] = {0};
/* ------------------------------------------------------------------ */
/* URL helpers */
/* ------------------------------------------------------------------ */
static char to_hex_digit(unsigned int v)
{
return (char)(v < 10 ? '0' + v : 'A' + (v - 10));
}
static void url_encode(const char *in, char *out, size_t out_cap)
{
size_t o = 0;
for (size_t i = 0; in[i] != '\0' && o < out_cap - 3; i++) {
unsigned char c = (unsigned char)in[i];
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9')
|| c == '-' || c == '_' || c == '.') {
out[o++] = (char)c;
} else if (c == ' ') {
out[o++] = '+';
} else {
out[o++] = '%';
out[o++] = to_hex_digit((c >> 4) & 0x0F);
out[o++] = to_hex_digit(c & 0x0F);
}
}
out[o] = '\0';
}
/* ------------------------------------------------------------------ */
/* HTTP primitives (blocking, net_task only) */
/* ------------------------------------------------------------------ */
typedef struct {
char *buf;
size_t len;
size_t cap;
esp_err_t err;
FILE *file; /* when downloading to a file */
int status;
} http_sink_t;
static esp_err_t http_on_body(http_sink_t *sink, const char *data, size_t len)
{
if (sink->file != NULL) {
if (len > 0 && fwrite(data, 1, len, sink->file) != len) {
return ESP_FAIL;
}
return ESP_OK;
}
if (len > sink->cap - sink->len) {
/* grow, never beyond cap */
size_t req = sink->len + len;
if (req > JSON_BUF_MAX) {
sink->err = ESP_ERR_NO_MEM;
return ESP_FAIL;
}
size_t new_cap = sink->cap ? sink->cap : 4096;
while (new_cap < req) {
new_cap *= 2;
}
char *nb = realloc(sink->buf, new_cap);
if (nb == NULL) {
sink->err = ESP_ERR_NO_MEM;
return ESP_FAIL;
}
sink->buf = nb;
sink->cap = new_cap;
}
memcpy(sink->buf + sink->len, data, len);
sink->len += len;
return ESP_OK;
}
static esp_err_t http_event_handler(esp_http_client_event_t *evt)
{
http_sink_t *sink = (http_sink_t *)evt->user_data;
if (sink == NULL) {
return ESP_OK;
}
switch (evt->event_id) {
case HTTP_EVENT_ON_DATA:
return http_on_body(sink, (const char *)evt->data, evt->data_len);
case HTTP_EVENT_DISCONNECTED:
if (sink->file != NULL) {
fflush(sink->file);
}
break;
case HTTP_EVENT_ERROR:
sink->err = ESP_FAIL;
break;
default:
break;
}
return ESP_OK;
}
static esp_err_t http_request(const char *url, http_sink_t *sink)
{
for (int attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
esp_http_client_config_t cfg = {
.url = url,
.transport_type = HTTP_TRANSPORT_OVER_SSL,
.timeout_ms = HTTP_TIMEOUT_MS,
.event_handler = http_event_handler,
.user_data = sink,
.buffer_size = 2048,
.crt_bundle_attach = esp_crt_bundle_attach,
};
esp_http_client_handle_t client = esp_http_client_init(&cfg);
if (client == NULL) {
return ESP_ERR_NO_MEM;
}
esp_http_client_set_method(client, HTTP_METHOD_GET);
esp_err_t ret = esp_http_client_perform(client);
esp_http_client_cleanup(client);
ESP_LOGD(TAG, "GET %s -> %s", url, esp_err_to_name(ret));
if (ret == ESP_OK) {
return ESP_OK;
}
if (sink->err != ESP_OK) {
return sink->err;
}
vTaskDelay(pdMS_TO_TICKS(500));
}
return ESP_FAIL;
}
static esp_err_t http_get_json(const char *url, char **out_buf)
{
*out_buf = NULL;
http_sink_t sink = {0};
esp_err_t ret = http_request(url, &sink);
if (ret != ESP_OK || sink.buf == NULL) {
free(sink.buf);
ESP_LOGE(TAG, "JSON fetch failed: %s", url);
return ret;
}
sink.buf[sink.len] = '\0';
*out_buf = sink.buf;
ESP_LOGI(TAG, "fetched %d bytes from %s", (int)sink.len, url);
return ESP_OK;
}
static esp_err_t http_download_file(const char *url, const char *path)
{
FILE *f = fopen(path, "wb");
if (f == NULL) {
return ESP_FAIL;
}
http_sink_t sink = { .file = f };
esp_err_t ret = http_request(url, &sink);
fclose(f);
if (ret != ESP_OK) {
remove(path);
return ret;
}
return ESP_OK;
}
static const char *get_string(const cJSON *item, const char *fallback)
{
if (item == NULL || !cJSON_IsString(item) || item->valuestring == NULL) {
return fallback;
}
return item->valuestring;
}
/* ------------------------------------------------------------------ */
/* Cache metadata */
/* ------------------------------------------------------------------ */
esp_err_t scryfall_ensure_cached(const char *card_name, const char *uid)
{
char json_path[64];
snprintf(json_path, sizeof(json_path), STORAGE_CARDS_DIR "/%s.json", uid);
if (storage_file_exists(json_path)) {
ESP_LOGI(TAG, "cache hit %s", json_path);
return ESP_OK;
}
/* 1. GET card JSON */
char url[512];
char enc[NAME_MAX * 3];
url_encode(card_name, enc, sizeof(enc));
snprintf(url, sizeof(url), SCRYFALL_API SCRYFALL_CARD_ARTS_URL "%s", enc);
char *body = NULL;
esp_err_t ret = http_get_json(url, &body);
if (ret != ESP_OK || body == NULL) {
free(body);
ESP_LOGE(TAG, "scryfall request failed for '%s'", card_name);
return ret != ESP_OK ? ret : ESP_FAIL;
}
cJSON *root = cJSON_Parse(body);
free(body);
if (root == NULL) {
ESP_LOGE(TAG, "JSON parse failed for '%s'", card_name);
return ESP_FAIL;
}
/* 2. Extract fields */
const char *name = get_string(cJSON_GetObjectItem(root, "name"), card_name);
const char *mana = NULL;
cJSON *mc = cJSON_GetObjectItem(root, "mana_cost");
if (cJSON_IsArray(mc) && cJSON_GetArraySize(mc) > 0) {
mana = get_string(cJSON_GetArrayItem(mc, 0), "");
} else {
mana = get_string(mc, "");
}
const char *type_line = get_string(cJSON_GetObjectItem(root, "type_line"), "");
const char *power = get_string(cJSON_GetObjectItem(root, "power"), "");
const char *toughness = get_string(cJSON_GetObjectItem(root, "toughness"), "");
const char *oracle = get_string(cJSON_GetObjectItem(root, "oracle_text"), "");
const char *image_url = NULL;
cJSON *uris = cJSON_GetObjectItem(root, "image_uris");
if (uris) {
image_url = get_string(cJSON_GetObjectItem(uris, "normal"), "");
}
const char *price_usd = NULL;
cJSON *prices = cJSON_GetObjectItem(root, "prices");
if (prices) {
price_usd = get_string(cJSON_GetObjectItem(prices, "usd"), "");
}
/* 3. Persist metadata */
char meta[1536];
snprintf(meta, sizeof(meta),
"{\n"
" \"name\": \"%s\",\n"
" \"mana_cost\": \"%s\",\n"
" \"type\": \"%s\",\n"
" \"power\": \"%s\",\n"
" \"toughness\": \"%s\",\n"
" \"oracle\": \"%s\",\n"
" \"price_usd\": \"%s\"\n"
"}\n",
name, mana, type_line, power, toughness, oracle,
price_usd ? price_usd : "");
ret = storage_write_text(json_path, meta);
/* 4. Download cover art (best effort) */
if (image_url && strlen(image_url) > 0) {
char jpg_path[64];
snprintf(jpg_path, sizeof(jpg_path), STORAGE_CARDS_DIR "/%s.jpg", uid);
esp_err_t dl = http_download_file(image_url, jpg_path);
if (dl != ESP_OK) {
ESP_LOGW(TAG, "image download failed: %s", image_url);
} else {
ESP_LOGI(TAG, "image cached to %s", jpg_path);
}
}
cJSON_Delete(root);
if (ret == ESP_OK) {
s_result_bits |= EVT_CARD_CACHED;
snprintf(s_last_uid, sizeof(s_last_uid), "%s", uid);
ESP_LOGI(TAG, "card '%s' cached under %s", card_name, uid);
}
return ret;
}
/* ------------------------------------------------------------------ */
/* net_task */
/* ------------------------------------------------------------------ */
static void prefetch_mappings(void)
{
char *buf = NULL;
size_t len = 0;
if (storage_read_text(STORAGE_MAPPINGS, &buf, &len) != ESP_OK || buf == NULL) {
free(buf);
return;
}
cJSON *root = cJSON_Parse(buf);
free(buf);
if (root == NULL || !cJSON_IsObject(root)) {
if (root) cJSON_Delete(root);
ESP_LOGW(TAG, "mappings.json unreadable");
return;
}
const char *uid;
cJSON *item = NULL;
cJSON_ArrayForEach(item, root) {
uid = item->string;
if (uid == NULL) continue;
char path[64];
snprintf(path, sizeof(path), STORAGE_CARDS_DIR "/%s.json", uid);
if (!storage_file_exists(path)) {
ESP_LOGI(TAG, "prefetching '%s' for %s", item->valuestring, uid);
scryfall_ensure_cached(item->valuestring, uid);
}
}
cJSON_Delete(root);
}
static void net_task(void *arg)
{
(void)arg;
ESP_LOGI(TAG, "net_task on core %d", xPortGetCoreID());
#ifndef CONFIG_MTG_WIFI_SSID
#error "Missing CONFIG_MTG_WIFI_SSID"
#endif
if (strlen(CONFIG_MTG_WIFI_SSID) > 0) {
if (wifi_manager_wait_connected(pdMS_TO_TICKS(60000)) != ESP_OK) {
ESP_LOGW(TAG, "Wi-Fi connect timed out, continuing without network");
}
}
#ifdef CONFIG_MTG_SCAN_PREFETCH
prefetch_mappings();
#endif
while (1) {
fetch_request_t req;
BaseType_t got = xQueueReceive(s_fetch_queue, &req, portMAX_DELAY);
if (got == pdFALSE) {
continue;
}
scryfall_ensure_cached(req.name, req.uid);
}
}
esp_err_t scryfall_client_start(void)
{
if (s_fetch_queue == NULL) {
s_fetch_queue = xQueueCreate(FETCH_QUEUE_LEN, sizeof(fetch_request_t));
if (s_fetch_queue == NULL) {
return ESP_ERR_NO_MEM;
}
xTaskCreatePinnedToCore(net_task, "net_task", NET_TASK_STACK, NULL, NET_TASK_PRIO, &s_net_task, NET_CORE);
}
return ESP_OK;
}
esp_err_t scryfall_fetch_request(const char *card_name, const char *uid)
{
if (s_fetch_queue == NULL) {
return ESP_ERR_INVALID_STATE;
}
if (strlen(card_name) >= NAME_MAX || strlen(uid) >= UID_MAX || strlen(card_name) == 0) {
return ESP_ERR_INVALID_ARG;
}
fetch_request_t req;
snprintf(req.name, sizeof(req.name), "%s", card_name);
snprintf(req.uid, sizeof(req.uid), "%s", uid);
return xQueueSend(s_fetch_queue, &req, 0) == pdTRUE ? ESP_OK : ESP_ERR_TIMEOUT;
}
bool scryfall_has_pending_result(void)
{
return (s_result_bits & EVT_CARD_CACHED) != 0;
}
const char *scryfall_last_result_uid(void)
{
return s_last_uid;
}
void scryfall_consume_result(void)
{
s_result_bits &= ~EVT_CARD_CACHED;
}