Subghz app example (#365)

* Gui: ported submenu and view_dispatcher_remove_view from iButton branch

* App gui-test: use backported submenu api

* App subghz: initial commit

* App subghz: syntax fix

* App gui-test: fix submenu callback

* App subghz: add subfolders to build

* Gui view: c++ verison of with_view_model

* Subghz app: simple spectrum settings view

* Subghz app: add spectrum settings view to view manager

* Subghz app: spectrum settings scene

Co-authored-by: coreglitch <mail@s3f.ru>

applications/subghz/scene/subghz-scene-generic.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "../subghz-event.h"
+
+class SubghzApp;
+
+class SubghzScene {
+public:
+    virtual void on_enter(SubghzApp* app) = 0;
+    virtual bool on_event(SubghzApp* app, SubghzEvent* event) = 0;
+    virtual void on_exit(SubghzApp* app) = 0;
+
+private:
+};

applications/subghz/scene/subghz-scene-spectrum-settings.cpp

@@ -0,0 +1,48 @@
+#include "subghz-scene-spectrum-settings.h"
+#include "../subghz-app.h"
+#include "../subghz-view-manager.h"
+#include "../subghz-event.h"
+#include <callback-connector.h>
+
+void SubghzSceneSpectrumSettings::on_enter(SubghzApp* app) {
+    SubghzAppViewManager* view_manager = app->get_view_manager();
+    SubghzViewSpectrumSettings* spectrum_settings = view_manager->get_spectrum_settings();
+
+    auto callback = cbc::obtain_connector(this, &SubghzSceneSpectrumSettings::ok_callback);
+    spectrum_settings->set_ok_callback(callback, app);
+    spectrum_settings->set_start_freq(433);
+
+    view_manager->switch_to(SubghzAppViewManager::ViewType::SpectrumSettings);
+}
+
+bool SubghzSceneSpectrumSettings::on_event(SubghzApp* app, SubghzEvent* event) {
+    bool consumed = false;
+
+    if(event->type == SubghzEvent::Type::NextScene) {
+        // save data
+        // uint32_t start_freq = app->get_view_manager()->get_spectrum_settings()->get_start_freq();
+        // app->get_spectrum_analyzer()->set_start_freq(start_freq);
+
+        // switch to next scene
+        // app->switch_to_next_scene(SubghzApp::Scene::SceneSpectrumAnalyze);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void SubghzSceneSpectrumSettings::on_exit(SubghzApp* app) {
+    SubghzAppViewManager* view_manager = app->get_view_manager();
+    SubghzViewSpectrumSettings* spectrum_settings = view_manager->get_spectrum_settings();
+
+    spectrum_settings->set_ok_callback(nullptr, nullptr);
+    spectrum_settings->set_start_freq(0);
+}
+
+void SubghzSceneSpectrumSettings::ok_callback(void* context) {
+    SubghzApp* app = static_cast<SubghzApp*>(context);
+    SubghzEvent event;
+
+    event.type = SubghzEvent::Type::NextScene;
+    app->get_view_manager()->send_event(&event);
+}

applications/subghz/scene/subghz-scene-spectrum-settings.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "subghz-scene-generic.h"
+
+class SubghzSceneSpectrumSettings : public SubghzScene {
+public:
+    void on_enter(SubghzApp* app) final;
+    bool on_event(SubghzApp* app, SubghzEvent* event) final;
+    void on_exit(SubghzApp* app) final;
+
+private:
+    void ok_callback(void* context);
+};

applications/subghz/scene/subghz-scene-start.cpp

@@ -0,0 +1,67 @@
+#include "subghz-scene-start.h"
+#include "../subghz-app.h"
+#include "../subghz-view-manager.h"
+#include "../subghz-event.h"
+#include <callback-connector.h>
+
+typedef enum {
+    SubmenuIndexSpectrumAnalyzer,
+    SubmenuIndexFrequencyScanner,
+    SubmenuIndexSignalAnalyzer,
+    SubmenuIndexSignalTransmitter,
+    SubmenuIndexApplications,
+} SubmenuIndex;
+
+void SubghzSceneStart::on_enter(SubghzApp* app) {
+    SubghzAppViewManager* view_manager = app->get_view_manager();
+    Submenu* submenu = view_manager->get_submenu();
+    auto callback = cbc::obtain_connector(this, &SubghzSceneStart::submenu_callback);
+
+    submenu_add_item(submenu, "Spectrum Analyzer", SubmenuIndexSpectrumAnalyzer, callback, app);
+    submenu_add_item(submenu, "Frequency Scanner", SubmenuIndexFrequencyScanner, callback, app);
+    submenu_add_item(submenu, "Signal Analyzer", SubmenuIndexSignalAnalyzer, callback, app);
+    submenu_add_item(submenu, "Signal Transmitter", SubmenuIndexSignalTransmitter, callback, app);
+    submenu_add_item(submenu, "Applications", SubmenuIndexApplications, callback, app);
+
+    view_manager->switch_to(SubghzAppViewManager::ViewType::Submenu);
+}
+
+bool SubghzSceneStart::on_event(SubghzApp* app, SubghzEvent* event) {
+    bool consumed = false;
+
+    if(event->type == SubghzEvent::Type::MenuSelected) {
+        switch(event->payload.menu_index) {
+        case SubmenuIndexSpectrumAnalyzer:
+            app->switch_to_next_scene(SubghzApp::Scene::SceneSpectrumSettings);
+            break;
+        case SubmenuIndexFrequencyScanner:
+            break;
+        case SubmenuIndexSignalAnalyzer:
+            break;
+        case SubmenuIndexSignalTransmitter:
+            break;
+        case SubmenuIndexApplications:
+            break;
+        }
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+void SubghzSceneStart::on_exit(SubghzApp* app) {
+    SubghzAppViewManager* view_manager = app->get_view_manager();
+    Submenu* submenu = view_manager->get_submenu();
+
+    submenu_clean(submenu);
+}
+
+void SubghzSceneStart::submenu_callback(void* context, uint32_t index) {
+    SubghzApp* app = static_cast<SubghzApp*>(context);
+    SubghzEvent event;
+
+    event.type = SubghzEvent::Type::MenuSelected;
+    event.payload.menu_index = index;
+
+    app->get_view_manager()->send_event(&event);
+}

applications/subghz/scene/subghz-scene-start.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "subghz-scene-generic.h"
+
+class SubghzSceneStart : public SubghzScene {
+public:
+    void on_enter(SubghzApp* app) final;
+    bool on_event(SubghzApp* app, SubghzEvent* event) final;
+    void on_exit(SubghzApp* app) final;
+
+private:
+    void submenu_callback(void* context, uint32_t index);
+};

applications/subghz/subghz-app.cpp

@@ -0,0 +1,90 @@
+#include "subghz-app.h"
+#include <api-hal-power.h>
+#include <stdarg.h>
+
+void SubghzApp::run(void) {
+    SubghzEvent event;
+    bool consumed;
+    bool exit = false;
+
+    scenes[current_scene]->on_enter(this);
+
+    while(!exit) {
+        view.receive_event(&event);
+
+        consumed = scenes[current_scene]->on_event(this, &event);
+
+        if(!consumed) {
+            if(event.type == SubghzEvent::Type::Back) {
+                exit = switch_to_previous_scene();
+            }
+        }
+    };
+
+    scenes[current_scene]->on_exit(this);
+}
+
+SubghzApp::SubghzApp() {
+    api_hal_power_insomnia_enter();
+}
+
+SubghzApp::~SubghzApp() {
+    api_hal_power_insomnia_exit();
+}
+
+SubghzAppViewManager* SubghzApp::get_view_manager() {
+    return &view;
+}
+
+void SubghzApp::switch_to_next_scene(Scene next_scene) {
+    previous_scenes_list.push_front(current_scene);
+
+    if(next_scene != Scene::SceneExit) {
+        scenes[current_scene]->on_exit(this);
+        current_scene = next_scene;
+        scenes[current_scene]->on_enter(this);
+    }
+}
+
+void SubghzApp::search_and_switch_to_previous_scene(std::initializer_list<Scene> scenes_list) {
+    Scene previous_scene = Scene::SceneStart;
+    bool scene_found = false;
+
+    while(!scene_found) {
+        previous_scene = get_previous_scene();
+        for(Scene element : scenes_list) {
+            if(previous_scene == element || previous_scene == Scene::SceneStart) {
+                scene_found = true;
+                break;
+            }
+        }
+    }
+
+    scenes[current_scene]->on_exit(this);
+    current_scene = previous_scene;
+    scenes[current_scene]->on_enter(this);
+}
+
+bool SubghzApp::switch_to_previous_scene(uint8_t count) {
+    Scene previous_scene = Scene::SceneStart;
+
+    for(uint8_t i = 0; i < count; i++) {
+        previous_scene = get_previous_scene();
+        if(previous_scene == Scene::SceneExit) break;
+    }
+
+    if(previous_scene == Scene::SceneExit) {
+        return true;
+    } else {
+        scenes[current_scene]->on_exit(this);
+        current_scene = previous_scene;
+        scenes[current_scene]->on_enter(this);
+        return false;
+    }
+}
+
+SubghzApp::Scene SubghzApp::get_previous_scene() {
+    Scene scene = previous_scenes_list.front();
+    previous_scenes_list.pop_front();
+    return scene;
+}

applications/subghz/subghz-app.h

@@ -0,0 +1,37 @@
+#pragma once
+#include <map>
+#include <list>
+#include "subghz-view-manager.h"
+
+#include "scene/subghz-scene-start.h"
+#include "scene/subghz-scene-spectrum-settings.h"
+
+class SubghzApp {
+public:
+    void run(void);
+
+    SubghzApp();
+    ~SubghzApp();
+
+    enum class Scene : uint8_t {
+        SceneExit,
+        SceneStart,
+        SceneSpectrumSettings,
+    };
+
+    SubghzAppViewManager* get_view_manager();
+    void switch_to_next_scene(Scene index);
+    void search_and_switch_to_previous_scene(std::initializer_list<Scene> scenes_list);
+    bool switch_to_previous_scene(uint8_t count = 1);
+    Scene get_previous_scene();
+
+private:
+    std::list<Scene> previous_scenes_list = {Scene::SceneExit};
+    Scene current_scene = Scene::SceneStart;
+    SubghzAppViewManager view;
+
+    std::map<Scene, SubghzScene*> scenes = {
+        {Scene::SceneStart, new SubghzSceneStart()},
+        {Scene::SceneSpectrumSettings, new SubghzSceneSpectrumSettings()},
+    };
+};

applications/subghz/subghz-event.h

@@ -0,0 +1,21 @@
+#pragma once
+#include <stdint.h>
+
+class SubghzEvent {
+public:
+    // events enum
+    enum class Type : uint8_t {
+        Tick,
+        Back,
+        MenuSelected,
+        NextScene,
+    };
+
+    // payload
+    union {
+        uint32_t menu_index;
+    } payload;
+
+    // event type
+    Type type;
+};

applications/subghz/subghz-view-manager.cpp

@@ -0,0 +1,81 @@
+#include "subghz-view-manager.h"
+#include "subghz-event.h"
+#include <callback-connector.h>
+
+SubghzAppViewManager::SubghzAppViewManager() {
+    event_queue = osMessageQueueNew(10, sizeof(SubghzEvent), NULL);
+
+    view_dispatcher = view_dispatcher_alloc();
+    auto callback = cbc::obtain_connector(this, &SubghzAppViewManager::previous_view_callback);
+
+    // allocate views
+    submenu = submenu_alloc();
+    view_dispatcher_add_view(
+        view_dispatcher,
+        static_cast<uint32_t>(SubghzAppViewManager::ViewType::Submenu),
+        submenu_get_view(submenu));
+
+    spectrum_settings = new SubghzViewSpectrumSettings();
+    view_dispatcher_add_view(
+        view_dispatcher,
+        static_cast<uint32_t>(SubghzAppViewManager::ViewType::SpectrumSettings),
+        spectrum_settings->get_view());
+
+    gui = static_cast<Gui*>(furi_record_open("gui"));
+    view_dispatcher_attach_to_gui(view_dispatcher, gui, ViewDispatcherTypeFullscreen);
+
+    // set previous view callback for all views
+    view_set_previous_callback(submenu_get_view(submenu), callback);
+    view_set_previous_callback(spectrum_settings->get_view(), callback);
+}
+
+SubghzAppViewManager::~SubghzAppViewManager() {
+    // remove views
+    view_dispatcher_remove_view(
+        view_dispatcher, static_cast<uint32_t>(SubghzAppViewManager::ViewType::Submenu));
+    view_dispatcher_remove_view(
+        view_dispatcher, static_cast<uint32_t>(SubghzAppViewManager::ViewType::SpectrumSettings));
+
+    // free view modules
+    submenu_free(submenu);
+    free(spectrum_settings);
+
+    // free dispatcher
+    view_dispatcher_free(view_dispatcher);
+
+    // free event queue
+    osMessageQueueDelete(event_queue);
+}
+
+void SubghzAppViewManager::switch_to(ViewType type) {
+    view_dispatcher_switch_to_view(view_dispatcher, static_cast<uint32_t>(type));
+}
+
+Submenu* SubghzAppViewManager::get_submenu() {
+    return submenu;
+}
+
+SubghzViewSpectrumSettings* SubghzAppViewManager::get_spectrum_settings() {
+    return spectrum_settings;
+}
+
+void SubghzAppViewManager::receive_event(SubghzEvent* event) {
+    if(osMessageQueueGet(event_queue, event, NULL, 100) != osOK) {
+        event->type = SubghzEvent::Type::Tick;
+    }
+}
+
+void SubghzAppViewManager::send_event(SubghzEvent* event) {
+    osStatus_t result = osMessageQueuePut(event_queue, event, 0, 0);
+    furi_check(result == osOK);
+}
+
+uint32_t SubghzAppViewManager::previous_view_callback(void* context) {
+    if(event_queue != NULL) {
+        SubghzEvent event;
+        event.type = SubghzEvent::Type::Back;
+        send_event(&event);
+    }
+
+    return VIEW_IGNORE;
+}

applications/subghz/subghz-view-manager.h

@@ -0,0 +1,37 @@
+#pragma once
+#include <furi.h>
+#include <gui/view_dispatcher.h>
+#include <gui/modules/submenu.h>
+#include "subghz-event.h"
+#include "view/subghz-view-spectrum-settings.h"
+
+class SubghzAppViewManager {
+public:
+    enum class ViewType : uint8_t {
+        Submenu,
+        SpectrumSettings,
+    };
+
+    osMessageQueueId_t event_queue;
+
+    SubghzAppViewManager();
+    ~SubghzAppViewManager();
+
+    void switch_to(ViewType type);
+
+    void receive_event(SubghzEvent* event);
+    void send_event(SubghzEvent* event);
+
+    Submenu* get_submenu();
+    SubghzViewSpectrumSettings* get_spectrum_settings();
+
+private:
+    ViewDispatcher* view_dispatcher;
+    Gui* gui;
+
+    uint32_t previous_view_callback(void* context);
+
+    // view elements
+    Submenu* submenu;
+    SubghzViewSpectrumSettings* spectrum_settings;
+};

applications/subghz/subghz.cpp

@@ -0,0 +1,10 @@
+#include "subghz-app.h"
+
+// app enter function
+extern "C" int32_t app_subghz(void* p) {
+    SubghzApp* app = new SubghzApp();
+    app->run();
+    delete app;
+
+    return 255;
+}

applications/subghz/view/subghz-view-spectrum-settings.cpp

@@ -0,0 +1,95 @@
+#include "subghz-view-spectrum-settings.h"
+#include <callback-connector.h>
+
+struct SpectrumSettingsModel {
+    uint32_t start_freq;
+};
+
+/***************************************************************************************/
+
+static void draw_callback(Canvas* canvas, void* _model) {
+    SpectrumSettingsModel* model = static_cast<SpectrumSettingsModel*>(_model);
+    const uint8_t str_size = 64;
+    char str_buffer[str_size];
+
+    canvas_clear(canvas);
+    snprintf(str_buffer, str_size, "Start freq < %ld > MHz", model->start_freq);
+    canvas_draw_str_aligned(canvas, 64, 32, AlignCenter, AlignCenter, str_buffer);
+}
+
+static bool input_callback(InputEvent* event, void* context) {
+    SubghzViewSpectrumSettings* _this = static_cast<SubghzViewSpectrumSettings*>(context);
+
+    bool consumed = false;
+
+    // Process key presses only
+    if(event->type == InputTypeShort) {
+        if(event->key == InputKeyOk) {
+            _this->call_ok_callback();
+            consumed = true;
+        } else if(event->key == InputKeyLeft) {
+            with_view_model_cpp(_this->get_view(), SpectrumSettingsModel, model, {
+                model->start_freq--;
+                return true;
+            });
+            consumed = true;
+        } else if(event->key == InputKeyRight) {
+            with_view_model_cpp(_this->get_view(), SpectrumSettingsModel, model, {
+                model->start_freq++;
+                return true;
+            });
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+/***************************************************************************************/
+
+View* SubghzViewSpectrumSettings::get_view() {
+    return view;
+}
+
+void SubghzViewSpectrumSettings::set_ok_callback(OkCallback callback, void* context) {
+    ok_callback = callback;
+    ok_callback_context = context;
+}
+
+void SubghzViewSpectrumSettings::call_ok_callback() {
+    if(ok_callback != nullptr) {
+        ok_callback(ok_callback_context);
+    }
+}
+
+void SubghzViewSpectrumSettings::set_start_freq(uint32_t start_freq) {
+    with_view_model_cpp(view, SpectrumSettingsModel, model, {
+        model->start_freq = start_freq;
+        return true;
+    });
+}
+
+uint32_t SubghzViewSpectrumSettings::get_start_freq() {
+    uint32_t result;
+
+    with_view_model_cpp(view, SpectrumSettingsModel, model, {
+        result = model->start_freq;
+        return false;
+    });
+
+    return result;
+}
+
+SubghzViewSpectrumSettings::SubghzViewSpectrumSettings() {
+    view = view_alloc();
+    view_set_context(view, this);
+    view_allocate_model(view, ViewModelTypeLocking, sizeof(SpectrumSettingsModel));
+
+    view_set_draw_callback(view, draw_callback);
+
+    view_set_input_callback(view, input_callback);
+}
+
+SubghzViewSpectrumSettings::~SubghzViewSpectrumSettings() {
+    view_free(view);
+}

applications/subghz/view/subghz-view-spectrum-settings.h

@@ -0,0 +1,25 @@
+#include <gui/view.h>
+
+class SubghzViewSpectrumSettings {
+public:
+    SubghzViewSpectrumSettings();
+    ~SubghzViewSpectrumSettings();
+
+    View* get_view();
+
+    // ok callback methods
+    typedef void (*OkCallback)(void* context);
+    void set_ok_callback(OkCallback callback, void* context);
+    void call_ok_callback();
+
+    // model data getters/setters
+    void set_start_freq(uint32_t start_freq);
+    uint32_t get_start_freq();
+
+private:
+    View* view;
+
+    // ok callback data
+    OkCallback ok_callback = nullptr;
+    void* ok_callback_context = nullptr;
+};