[FL-2627] Flipper applications: SDK, build and debug system (#1387)

* Added support for running applications from SD card (FAPs - Flipper Application Packages)
* Added plugin_dist target for fbt to build FAPs
* All apps of type FlipperAppType.EXTERNAL and FlipperAppType.PLUGIN are built as FAPs by default
* Updated VSCode configuration for new fbt features - re-deploy stock configuration to use them
* Added debugging support for FAPs with fbt debug & VSCode
* Added public firmware API with automated versioning

Co-authored-by: hedger <hedger@users.noreply.github.com>
Co-authored-by: SG <who.just.the.doctor@gmail.com>
Co-authored-by: あく <alleteam@gmail.com>

applications/main/subghz/helpers/subghz_chat.c

@@ -0,0 +1,148 @@
+#include "subghz_chat.h"
+#include <lib/subghz/subghz_tx_rx_worker.h>
+
+#define TAG "SubGhzChat"
+#define SUBGHZ_CHAT_WORKER_TIMEOUT_BETWEEN_MESSAGES 500
+
+struct SubGhzChatWorker {
+    FuriThread* thread;
+    SubGhzTxRxWorker* subghz_txrx;
+
+    volatile bool worker_running;
+    volatile bool worker_stoping;
+    FuriMessageQueue* event_queue;
+    uint32_t last_time_rx_data;
+
+    Cli* cli;
+};
+
+/** Worker thread
+ * 
+ * @param context 
+ * @return exit code 
+ */
+static int32_t subghz_chat_worker_thread(void* context) {
+    SubGhzChatWorker* instance = context;
+    FURI_LOG_I(TAG, "Worker start");
+    char c;
+    SubGhzChatEvent event;
+    event.event = SubGhzChatEventUserEntrance;
+    furi_message_queue_put(instance->event_queue, &event, 0);
+    while(instance->worker_running) {
+        if(cli_read_timeout(instance->cli, (uint8_t*)&c, 1, 1000) == 1) {
+            event.event = SubGhzChatEventInputData;
+            event.c = c;
+            furi_message_queue_put(instance->event_queue, &event, FuriWaitForever);
+        }
+    }
+
+    FURI_LOG_I(TAG, "Worker stop");
+    return 0;
+}
+
+static void subghz_chat_worker_update_rx_event_chat(void* context) {
+    furi_assert(context);
+    SubGhzChatWorker* instance = context;
+    SubGhzChatEvent event;
+    if((furi_get_tick() - instance->last_time_rx_data) >
+       SUBGHZ_CHAT_WORKER_TIMEOUT_BETWEEN_MESSAGES) {
+        event.event = SubGhzChatEventNewMessage;
+        furi_message_queue_put(instance->event_queue, &event, FuriWaitForever);
+    }
+    instance->last_time_rx_data = furi_get_tick();
+    event.event = SubGhzChatEventRXData;
+    furi_message_queue_put(instance->event_queue, &event, FuriWaitForever);
+}
+
+SubGhzChatWorker* subghz_chat_worker_alloc(Cli* cli) {
+    SubGhzChatWorker* instance = malloc(sizeof(SubGhzChatWorker));
+
+    instance->cli = cli;
+
+    instance->thread = furi_thread_alloc();
+    furi_thread_set_name(instance->thread, "SubGhzChat");
+    furi_thread_set_stack_size(instance->thread, 2048);
+    furi_thread_set_context(instance->thread, instance);
+    furi_thread_set_callback(instance->thread, subghz_chat_worker_thread);
+    instance->subghz_txrx = subghz_tx_rx_worker_alloc();
+    instance->event_queue = furi_message_queue_alloc(80, sizeof(SubGhzChatEvent));
+    return instance;
+}
+
+void subghz_chat_worker_free(SubGhzChatWorker* instance) {
+    furi_assert(instance);
+    furi_assert(!instance->worker_running);
+    furi_message_queue_free(instance->event_queue);
+    subghz_tx_rx_worker_free(instance->subghz_txrx);
+    furi_thread_free(instance->thread);
+
+    free(instance);
+}
+
+bool subghz_chat_worker_start(SubGhzChatWorker* instance, uint32_t frequency) {
+    furi_assert(instance);
+    furi_assert(!instance->worker_running);
+    bool res = false;
+
+    if(subghz_tx_rx_worker_start(instance->subghz_txrx, frequency)) {
+        furi_message_queue_reset(instance->event_queue);
+        subghz_tx_rx_worker_set_callback_have_read(
+            instance->subghz_txrx, subghz_chat_worker_update_rx_event_chat, instance);
+
+        instance->worker_running = true;
+        instance->last_time_rx_data = 0;
+
+        furi_thread_start(instance->thread);
+
+        res = true;
+    }
+    return res;
+}
+
+void subghz_chat_worker_stop(SubGhzChatWorker* instance) {
+    furi_assert(instance);
+    furi_assert(instance->worker_running);
+    if(subghz_tx_rx_worker_is_running(instance->subghz_txrx)) {
+        subghz_tx_rx_worker_stop(instance->subghz_txrx);
+    }
+
+    instance->worker_running = false;
+
+    furi_thread_join(instance->thread);
+}
+
+bool subghz_chat_worker_is_running(SubGhzChatWorker* instance) {
+    furi_assert(instance);
+    return instance->worker_running;
+}
+
+SubGhzChatEvent subghz_chat_worker_get_event_chat(SubGhzChatWorker* instance) {
+    furi_assert(instance);
+    SubGhzChatEvent event;
+    if(furi_message_queue_get(instance->event_queue, &event, FuriWaitForever) == FuriStatusOk) {
+        return event;
+    } else {
+        event.event = SubGhzChatEventNoEvent;
+        return event;
+    }
+}
+
+void subghz_chat_worker_put_event_chat(SubGhzChatWorker* instance, SubGhzChatEvent* event) {
+    furi_assert(instance);
+    furi_message_queue_put(instance->event_queue, event, FuriWaitForever);
+}
+
+size_t subghz_chat_worker_available(SubGhzChatWorker* instance) {
+    furi_assert(instance);
+    return subghz_tx_rx_worker_available(instance->subghz_txrx);
+}
+
+size_t subghz_chat_worker_read(SubGhzChatWorker* instance, uint8_t* data, size_t size) {
+    furi_assert(instance);
+    return subghz_tx_rx_worker_read(instance->subghz_txrx, data, size);
+}
+
+bool subghz_chat_worker_write(SubGhzChatWorker* instance, uint8_t* data, size_t size) {
+    furi_assert(instance);
+    return subghz_tx_rx_worker_write(instance->subghz_txrx, data, size);
+}