Momentum-Apps/link_camera.c

#include "link_camera.h"
#include <gui/elements.h>
#include <malveke_gb_link_camera_icons.h>
// #include <u8g2_glue.h>

QRCode qrcode;
uint8_t qrcodeData[((((4 * 8 + 17) * (4 * 8 + 17)) + 7) / 8)];

static uint32_t link_camera_exit(void *context)
{
    UNUSED(context);
    return VIEW_NONE;
}

static void view_draw_callback(Canvas *canvas, void *_model)
{
    LinkCameraModel *model = _model;
    canvas_clear(canvas);
    canvas_set_color(canvas, ColorBlack);
    canvas_set_font(canvas, FontPrimary);

    if (model->connected)
    {
        // canvas_draw_str_aligned(canvas, 128/2, 64/3, AlignCenter, AlignCenter, "Connected");
        // canvas_draw_str_aligned(canvas, 128/2, 64/2, AlignCenter, AlignCenter, model->ip);
        /*
        char ssid[64]; // Incrementa el tamaño a 64
        char password[64]; // Incrementa el tamaño a 64
        char qrstr[150]; // Deja qrstr con el tamaño actual
        snprintf(ssid, sizeof(ssid), "%s", "[MALVEKE] Flipper GB Camera");
        snprintf(password, sizeof(password), "%s", "12345678");
        snprintf(qrstr, sizeof(qrstr), "WIFI:S:%s;T:WPA2;P:%s;;", ssid, password);
        qrcode_initText(&qrcode, qrcodeData, 2, 0, qrstr);
        // canvas_draw_frame(canvas, 63, 63, 0, 0);

        for (uint8_t y = 0; y < qrcode.size; y++) {
            // Cada módulo horizontal
            for (uint8_t x = 0; x < qrcode.size; x++) {
                if (qrcode_getModule(&qrcode, x, y)) {
                    if(qrcode_getModule(&qrcode, x, y)) {
                        // canvas_draw_dot(canvas, x, y);
                        int scale = 2;
                        // // Dibuja cada punto dos veces para escalar al doble
                        canvas_draw_dot(canvas, (x * scale) + 2, (y * scale) + 4);
                        canvas_draw_dot(canvas, (x * scale + 1) + 2, (y * scale) + 4);
                        canvas_draw_dot(canvas, (x * scale) + 2, (y * scale + 1) + 4);
                        canvas_draw_dot(canvas, (x * scale + 1) + 2, (y * scale + 1) + 4);
                    }
                }
            }
        }
        canvas_set_font(canvas, FontPrimary);
        canvas_draw_str(canvas, 62, 11, "SSID");
        canvas_set_font(canvas, FontSecondary);
        // u8g2_SetFont(&canvas->fb, u8g2_font_5x7_tf); //u8g2_font_micro_tr);
        // canvas_set_font(canvas, FontBatteryPercent);
        canvas_draw_str(canvas, 62, 20, "[MALVEKE] Flipper GB Camera");
        canvas_set_font(canvas, FontPrimary);
        canvas_draw_str(canvas, 62, 30, "Password");
        canvas_set_font(canvas, FontSecondary);
        // canvas_set_font(canvas, u8g2_font_5x7_tf);
        canvas_draw_str(canvas, 62, 40, "12345678");

        */
        canvas_set_font(canvas, FontPrimary);
        canvas_draw_str(canvas, 2, 11, "SSID");
        canvas_set_font(canvas, FontSecondary);
        // u8g2_SetFont(&canvas->fb, u8g2_font_5x7_tf); //u8g2_font_micro_tr);
        // canvas_set_font(canvas, FontBatteryPercent);
        canvas_draw_str(canvas, 2, 20, "[MALVEKE] Flipper GB Cam");
        canvas_set_font(canvas, FontPrimary);
        canvas_draw_str(canvas, 2, 30, "Password");
        canvas_set_font(canvas, FontSecondary);
        canvas_draw_str(canvas, 2, 40, "12345678");

        canvas_set_font(canvas, FontPrimary);
        canvas_draw_str(canvas, 2, 50, "Host");
        canvas_set_font(canvas, FontSecondary);
        canvas_draw_str(canvas, 2, 60, model->ip);
    }
    else
    {
        canvas_draw_icon(canvas, 60, 7, &I_malveke_67x49);
        canvas_set_font(canvas, FontSecondary);

        canvas_draw_str(canvas, 4, 25, "Connect");
        canvas_set_font(canvas, FontPrimary);
        canvas_draw_str(canvas, 4, 35, "MALVEKE");
        canvas_set_font(canvas, FontSecondary);
        canvas_draw_str(canvas, 4, 44, "into Flipper");
        elements_button_center(canvas, "Ok");
    }

    // if (!model->initialized){
    //     canvas_clear(canvas);
    //     canvas_draw_icon(canvas, 74, 16, &I_DolphinCommon_56x48);
    //     canvas_set_font(canvas, FontSecondary);
    //     canvas_draw_str(canvas, 8, 12, "Waiting MALVEKE Board...");
    //     // canvas_draw_str(canvas, 20, 24, "VCC - 3V3/5V");
    //     // canvas_draw_str(canvas, 20, 34, "GND - GND");
    //     // canvas_draw_str(canvas, 20, 44, "U0R - TX");
    //     // canvas_draw_str(canvas, 20, 54, "U0T - RX");
    // }
}
static bool view_input_callback(InputEvent *event, void *context)
{
    LinkCameraApp *instance = context;
    UNUSED(instance);
    if (event->type == InputTypePress)
    {
        if (event->key == InputKeyBack)
        {
            uart_set_handle_rx_data_cb(instance->uart, NULL);
            uart_free(instance->uart);

            furi_hal_power_disable_external_3_3v();
            furi_delay_ms(100);
            furi_hal_power_enable_external_3_3v();
            furi_delay_ms(200);
        }
        else if (event->key == InputKeyOk)
        {

            furi_hal_power_disable_external_3_3v();
            furi_delay_ms(100);
            furi_hal_power_enable_external_3_3v();
            furi_delay_ms(200);

            with_view_model(
                instance->view,
                LinkCameraModel * model,
                {
                    model->initialized = true;
                },
                true);
            uart_tx((uint8_t *)("c"), 1);
            uart_tx((uint8_t *)("\n"), 1);

        }
    }
    return false;
}
static void link_camera_free(LinkCameraApp *app)
{
    furi_assert(app);
    // Free views
    view_dispatcher_remove_view(app->view_dispatcher, 0);
    view_free(app->view);
    view_dispatcher_free(app->view_dispatcher);
    // Close gui record
    furi_record_close(RECORD_GUI);
    furi_record_close(RECORD_STORAGE);
    app->gui = NULL;
    // Free rest
    free(app);
}
void handle_rx_data_cb(uint8_t *buf, size_t len, void *context)
{
    furi_assert(context);
    UNUSED(len);
    // UNUSED(buf);
    LinkCameraApp *instance = (LinkCameraApp *)context;

    // FURI_LOG_I("UART", "[in]: %s", (char*)buf);
    with_view_model(
        instance->view,
        LinkCameraModel * model,
        {
            cJSON *json = cJSON_Parse((char *)buf);
            if (json == NULL)
            {
            }
            else
            {
                cJSON *type = cJSON_GetObjectItemCaseSensitive(json, "type");
                if (cJSON_IsString(type) && (type->valuestring != NULL))
                {
                    model->event_type = strdup(type->valuestring);
                }
                else
                {
                    model->event_type = "None";
                }

                if (strcmp(model->event_type, "connected") == 0)
                {
                    cJSON *ip = cJSON_GetObjectItemCaseSensitive(json, "ip");
                    if (cJSON_IsString(ip) && (ip->valuestring != NULL))
                    {
                        model->ip = strdup(ip->valuestring);
                    }
                    else
                    {
                        model->ip = "0.0.0.0";
                    }
                    cJSON *ssid = cJSON_GetObjectItemCaseSensitive(json, "ssid");
                    if (cJSON_IsString(ssid) && (ssid->valuestring != NULL))
                    {
                        model->ssid = strdup(ssid->valuestring);
                    }
                    else
                    {
                        model->ssid = " - ";
                    }
                    cJSON *password = cJSON_GetObjectItemCaseSensitive(json, "password");
                    if (cJSON_IsString(password) && (password->valuestring != NULL))
                    {
                        model->password = strdup(password->valuestring);
                    }
                    else
                    {
                        model->password = "******";
                    }
                    model->connected = true;
                }
            }
        },
        true);
}
static LinkCameraApp *link_camera_alloc()
{
    LinkCameraApp *app = malloc(sizeof(LinkCameraApp));
    // Gui
    app->gui = furi_record_open(RECORD_GUI);
    app->storage = furi_record_open(RECORD_STORAGE);

    app->uart = usart_init(app);
    uart_set_handle_rx_data_cb(app->uart, handle_rx_data_cb);

    // View dispatcher
    app->view_dispatcher = view_dispatcher_alloc();
    view_dispatcher_enable_queue(app->view_dispatcher);
    view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);

    // Views
    app->view = view_alloc();
    view_set_context(app->view, app);
    view_set_draw_callback(app->view, view_draw_callback);
    view_set_input_callback(app->view, view_input_callback);
    view_allocate_model(app->view, ViewModelTypeLocking, sizeof(LinkCameraModel));

    view_set_previous_callback(app->view, link_camera_exit);
    view_dispatcher_add_view(app->view_dispatcher, 0, app->view);
    view_dispatcher_switch_to_view(app->view_dispatcher, 0);

    // furi_hal_power_disable_external_3_3v();
    // furi_delay_ms(100);
    // furi_hal_power_enable_external_3_3v();
    // furi_delay_ms(200);

    // with_view_model(
    //     app->view,
    //     LinkCameraModel * model,
    //     {
    //         model->initialized = true;
    //     },
    //     true);
    // uart_tx((uint8_t*)("c"), 1);
    // uart_tx((uint8_t*)("\n"), 1);

    return app;
}

int32_t link_camera_app(void *p)
{
    UNUSED(p);

    LinkCameraApp *app = link_camera_alloc();
    view_dispatcher_run(app->view_dispatcher);
    link_camera_free(app);

    // furi_hal_power_disable_otg();

    return 0;
}