unleashed-firmware/applications/plugins/morse_code/morse_code.c

#include "morse_code_worker.h"
#include <furi.h>
#include <gui/gui.h>
#include <gui/elements.h>
#include <input/input.h>
#include <stdlib.h>
#include <furi_hal.h>
#include <string.h>

static const float MORSE_CODE_VOLUMES[] = {0, .25, .5, .75, 1};

typedef struct {
    FuriString* words;
    uint8_t volume;
    uint32_t dit_delta;
} MorseCodeModel;

typedef struct {
    MorseCodeModel* model;
    FuriMutex** model_mutex;

    FuriMessageQueue* input_queue;

    ViewPort* view_port;
    Gui* gui;

    MorseCodeWorker* worker;
} MorseCode;


static void render_callback(Canvas* const canvas, void* ctx) {
    MorseCode* morse_code = ctx;
    furi_check(furi_mutex_acquire(morse_code->model_mutex, FuriWaitForever) == FuriStatusOk);
    // border around the edge of the screen
    canvas_set_font(canvas, FontPrimary);

    //write words
    elements_multiline_text_aligned(canvas, 64, 30, AlignCenter, AlignCenter, furi_string_get_cstr(morse_code->model->words));
    
     // volume view_port
    uint8_t vol_bar_x_pos = 124;
    uint8_t vol_bar_y_pos = 0;
    const uint8_t volume_h =
        (64 / (COUNT_OF(MORSE_CODE_VOLUMES) - 1)) * morse_code->model->volume;
    canvas_draw_frame(canvas, vol_bar_x_pos, vol_bar_y_pos, 4, 64);
    canvas_draw_box(canvas, vol_bar_x_pos, vol_bar_y_pos + (64 - volume_h), 4, volume_h);

    //dit bpm
    canvas_draw_str_aligned(
        canvas, 0, 10, AlignLeft, AlignCenter, furi_string_get_cstr(furi_string_alloc_printf("Dit: %ld ms", morse_code->model->dit_delta)));
    
    //button info
    elements_button_center(canvas, "Press/Hold");
    furi_mutex_release(morse_code->model_mutex);
}

static void input_callback(InputEvent* input_event, void* ctx) {
    MorseCode* morse_code = ctx;
    furi_message_queue_put(morse_code->input_queue, input_event, FuriWaitForever);
}

static void morse_code_worker_callback(
    FuriString* words,
    void* context) {
    MorseCode* morse_code = context;
    furi_check(furi_mutex_acquire(morse_code->model_mutex, FuriWaitForever) == FuriStatusOk);
    morse_code->model->words = words;
    furi_mutex_release(morse_code->model_mutex);
    view_port_update(morse_code->view_port);
}

MorseCode* morse_code_alloc() {
    MorseCode* instance = malloc(sizeof(MorseCode));

    instance->model = malloc(sizeof(MorseCodeModel));
    instance->model->words = furi_string_alloc_set_str("");
    instance->model->volume = 3;
    instance->model->dit_delta = 150;
    instance->model_mutex = furi_mutex_alloc(FuriMutexTypeNormal);

    instance->input_queue = furi_message_queue_alloc(8, sizeof(InputEvent));

    instance->worker = morse_code_worker_alloc();

    morse_code_worker_set_callback(instance->worker, morse_code_worker_callback, instance);

    instance->view_port = view_port_alloc();
    view_port_draw_callback_set(instance->view_port, render_callback, instance);
    view_port_input_callback_set(instance->view_port, input_callback, instance);

    // Open GUI and register view_port
    instance->gui = furi_record_open(RECORD_GUI);
    gui_add_view_port(instance->gui, instance->view_port, GuiLayerFullscreen);

    return instance;
}

void morse_code_free(MorseCode* instance) {
    gui_remove_view_port(instance->gui, instance->view_port);
    furi_record_close(RECORD_GUI);
    view_port_free(instance->view_port);

    morse_code_worker_free(instance->worker);

    furi_message_queue_free(instance->input_queue);

    furi_mutex_free(instance->model_mutex);

    free(instance->model);
    free(instance);
}

int32_t morse_code_app() {
    MorseCode* morse_code = morse_code_alloc();
    InputEvent input;
    morse_code_worker_start(morse_code->worker);
    morse_code_worker_set_volume(
                    morse_code->worker, MORSE_CODE_VOLUMES[morse_code->model->volume]);
    morse_code_worker_set_dit_delta(morse_code->worker,  morse_code->model->dit_delta);
    while(furi_message_queue_get(morse_code->input_queue, &input, FuriWaitForever) == FuriStatusOk){
        furi_check(furi_mutex_acquire(morse_code->model_mutex, FuriWaitForever) == FuriStatusOk);
        if(input.key == InputKeyBack) {
                furi_mutex_release(morse_code->model_mutex);
                break;
        }else if(input.key == InputKeyOk){
                if(input.type == InputTypePress)
                    morse_code_worker_play(morse_code->worker, true);
                else if(input.type == InputTypeRelease)
                    morse_code_worker_play(morse_code->worker, false);
            }else if(input.key == InputKeyUp && input.type == InputTypePress){
                 if(morse_code->model->volume < COUNT_OF(MORSE_CODE_VOLUMES) - 1)
                    morse_code->model->volume++;
                morse_code_worker_set_volume(
                    morse_code->worker, MORSE_CODE_VOLUMES[morse_code->model->volume]);
            }else if(input.key == InputKeyDown && input.type == InputTypePress){
                 if(morse_code->model->volume > 0) 
                    morse_code->model->volume--;
                morse_code_worker_set_volume(
                    morse_code->worker, MORSE_CODE_VOLUMES[morse_code->model->volume]);
            }else if(input.key == InputKeyLeft && input.type == InputTypePress){
                 if(morse_code->model->dit_delta > 10) 
                    morse_code->model->dit_delta-=10;
                morse_code_worker_set_dit_delta(
                    morse_code->worker,  morse_code->model->dit_delta);
            }
            else if(input.key == InputKeyRight && input.type == InputTypePress){
                 if(morse_code->model->dit_delta >= 10) 
                    morse_code->model->dit_delta+=10;
                morse_code_worker_set_dit_delta(
                    morse_code->worker,  morse_code->model->dit_delta);
            }
                
        FURI_LOG_D("Input", "%s %s %ld", input_get_key_name(input.key), input_get_type_name(input.type), input.sequence);
        
        furi_mutex_release(morse_code->model_mutex);
        view_port_update(morse_code->view_port);  
    }
    morse_code_worker_stop(morse_code->worker);
    morse_code_free(morse_code);
    return 0;
}