Files
WaveShare_ESP32_BoomCast_FW/BoomCast_Waveshare_Arduino/boomcast_uploader.cpp
T
2026-10-10 16:03:44 +02:00

242 lines
9.8 KiB
C++

#include "boomcast_uploader.h"
#include "boomcast_config.h"
#include "boomcast_network.h"
#include "boomcast_state.h"
#include "boomcast_monitor.h"
#include <WiFiClientSecure.h>
#include <ArduinoJson.h>
#include <stdio.h>
#include <time.h>
#include "esp_sntp.h"
#include "esp_heap_caps.h"
BoomUploader boomUploader;
static String eventIdFromFilename(String name) {
if (name.endsWith(".wav")) name.remove(name.length() - 4);
return name;
}
static String isoUtc(uint64_t epochMs) {
if (!epochMs) return "";
time_t seconds = epochMs / 1000;
struct tm utc;
if (!gmtime_r(&seconds, &utc)) return "";
char text[30];
snprintf(text, sizeof(text), "%04d-%02d-%02dT%02d:%02d:%02d.%03uZ",
utc.tm_year + 1900, utc.tm_mon + 1, utc.tm_mday,
utc.tm_hour, utc.tm_min, utc.tm_sec, unsigned(epochMs % 1000));
return String(text);
}
static bool writeAll(WiFiClientSecure& client, const uint8_t* bytes, size_t size) {
size_t done = 0;
const uint32_t started = millis();
while (done < size && client.connected()) {
boomMonitor.tick();
if (millis() - started > 15000) return false;
size_t n = client.write(bytes + done, size - done);
if (!n) return false;
done += n;
}
return done == size;
}
static bool writeAll(WiFiClientSecure& client, const String& value) {
return writeAll(client, reinterpret_cast<const uint8_t*>(value.c_str()), value.length());
}
static void addPart(String& body, const String& boundary, const char* name, const String& value) {
body += "--" + boundary + "\r\nContent-Disposition: form-data; name=\"" + name + "\"\r\n\r\n" + value + "\r\n";
}
static bool waitForNtpTime() {
// SNTP reports COMPLETED once per synchronization. Retain that result for
// later uploads; a reboot clears it and requires a new NTP sync.
static bool synchronized = false;
const uint32_t started = millis();
while (!synchronized && boomNetwork.connected() && millis() - started < 20000) {
if (sntp_get_sync_status() == SNTP_SYNC_STATUS_COMPLETED) synchronized = true;
boomMonitor.tick();
if (!synchronized) delay(100);
}
time_t now = time(nullptr);
return synchronized && now >= 1704067200; // Reject an unset or implausible clock.
}
bool BoomUploader::submitOne(const String& filename) {
if (!queue_ || !queue_->ready() || !boomNetwork.connected() || !queue_->exists(filename)) return false;
boomState.setSyncing(true, "Uploading " + filename);
bool ok = doPost(filename, queue_->absolutePath(filename));
if (ok && !queue_->remove(filename)) {
boomState.setSyncing(false, "Receipt received; local cleanup failed");
return false;
}
boomState.setSyncing(false, ok ? "Submitted " + filename : "Upload failed; queued for retry");
return ok;
}
int BoomUploader::submitAll() {
if (!queue_ || !boomNetwork.connected()) return 0;
int sent = 0;
const uint32_t started = millis();
while (sent < 500 && millis() - started < 30000) {
boomMonitor.tick();
String first[1];
if (!queue_->listNames(first, 1) || !submitOne(first[0])) break;
++sent;
}
return sent;
}
void BoomUploader::tick() {
if (!queue_ || !queue_->ready() || !boomNetwork.connected() || !queue_->count()) return;
if ((int32_t)(millis() - nextAttemptMs_) < 0) return;
String first[1];
if (!queue_->listNames(first, 1)) return;
if (submitOne(first[0])) {
failures_ = 0;
permanentFailure_ = false;
nextAttemptMs_ = millis() + 1000;
} else {
failures_ = min(uint8_t(failures_ + 1), uint8_t(8));
uint32_t base = permanentFailure_ ? 3600000UL : min(900000UL, 5000UL << failures_);
nextAttemptMs_ = millis() + base + (esp_random() % 5000);
}
}
bool BoomUploader::doPost(const String& filename, const String& path) {
permanentFailure_ = false;
BoomEventMeta meta;
if (!queue_->readMeta(filename, meta)) return false;
String token = boomState.prefs().getString("token", SENSOR_TOKEN);
if (!token.length() || !SENSOR_ID) {
Serial.println("[Upload] sensor ID or token missing");
permanentFailure_ = true;
return false;
}
String origin(SERVER_BASE_URL);
if (!origin.startsWith("https://")) {
Serial.println("[Upload] HTTPS required");
permanentFailure_ = true;
return false;
}
String host = origin.substring(8);
int slash = host.indexOf('/'); if (slash >= 0) host = host.substring(0, slash);
uint16_t port = 443;
int colon = host.lastIndexOf(':');
if (colon >= 0) { port = host.substring(colon + 1).toInt(); host = host.substring(0, colon); }
if (!host.length() || !port) return false;
if (!waitForNtpTime()) {
Serial.println("[Upload] waiting for NTP time before TLS validation");
return false;
}
FILE* file = fopen(path.c_str(), "rb");
if (!file) return false;
const size_t fileBytes = queue_->fileSize(filename);
const String boundary = "BoomCast" + String(esp_random(), HEX);
const String eventId = eventIdFromFilename(filename);
String preamble; preamble.reserve(700);
addPart(preamble, boundary, "sensor_id", String(SENSOR_ID));
addPart(preamble, boundary, "event_id", eventId);
if (meta.captureStartedMs) {
addPart(preamble, boundary, "captured_at", isoUtc(meta.captureStartedMs));
addPart(preamble, boundary, "capture_started_at", isoUtc(meta.captureStartedMs));
} else addPart(preamble, boundary, "time_state", "unknown");
if (meta.triggeredMs) addPart(preamble, boundary, "triggered_at", isoUtc(meta.triggeredMs));
if (meta.queuedMs) addPart(preamble, boundary, "queued_at", isoUtc(meta.queuedMs));
addPart(preamble, boundary, "duration_seconds", String(meta.sampleCount / float(AUDIO_SAMPLE_RATE), 4));
addPart(preamble, boundary, "firmware_version", BOOMCAST_FIRMWARE_VERSION);
addPart(preamble, boundary, "trigger_type", filename.indexOf("_manual_") >= 0 ? "manual" : "audio_spike");
preamble += "--" + boundary + "\r\nContent-Disposition: form-data; name=\"file\"; filename=\"" + filename + "\"\r\nContent-Type: audio/wav\r\n\r\n";
const String trailer = "\r\n--" + boundary + "--\r\n";
const size_t length = preamble.length() + fileBytes + trailer.length();
WiFiClientSecure client;
client.useBuiltinCACertBundle();
client.setTimeout(5);
client.setHandshakeTimeout(15);
Serial.printf("[Upload] free heap=%u PSRAM=%u largest PSRAM=%u\n",
unsigned(ESP.getFreeHeap()), unsigned(ESP.getFreePsram()),
unsigned(heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM)));
if (!client.connect(host.c_str(), port, 5000)) { fclose(file); return false; }
String header = "POST " + String(SUBMIT_PATH) + " HTTP/1.1\r\nHost: " + host + "\r\n";
header += "Authorization: Bearer " + token + "\r\n";
header += "Content-Type: multipart/form-data; boundary=" + boundary + "\r\n";
header += "Content-Length: " + String(length) + "\r\nAccept: application/json\r\nConnection: close\r\n\r\n";
bool sent = writeAll(client, header) && writeAll(client, preamble);
uint8_t chunk[1024];
size_t fileSent = 0;
const uint32_t uploadStarted = millis();
while (sent && fileSent < fileBytes && millis() - uploadStarted < 30000) {
size_t n = fread(chunk, 1, min(sizeof(chunk), fileBytes - fileSent), file);
if (n == 0) { sent = false; break; }
sent = writeAll(client, chunk, n);
fileSent += n;
}
if (ferror(file) || fileSent != fileBytes) sent = false;
fclose(file);
if (sent) sent = writeAll(client, trailer);
if (!sent) { client.stop(); return false; }
const uint32_t responseStarted = millis();
auto readLine = [&client, responseStarted](String& line) {
line = "";
while (millis() - responseStarted < 60000 && line.length() < 1024) {
boomMonitor.tick();
if (client.available()) {
char c = char(client.read());
if (c == '\n') return true;
line += c;
} else { if (!client.connected()) return false; delay(5); }
}
return false;
};
String statusLine;
if (!readLine(statusLine)) { client.stop(); return false; }
int status = 0;
if (statusLine.startsWith("HTTP/1.")) {
int firstSpace = statusLine.indexOf(' ');
if (firstSpace > 0) status = statusLine.substring(firstSpace + 1).toInt();
}
// Django returns an ordinary Content-Length response; do not accept redirects.
int contentLength = -1;
size_t headerBytes = 0;
while (true) {
String line;
if (!readLine(line) || (headerBytes += line.length()) > 8192) { client.stop(); return false; }
line.trim();
if (!line.length()) break;
if (line.startsWith("Content-Length:") || line.startsWith("content-length:"))
contentLength = line.substring(line.indexOf(':') + 1).toInt();
}
if (contentLength < 0 || contentLength > 8192) { client.stop(); return false; }
String body; body.reserve(contentLength);
while (body.length() < size_t(contentLength) && millis() - responseStarted < 60000) {
boomMonitor.tick();
if (!client.connected() && !client.available()) break;
while (client.available() && body.length() < size_t(contentLength)) body += char(client.read());
delay(1);
}
client.stop();
Serial.printf("[Upload] HTTP %d, response bytes=%u\n", status, unsigned(body.length()));
if (body.length() != size_t(contentLength)) return false;
if (status != 200 && status != 201) {
permanentFailure_ = status >= 400 && status < 500 && status != 408 && status != 429;
return false;
}
JsonDocument receipt;
if (deserializeJson(receipt, body)) return false;
const char* returnedEvent = receipt["event_id"] | "";
const char* submission = receipt["submission_id"] | "";
const char* state = receipt["status"] | "";
if (eventId != returnedEvent || strlen(submission) != 36 ||
(strcmp(state, "pending") && strcmp(state, "reviewed")) ||
(status == 200 && !receipt["duplicate"].as<bool>())) return false;
Serial.printf("[Upload] accepted event %s; free heap=%u PSRAM=%u largest PSRAM=%u\n",
eventId.c_str(), unsigned(ESP.getFreeHeap()), unsigned(ESP.getFreePsram()),
unsigned(heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM)));
return true;
}