452 lines
14 KiB
C++
452 lines
14 KiB
C++
#include "device_manager.h"
|
||
#include <esp_log.h>
|
||
#include <esp_mac.h>
|
||
#include <nvs_flash.h>
|
||
#include <nvs.h>
|
||
#include <cJSON.h>
|
||
#include "board.h"
|
||
#include "server_config.h"
|
||
|
||
#define TAG "DeviceManager"
|
||
|
||
DeviceManager& DeviceManager::GetInstance() {
|
||
static DeviceManager instance;
|
||
return instance;
|
||
}
|
||
|
||
DeviceManager::DeviceManager() : is_bound_(false) {
|
||
// 初始化NVS（如果尚未初始化）
|
||
esp_err_t ret = nvs_flash_init();
|
||
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
|
||
ESP_ERROR_CHECK(nvs_flash_erase());
|
||
ret = nvs_flash_init();
|
||
}
|
||
ESP_ERROR_CHECK(ret);
|
||
|
||
// 获取MAC地址
|
||
uint8_t mac[6];
|
||
esp_err_t err = esp_efuse_mac_get_default(mac);
|
||
if (err == ESP_OK) {
|
||
char mac_str[18];
|
||
snprintf(mac_str, sizeof(mac_str), "%02X:%02X:%02X:%02X:%02X:%02X",
|
||
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
|
||
mac_address_ = std::string(mac_str);
|
||
ESP_LOGI(TAG, "Device MAC Address: %s", mac_address_.c_str());
|
||
} else {
|
||
ESP_LOGE(TAG, "Failed to get MAC address");
|
||
}
|
||
|
||
// 从NVS加载配置
|
||
LoadFromNVS();
|
||
|
||
// 如果没有 token，尝试从服务器自动获取（可能已在网页端绑定）
|
||
if (device_token_.empty() && !mac_address_.empty()) {
|
||
ESP_LOGI(TAG, "No token found, trying to fetch from server...");
|
||
TryFetchTokenFromServer();
|
||
}
|
||
}
|
||
|
||
DeviceManager::~DeviceManager() {
|
||
}
|
||
|
||
std::string DeviceManager::GetMACAddress() {
|
||
return mac_address_;
|
||
}
|
||
|
||
void DeviceManager::LoadFromNVS() {
|
||
nvs_handle_t nvs_handle;
|
||
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READONLY, &nvs_handle);
|
||
|
||
if (err == ESP_OK) {
|
||
// 读取Token
|
||
size_t token_len = 0;
|
||
err = nvs_get_str(nvs_handle, NVS_KEY_TOKEN, nullptr, &token_len);
|
||
if (err == ESP_OK && token_len > 0) {
|
||
char* token_buf = new char[token_len];
|
||
err = nvs_get_str(nvs_handle, NVS_KEY_TOKEN, token_buf, &token_len);
|
||
if (err == ESP_OK) {
|
||
device_token_ = std::string(token_buf);
|
||
is_bound_ = true;
|
||
ESP_LOGI(TAG, "Loaded device token from NVS (length: %d)", token_len - 1);
|
||
}
|
||
delete[] token_buf;
|
||
}
|
||
|
||
// 读取用户名
|
||
size_t username_len = 0;
|
||
err = nvs_get_str(nvs_handle, NVS_KEY_USERNAME, nullptr, &username_len);
|
||
if (err == ESP_OK && username_len > 0) {
|
||
char* username_buf = new char[username_len];
|
||
err = nvs_get_str(nvs_handle, NVS_KEY_USERNAME, username_buf, &username_len);
|
||
if (err == ESP_OK) {
|
||
bound_username_ = std::string(username_buf);
|
||
ESP_LOGI(TAG, "Device bound to user: %s", bound_username_.c_str());
|
||
}
|
||
delete[] username_buf;
|
||
}
|
||
|
||
nvs_close(nvs_handle);
|
||
} else if (err == ESP_ERR_NVS_NOT_FOUND) {
|
||
ESP_LOGI(TAG, "No device binding found in NVS");
|
||
} else {
|
||
ESP_LOGE(TAG, "Failed to open NVS: %s", esp_err_to_name(err));
|
||
}
|
||
}
|
||
|
||
bool DeviceManager::SaveDeviceToken(const std::string& token) {
|
||
nvs_handle_t nvs_handle;
|
||
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs_handle);
|
||
|
||
if (err != ESP_OK) {
|
||
ESP_LOGE(TAG, "Failed to open NVS for writing: %s", esp_err_to_name(err));
|
||
return false;
|
||
}
|
||
|
||
err = nvs_set_str(nvs_handle, NVS_KEY_TOKEN, token.c_str());
|
||
if (err != ESP_OK) {
|
||
ESP_LOGE(TAG, "Failed to write token to NVS: %s", esp_err_to_name(err));
|
||
nvs_close(nvs_handle);
|
||
return false;
|
||
}
|
||
|
||
err = nvs_commit(nvs_handle);
|
||
nvs_close(nvs_handle);
|
||
|
||
if (err == ESP_OK) {
|
||
device_token_ = token;
|
||
is_bound_ = true;
|
||
ESP_LOGI(TAG, "Device token saved to NVS");
|
||
return true;
|
||
} else {
|
||
ESP_LOGE(TAG, "Failed to commit NVS: %s", esp_err_to_name(err));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
std::string DeviceManager::GetDeviceToken() {
|
||
return device_token_;
|
||
}
|
||
|
||
bool DeviceManager::ClearDeviceToken() {
|
||
nvs_handle_t nvs_handle;
|
||
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs_handle);
|
||
|
||
if (err != ESP_OK) {
|
||
ESP_LOGE(TAG, "Failed to open NVS for erasing: %s", esp_err_to_name(err));
|
||
return false;
|
||
}
|
||
|
||
nvs_erase_key(nvs_handle, NVS_KEY_TOKEN);
|
||
nvs_erase_key(nvs_handle, NVS_KEY_USERNAME);
|
||
err = nvs_commit(nvs_handle);
|
||
nvs_close(nvs_handle);
|
||
|
||
if (err == ESP_OK) {
|
||
device_token_.clear();
|
||
bound_username_.clear();
|
||
is_bound_ = false;
|
||
ESP_LOGI(TAG, "Device token cleared");
|
||
return true;
|
||
} else {
|
||
ESP_LOGE(TAG, "Failed to clear device token: %s", esp_err_to_name(err));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
bool DeviceManager::BindDevice(const std::string& binding_code, const std::string& device_name) {
|
||
ESP_LOGI(TAG, "Starting device binding with code: %s", binding_code.c_str());
|
||
|
||
if (mac_address_.empty()) {
|
||
ESP_LOGE(TAG, "MAC address not available");
|
||
return false;
|
||
}
|
||
|
||
// 构建请求JSON
|
||
cJSON* request = cJSON_CreateObject();
|
||
cJSON_AddStringToObject(request, "mac", mac_address_.c_str());
|
||
cJSON_AddStringToObject(request, "binding_code", binding_code.c_str());
|
||
if (!device_name.empty()) {
|
||
cJSON_AddStringToObject(request, "device_name", device_name.c_str());
|
||
} else {
|
||
cJSON_AddStringToObject(request, "device_name", "ESP32音乐播放器");
|
||
}
|
||
|
||
char* request_str = cJSON_PrintUnformatted(request);
|
||
std::string request_body(request_str);
|
||
cJSON_Delete(request);
|
||
cJSON_free(request_str);
|
||
|
||
// 发送HTTP请求到服务器
|
||
auto& board = Board::GetInstance();
|
||
auto network = board.GetNetwork();
|
||
auto http = network->CreateHttp(0);
|
||
|
||
std::string bind_url = DEVICE_BIND_API_URL;
|
||
|
||
http->SetHeader("Content-Type", "application/json");
|
||
http->SetHeader("User-Agent", "ESP32-Music-Player/1.0");
|
||
|
||
ESP_LOGI(TAG, "Sending bind request to: %s", bind_url.c_str());
|
||
ESP_LOGD(TAG, "Request body: %s", request_body.c_str());
|
||
|
||
if (!http->Open("POST", bind_url)) {
|
||
ESP_LOGE(TAG, "Failed to connect to bind API");
|
||
return false;
|
||
}
|
||
|
||
// 发送请求体
|
||
http->Write(request_body.c_str(), request_body.length());
|
||
|
||
int status_code = http->GetStatusCode();
|
||
ESP_LOGI(TAG, "Bind request status code: %d", status_code);
|
||
|
||
if (status_code != 200) {
|
||
ESP_LOGE(TAG, "Bind request failed with status: %d", status_code);
|
||
http->Close();
|
||
return false;
|
||
}
|
||
|
||
// 读取响应
|
||
std::string response = http->ReadAll();
|
||
http->Close();
|
||
|
||
ESP_LOGD(TAG, "Bind response: %s", response.c_str());
|
||
|
||
// 解析响应JSON
|
||
cJSON* response_json = cJSON_Parse(response.c_str());
|
||
if (!response_json) {
|
||
ESP_LOGE(TAG, "Failed to parse bind response");
|
||
return false;
|
||
}
|
||
|
||
cJSON* success = cJSON_GetObjectItem(response_json, "success");
|
||
if (!success || !cJSON_IsBool(success) || !cJSON_IsTrue(success)) {
|
||
ESP_LOGE(TAG, "Bind request was not successful");
|
||
cJSON_Delete(response_json);
|
||
return false;
|
||
}
|
||
|
||
cJSON* token = cJSON_GetObjectItem(response_json, "token");
|
||
cJSON* username = cJSON_GetObjectItem(response_json, "username");
|
||
|
||
if (!token || !cJSON_IsString(token)) {
|
||
ESP_LOGE(TAG, "No token in bind response");
|
||
cJSON_Delete(response_json);
|
||
return false;
|
||
}
|
||
|
||
std::string token_str = token->valuestring;
|
||
std::string username_str = username && cJSON_IsString(username) ? username->valuestring : "";
|
||
|
||
cJSON_Delete(response_json);
|
||
|
||
// 保存Token到NVS
|
||
if (!SaveDeviceToken(token_str)) {
|
||
ESP_LOGE(TAG, "Failed to save token");
|
||
return false;
|
||
}
|
||
|
||
// 保存用户名到NVS
|
||
if (!username_str.empty()) {
|
||
nvs_handle_t nvs_handle;
|
||
if (nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs_handle) == ESP_OK) {
|
||
nvs_set_str(nvs_handle, NVS_KEY_USERNAME, username_str.c_str());
|
||
nvs_commit(nvs_handle);
|
||
nvs_close(nvs_handle);
|
||
bound_username_ = username_str;
|
||
}
|
||
}
|
||
|
||
ESP_LOGI(TAG, "Device successfully bound to user: %s", username_str.c_str());
|
||
|
||
return true;
|
||
}
|
||
|
||
bool DeviceManager::VerifyDevice() {
|
||
if (device_token_.empty()) {
|
||
ESP_LOGW(TAG, "No device token available for verification");
|
||
return false;
|
||
}
|
||
|
||
auto& board = Board::GetInstance();
|
||
auto network = board.GetNetwork();
|
||
auto http = network->CreateHttp(0);
|
||
|
||
std::string verify_url = DEVICE_VERIFY_API_URL;
|
||
|
||
http->SetHeader("X-Device-Token", device_token_.c_str());
|
||
http->SetHeader("User-Agent", "ESP32-Music-Player/1.0");
|
||
|
||
if (!http->Open("GET", verify_url)) {
|
||
ESP_LOGE(TAG, "Failed to connect to verify API");
|
||
return false;
|
||
}
|
||
|
||
int status_code = http->GetStatusCode();
|
||
http->Close();
|
||
|
||
if (status_code == 200) {
|
||
ESP_LOGI(TAG, "Device verification successful");
|
||
return true;
|
||
} else {
|
||
ESP_LOGW(TAG, "Device verification failed with status: %d", status_code);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
std::string DeviceManager::GetFavorites() {
|
||
if (device_token_.empty()) {
|
||
return "";
|
||
}
|
||
|
||
auto& board = Board::GetInstance();
|
||
auto network = board.GetNetwork();
|
||
auto http = network->CreateHttp(0);
|
||
|
||
std::string url = FAVORITE_LIST_API_URL;
|
||
|
||
http->SetHeader("X-Device-Token", device_token_.c_str());
|
||
http->SetHeader("User-Agent", "ESP32-Music-Player/1.0");
|
||
|
||
if (!http->Open("GET", url)) {
|
||
ESP_LOGE(TAG, "Failed to connect to favorites API");
|
||
return "";
|
||
}
|
||
|
||
int status_code = http->GetStatusCode();
|
||
std::string response = http->ReadAll();
|
||
http->Close();
|
||
|
||
if (status_code == 200) {
|
||
return response;
|
||
} else {
|
||
ESP_LOGW(TAG, "GetFavorites failed with status: %d", status_code);
|
||
return "";
|
||
}
|
||
}
|
||
|
||
std::string DeviceManager::GetUserPlaylists() {
|
||
if (device_token_.empty()) {
|
||
return "";
|
||
}
|
||
|
||
auto& board = Board::GetInstance();
|
||
auto network = board.GetNetwork();
|
||
auto http = network->CreateHttp(0);
|
||
|
||
std::string url = PLAYLIST_LIST_API_URL;
|
||
|
||
http->SetHeader("X-Device-Token", device_token_.c_str());
|
||
http->SetHeader("User-Agent", "ESP32-Music-Player/1.0");
|
||
|
||
if (!http->Open("GET", url)) {
|
||
ESP_LOGE(TAG, "Failed to connect to playlist API");
|
||
return "";
|
||
}
|
||
|
||
int status_code = http->GetStatusCode();
|
||
std::string response = http->ReadAll();
|
||
http->Close();
|
||
|
||
if (status_code == 200) {
|
||
return response;
|
||
} else {
|
||
ESP_LOGW(TAG, "GetUserPlaylists failed with status: %d", status_code);
|
||
return "";
|
||
}
|
||
}
|
||
|
||
bool DeviceManager::IsDeviceBound() {
|
||
return is_bound_ && !device_token_.empty();
|
||
}
|
||
|
||
std::string DeviceManager::GetBoundUsername() {
|
||
return bound_username_;
|
||
}
|
||
|
||
bool DeviceManager::TryFetchTokenFromServer() {
|
||
ESP_LOGI(TAG, "Attempting to fetch token from server using MAC: %s", mac_address_.c_str());
|
||
|
||
auto& board = Board::GetInstance();
|
||
auto network = board.GetNetwork();
|
||
auto http = network->CreateHttp(0);
|
||
|
||
// 构建请求 JSON
|
||
cJSON* request = cJSON_CreateObject();
|
||
cJSON_AddStringToObject(request, "mac", mac_address_.c_str());
|
||
char* request_str = cJSON_PrintUnformatted(request);
|
||
std::string request_body(request_str);
|
||
cJSON_Delete(request);
|
||
cJSON_free(request_str);
|
||
|
||
std::string sync_url = MUSIC_SERVER_URL;
|
||
sync_url += "/api/esp32/sync";
|
||
|
||
http->SetHeader("Content-Type", "application/json");
|
||
http->SetHeader("User-Agent", "ESP32-Music-Player/1.0");
|
||
|
||
if (!http->Open("POST", sync_url)) {
|
||
ESP_LOGW(TAG, "Failed to connect to sync API");
|
||
return false;
|
||
}
|
||
|
||
http->Write(request_body.c_str(), request_body.length());
|
||
|
||
int status_code = http->GetStatusCode();
|
||
std::string response = http->ReadAll();
|
||
http->Close();
|
||
|
||
if (status_code == 404) {
|
||
ESP_LOGI(TAG, "Device not bound on server yet");
|
||
return false;
|
||
}
|
||
|
||
if (status_code != 200) {
|
||
ESP_LOGW(TAG, "Token sync failed with status: %d", status_code);
|
||
return false;
|
||
}
|
||
|
||
// 解析响应
|
||
cJSON* response_json = cJSON_Parse(response.c_str());
|
||
if (!response_json) {
|
||
ESP_LOGE(TAG, "Failed to parse sync response");
|
||
return false;
|
||
}
|
||
|
||
cJSON* token = cJSON_GetObjectItem(response_json, "token");
|
||
cJSON* username = cJSON_GetObjectItem(response_json, "username");
|
||
|
||
if (!token || !cJSON_IsString(token)) {
|
||
ESP_LOGE(TAG, "Invalid sync response: missing token");
|
||
cJSON_Delete(response_json);
|
||
return false;
|
||
}
|
||
|
||
std::string token_str = token->valuestring;
|
||
std::string username_str = username && cJSON_IsString(username) ? username->valuestring : "";
|
||
|
||
cJSON_Delete(response_json);
|
||
|
||
// 保存 Token 到 NVS
|
||
if (!SaveDeviceToken(token_str)) {
|
||
ESP_LOGE(TAG, "Failed to save synced token");
|
||
return false;
|
||
}
|
||
|
||
// 保存用户名到 NVS
|
||
if (!username_str.empty()) {
|
||
nvs_handle_t nvs_handle;
|
||
if (nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs_handle) == ESP_OK) {
|
||
nvs_set_str(nvs_handle, NVS_KEY_USERNAME, username_str.c_str());
|
||
nvs_commit(nvs_handle);
|
||
nvs_close(nvs_handle);
|
||
bound_username_ = username_str;
|
||
is_bound_ = true;
|
||
}
|
||
}
|
||
|
||
ESP_LOGI(TAG, "✅ Token synced successfully for user: %s", username_str.c_str());
|
||
|
||
return true;
|
||
}
|