Shim.cpp 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384
  1. /*
  2. * This software is released under the MIT License.
  3. * https://opensource.org/licenses/MIT
  4. *
  5. */
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include <inttypes.h>
  9. #include "sdkconfig.h"
  10. #include "freertos/FreeRTOS.h"
  11. #include "freertos/task.h"
  12. #include "esp_system.h"
  13. #include "esp_wifi.h"
  14. #include "esp_event.h"
  15. #include "esp_log.h"
  16. #include "esp_http_server.h"
  17. #include <ConstantParameters.h>
  18. #include <Session.h>
  19. #include <SpircController.h>
  20. #include <MercuryManager.h>
  21. #include <ZeroconfAuthenticator.h>
  22. #include <ApResolve.h>
  23. #include <HTTPServer.h>
  24. #include "ConfigJSON.h"
  25. #include "Logger.h"
  26. #include "platform_config.h"
  27. #include "tools.h"
  28. #include "cspot_private.h"
  29. #include "cspot_sink.h"
  30. #include "Shim.h"
  31. extern "C" {
  32. httpd_handle_t get_http_server(int *port);
  33. static esp_err_t handlerWrapper(httpd_req_t *req);
  34. };
  35. #define CSPOT_STACK_SIZE (8*1024)
  36. static const char *TAG = "cspot";
  37. // using a global is pretty ugly, but it's easier with all Lambda below
  38. static EXT_RAM_ATTR struct cspot_s {
  39. char name[32];
  40. cspot_cmd_cb_t cHandler;
  41. cspot_data_cb_t dHandler;
  42. TaskHandle_t TaskHandle;
  43. std::shared_ptr<LoginBlob> blob;
  44. } cspot;
  45. std::shared_ptr<ConfigJSON> configMan;
  46. std::shared_ptr<NVSFile> file;
  47. std::shared_ptr<MercuryManager> mercuryManager;
  48. std::shared_ptr<SpircController> spircController;
  49. /****************************************************************************************
  50. * Main task (could it be deleted after spirc has started?)
  51. */
  52. static void cspotTask(void *pvParameters) {
  53. char configName[] = "cspot_config";
  54. std::string jsonConfig;
  55. // Config file
  56. file = std::make_shared<NVSFile>();
  57. configMan = std::make_shared<ConfigJSON>(configName, file);
  58. // We might have no config at all
  59. if (!file->readFile(configName, jsonConfig) || !jsonConfig.length()) {
  60. ESP_LOGW(TAG, "Cannot load config, using default");
  61. configMan->deviceName = cspot.name;
  62. configMan->format = AudioFormat_OGG_VORBIS_160;
  63. configMan->volume = 32767;
  64. configMan->save();
  65. }
  66. // safely load config now
  67. configMan->load();
  68. if (!configMan->deviceName.length()) configMan->deviceName = cspot.name;
  69. ESP_LOGI(TAG, "Started CSpot with %s (bitrate %d)", configMan->deviceName.c_str(), configMan->format == AudioFormat_OGG_VORBIS_320 ? 320 : (configMan->format == AudioFormat_OGG_VORBIS_160 ? 160 : 96));
  70. // All we do here is notify the task to start the mercury loop
  71. auto createPlayerCallback = [](std::shared_ptr<LoginBlob> blob) {
  72. // TODO: handle/refuse that another user takes ownership
  73. cspot.blob = blob;
  74. xTaskNotifyGive(cspot.TaskHandle);
  75. };
  76. int port;
  77. httpd_handle_t server = get_http_server(&port);
  78. auto httpServer = std::make_shared<ShimHTTPServer>(server, port);
  79. auto authenticator = std::make_shared<ZeroconfAuthenticator>(createPlayerCallback, httpServer);
  80. authenticator->registerHandlers();
  81. // wait to be notified and have a mercury loop
  82. while (1) {
  83. ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
  84. auto session = std::make_unique<Session>();
  85. session->connectWithRandomAp();
  86. auto token = session->authenticate(cspot.blob);
  87. ESP_LOGI(TAG, "Creating Spotify (using CSpot) player");
  88. // Auth successful
  89. if (token.size() > 0 && cspot.cHandler(CSPOT_SETUP, 44100)) {
  90. auto audioSink = std::make_shared<ShimAudioSink>();
  91. mercuryManager = std::make_shared<MercuryManager>(std::move(session));
  92. mercuryManager->startTask();
  93. spircController = std::make_shared<SpircController>(mercuryManager, cspot.blob->username, audioSink);
  94. spircController->setEventHandler([](CSpotEvent &event) {
  95. switch (event.eventType) {
  96. case CSpotEventType::TRACK_INFO: {
  97. TrackInfo track = std::get<TrackInfo>(event.data);
  98. cspot.cHandler(CSPOT_TRACK, 44100, track.duration, track.artist.c_str(),
  99. track.album.c_str(), track.name.c_str(), track.imageUrl.c_str());
  100. break;
  101. }
  102. case CSpotEventType::PLAY_PAUSE: {
  103. bool isPaused = std::get<bool>(event.data);
  104. if (isPaused) cspot.cHandler(CSPOT_PAUSE);
  105. else cspot.cHandler(CSPOT_PLAY);
  106. break;
  107. }
  108. case CSpotEventType::LOAD:
  109. cspot.cHandler(CSPOT_LOAD, std::get<int>(event.data), -1);
  110. break;
  111. case CSpotEventType::SEEK:
  112. cspot.cHandler(CSPOT_SEEK, std::get<int>(event.data));
  113. break;
  114. case CSpotEventType::DISC:
  115. cspot.cHandler(CSPOT_DISC);
  116. spircController->stopPlayer();
  117. mercuryManager->stop();
  118. break;
  119. case CSpotEventType::PREV:
  120. case CSpotEventType::NEXT:
  121. cspot.cHandler(CSPOT_FLUSH);
  122. break;
  123. /*
  124. // we use volume from sink which is a 16 bits value
  125. case CSpotEventType::VOLUME: {
  126. int volume = std::get<int>(event.data);
  127. cspot.cHandler(CSPOT_VOLUME, volume);
  128. ESP_LOGW(TAG, "cspot volume : %d", volume);
  129. break;
  130. }
  131. */
  132. default:
  133. break;
  134. }
  135. });
  136. mercuryManager->reconnectedCallback = []() {
  137. return spircController->subscribe();
  138. };
  139. mercuryManager->handleQueue();
  140. // release controllers
  141. mercuryManager.reset();
  142. spircController.reset();
  143. }
  144. // release auth blob and flush files
  145. cspot.blob.reset();
  146. file->flush();
  147. ESP_LOGI(TAG, "Shutting down CSpot player");
  148. }
  149. // we should not be here
  150. vTaskDelete(NULL);
  151. }
  152. /****************************************************************************************
  153. * API to create and start a cspot instance
  154. */
  155. struct cspot_s* cspot_create(const char *name, cspot_cmd_cb_t cmd_cb, cspot_data_cb_t data_cb) {
  156. static DRAM_ATTR StaticTask_t xTaskBuffer __attribute__ ((aligned (4)));
  157. static EXT_RAM_ATTR StackType_t xStack[CSPOT_STACK_SIZE] __attribute__ ((aligned (4)));
  158. bell::setDefaultLogger();
  159. cspot.cHandler = cmd_cb;
  160. cspot.dHandler = data_cb;
  161. strncpy(cspot.name, name, sizeof(cspot.name) - 1);
  162. cspot.TaskHandle = xTaskCreateStatic(&cspotTask, "cspot", CSPOT_STACK_SIZE, NULL, CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT - 2, xStack, &xTaskBuffer);
  163. return &cspot;
  164. }
  165. /****************************************************************************************
  166. * Commands sent by local buttons/actions
  167. */
  168. bool cspot_cmd(struct cspot_s* ctx, cspot_event_t event, void *param) {
  169. // we might have not controller left
  170. if (!spircController.use_count()) return false;
  171. switch(event) {
  172. case CSPOT_PREV:
  173. spircController->prevSong();
  174. break;
  175. case CSPOT_NEXT:
  176. spircController->nextSong();
  177. break;
  178. case CSPOT_TOGGLE:
  179. spircController->playToggle();
  180. break;
  181. case CSPOT_PAUSE:
  182. spircController->setPause(true);
  183. break;
  184. case CSPOT_PLAY:
  185. spircController->setPause(false);
  186. break;
  187. case CSPOT_DISC:
  188. spircController->disconnect();
  189. break;
  190. case CSPOT_STOP:
  191. spircController->stopPlayer();
  192. break;
  193. case CSPOT_VOLUME_UP:
  194. spircController->adjustVolume(MAX_VOLUME / 100 + 1);
  195. break;
  196. case CSPOT_VOLUME_DOWN:
  197. spircController->adjustVolume(-(MAX_VOLUME / 100 + 1));
  198. break;
  199. default:
  200. break;
  201. }
  202. return true;
  203. }
  204. /****************************************************************************************
  205. * AudioSink class to push data to squeezelite backend (decode_external)
  206. */
  207. void ShimAudioSink::volumeChanged(uint16_t volume) {
  208. cspot.cHandler(CSPOT_VOLUME, volume);
  209. }
  210. void ShimAudioSink::feedPCMFrames(const uint8_t *data, size_t bytes) {
  211. cspot.dHandler(data, bytes);
  212. }
  213. /****************************************************************************************
  214. * NVSFile class to store config
  215. */
  216. bool NVSFile::readFile(std::string filename, std::string &fileContent) {
  217. auto search = files.find(filename);
  218. // cache
  219. if (search == files.end()) {
  220. char *content = (char*) config_alloc_get(NVS_TYPE_STR, filename.c_str());
  221. if (!content) return false;
  222. fileContent = content;
  223. free(content);
  224. } else {
  225. fileContent = search->second;
  226. }
  227. return true;
  228. }
  229. bool NVSFile::writeFile(std::string filename, std::string fileContent) {
  230. auto search = files.find(filename);
  231. files[filename] = fileContent;
  232. if (search == files.end()) return (ESP_OK == config_set_value(NVS_TYPE_STR, filename.c_str(), fileContent.c_str()));
  233. return true;
  234. }
  235. bool NVSFile::flush() {
  236. esp_err_t err = ESP_OK;
  237. for (auto it = files.begin(); it != files.end(); ++it) {
  238. err |= config_set_value(NVS_TYPE_STR, it->first.c_str(), it->second.c_str());
  239. }
  240. return (err == ESP_OK);
  241. }
  242. /****************************************************************************************
  243. * Shim HTTP server for spirc
  244. */
  245. static esp_err_t handlerWrapper(httpd_req_t *req) {
  246. bell::HTTPRequest request = { };
  247. char *query = NULL, *body = NULL;
  248. bell::httpHandler *handler = (bell::httpHandler*) req->user_ctx;
  249. size_t query_len = httpd_req_get_url_query_len(req);
  250. request.connection = httpd_req_to_sockfd(req);
  251. // get body if any (add '\0' at the end if used as string)
  252. if (req->content_len) {
  253. body = (char*) calloc(1, req->content_len + 1);
  254. int size = httpd_req_recv(req, body, req->content_len);
  255. request.body = body;
  256. ESP_LOGD(TAG,"wrapper received body %d/%d", size, req->content_len);
  257. }
  258. // parse query if any (can be in body as well for url-encoded)
  259. if (query_len) {
  260. query = (char*) malloc(query_len + 1);
  261. httpd_req_get_url_query_str(req, query, query_len + 1);
  262. } else if (body && strchr(body, '&')) {
  263. query = body;
  264. body = NULL;
  265. }
  266. // I know this is very crude and unsafe...
  267. url_decode(query);
  268. char *key = strtok(query, "&");
  269. while (key) {
  270. char *value = strchr(key, '=');
  271. *value++ = '\0';
  272. request.queryParams[key] = value;
  273. ESP_LOGD(TAG,"wrapper received key:%s value:%s", key, value);
  274. key = strtok(NULL, "&");
  275. };
  276. if (query) free(query);
  277. if (body) free(body);
  278. /*
  279. This is a strange construct as the C++ handler will call the ShimHTTPSer::respond
  280. and then we'll return. So we can't obtain the response to be sent, as esp_http_server
  281. normally expects, instead respond() will use raw socket and close connection
  282. */
  283. (*handler)(request);
  284. return ESP_OK;
  285. }
  286. void ShimHTTPServer::registerHandler(bell::RequestType requestType, const std::string &routeUrl, bell::httpHandler handler) {
  287. httpd_uri_t request = {
  288. .uri = routeUrl.c_str(),
  289. .method = (requestType == bell::RequestType::GET ? HTTP_GET : HTTP_POST),
  290. .handler = handlerWrapper,
  291. .user_ctx = NULL,
  292. };
  293. // find athe first free spot and register handler
  294. for (int i = 0; i < sizeof(uriHandlers)/sizeof(bell::httpHandler); i++) {
  295. if (!uriHandlers[i]) {
  296. uriHandlers[i] = handler;
  297. request.user_ctx = uriHandlers + i;
  298. httpd_register_uri_handler(serverHandle, &request);
  299. break;
  300. }
  301. }
  302. if (!request.user_ctx) ESP_LOGW(TAG, "Cannot add handler for %s", routeUrl.c_str());
  303. }
  304. void ShimHTTPServer::respond(const bell::HTTPResponse &response) {
  305. char *buf;
  306. size_t len = asprintf(&buf, "HTTP/1.1 %d OK\r\n"
  307. "Server: SQUEEZEESP32\r\n"
  308. "Connection: close\r\n"
  309. "Content-type: %s\r\n"
  310. "Content-length: %d\r\n"
  311. "Access-Control-Allow-Origin: *\r\n"
  312. "Access-Control-Allow-Methods: GET, POST, PATCH, PUT, DELETE, OPTIONS\r\n"
  313. "Access-Control-Allow-Headers: Origin, Content-Type, X-Auth-Token\r\n"
  314. "\r\n%s",
  315. response.status, response.contentType.c_str(),
  316. response.body.size(), response.body.c_str()
  317. );
  318. // use raw socket send and close connection
  319. httpd_socket_send(serverHandle, response.connectionFd, buf, len, 0);
  320. free(buf);
  321. // we want to close the socket due to the strange construct
  322. httpd_sess_trigger_close(serverHandle, response.connectionFd);
  323. }