Momentum-Apps/flip_wifi/flipper_http/flipper_http.h

// Description: Flipper HTTP API (For use with Flipper Zero and the FlipperHTTP flash: https://github.com/jblanked/FlipperHTTP)
// License: MIT
// Author: JBlanked
// File: flipper_http.h
#pragma once

#include <gui/gui.h>
#include <gui/view.h>
#include <gui/view_dispatcher.h>
#include <gui/modules/loading.h>
#include <furi.h>
#include <furi_hal.h>
#include <furi_hal_gpio.h>
#include <furi_hal_serial.h>
#include <storage/storage.h>
#include <momentum/settings.h>

#define HTTP_TAG               "FlipWiFi" // change this to your app name
#define http_tag               "flip_wifi" // change this to your app id
#define UART_CH                (momentum_settings.uart_esp_channel) // UART channel
#define TIMEOUT_DURATION_TICKS (15 * 1000) // 15 seconds (for WiFi scanning)
#define BAUDRATE               (115200) // UART baudrate
#define RX_BUF_SIZE            2048 // UART RX buffer size
#define RX_LINE_BUFFER_SIZE    4096 // UART RX line buffer size (increase for large responses)
#define MAX_FILE_SHOW          4096 // Maximum data from file to show
#define FILE_BUFFER_SIZE       512 // File buffer size

// Forward declaration for callback
typedef void (*FlipperHTTP_Callback)(const char* line, void* context);

// State variable to track the UART state
typedef enum {
    INACTIVE, // Inactive state
    IDLE, // Default state
    RECEIVING, // Receiving data
    SENDING, // Sending data
    ISSUE, // Issue with connection
} HTTPState;

// Event Flags for UART Worker Thread
typedef enum {
    WorkerEvtStop = (1 << 0),
    WorkerEvtRxDone = (1 << 1),
} WorkerEvtFlags;

typedef enum {
    GET, // GET request
    POST, // POST request
    PUT, // PUT request
    DELETE, // DELETE request
    //
    BYTES, // Stream bytes to file
    BYTES_POST, // Stream bytes to file after a POST request
} HTTPMethod;

typedef enum {
    HTTP_CMD_WIFI_CONNECT,
    HTTP_CMD_WIFI_DISCONNECT,
    HTTP_CMD_IP_ADDRESS,
    HTTP_CMD_IP_WIFI,
    HTTP_CMD_SCAN,
    HTTP_CMD_LIST_COMMANDS,
    HTTP_CMD_LED_ON,
    HTTP_CMD_LED_OFF,
    HTTP_CMD_PING,
    HTTP_CMD_REBOOT
} HTTPCommand; // list of non-input commands

// FlipperHTTP Structure
typedef struct
{
    FuriStreamBuffer *flipper_http_stream;    // Stream buffer for UART communication
    FuriHalSerialHandle *serial_handle;       // Serial handle for UART communication
    FuriThread *rx_thread;                    // Worker thread for UART
    FuriThreadId rx_thread_id;                // Worker thread ID
    FlipperHTTP_Callback handle_rx_line_cb;   // Callback for received lines
    void *callback_context;                   // Context for the callback
    HTTPState state;                          // State of the UART
    HTTPMethod method;                        // HTTP method
    char *last_response;                      // variable to store the last received data from the UART
    FuriString *last_response_str;            // String to store the last received data
    char file_path[256];                      // Path to save the received data
    FuriTimer *get_timeout_timer;             // Timer for HTTP request timeout
    bool started_receiving;                   // Indicates if a request has started
    bool just_started;                        // Indicates if data reception has just started
    bool is_bytes_request;                    // Flag to indicate if the request is for bytes
    bool save_bytes;                          // Flag to save the received data to a file
    bool save_received_data;                  // Flag to save the received data to a file
    bool just_started_bytes;                  // Indicates if bytes data reception has just started
    size_t bytes_received;                    // Number of bytes received
    char rx_line_buffer[RX_LINE_BUFFER_SIZE]; // Buffer for received lines
    uint8_t file_buffer[FILE_BUFFER_SIZE]; // Buffer for file data
    size_t file_buffer_len; // Length of the file buffer
    size_t content_length; // Length of the content received
    int status_code; // HTTP status code
} FlipperHTTP;

/**
 * @brief      Initialize UART.
 * @return     FlipperHTTP context if the UART was initialized successfully, NULL otherwise.
 * @note       The received data will be handled asynchronously via the callback.
 */
FlipperHTTP* flipper_http_alloc();

/**
 * @brief      Deinitialize UART.
 * @return     void
 * @param fhttp The FlipperHTTP context
 * @note       This function will stop the asynchronous RX, release the serial handle, and free the resources.
 */
void flipper_http_free(FlipperHTTP* fhttp);

/**
 * @brief      Append received data to a file.
 * @return     true if the data was appended successfully, false otherwise.
 * @param      data        The data to append to the file.
 * @param      data_size   The size of the data to append.
 * @param      start_new_file  Flag to indicate if a new file should be created.
 * @param      file_path   The path to the file.
 * @note       Make sure to initialize the file path before calling this function.
 */
bool flipper_http_append_to_file(
    const void* data,
    size_t data_size,
    bool start_new_file,
    char* file_path);

/**
 * @brief      Send a command to deauthenticate a WiFi network.
 * @return     true if the request was successful, false otherwise.
 * @param fhttp The FlipperHTTP context
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_deauth_start(FlipperHTTP *fhttp, const char *ssid);

/**
 * @brief      Send a request to stop the deauth
 * @return     true if the request was successful, false otherwise.
 * @param fhttp The FlipperHTTP context
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_deauth_stop(FlipperHTTP *fhttp);

/**
 * @brief      Load data from a file.
 * @return     The loaded data as a FuriString.
 * @param      file_path The path to the file to load.
 */
FuriString* flipper_http_load_from_file(char* file_path);

/**
 * @brief      Load data from a file with a size limit.
 * @return     The loaded data as a FuriString.
 * @param      file_path The path to the file to load.
 * @param      limit     The size limit for loading data.
 */
FuriString* flipper_http_load_from_file_with_limit(char* file_path, size_t limit);

/**
 * @brief Perform a task while displaying a loading screen
 * @param fhttp The FlipperHTTP context
 * @param http_request The function to send the request
 * @param parse_response The function to parse the response
 * @param success_view_id The view ID to switch to on success
 * @param failure_view_id The view ID to switch to on failure
 * @param view_dispatcher The view dispatcher to use
 * @return
 */
void flipper_http_loading_task(
    FlipperHTTP* fhttp,
    bool (*http_request)(void),
    bool (*parse_response)(void),
    uint32_t success_view_id,
    uint32_t failure_view_id,
    ViewDispatcher** view_dispatcher);

/**
 * @brief      Parse JSON data.
 * @return     true if the JSON data was parsed successfully, false otherwise.
 * @param fhttp The FlipperHTTP context
 * @param      key       The key to parse from the JSON data.
 * @param      json_data The JSON data to parse.
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_parse_json(FlipperHTTP* fhttp, const char* key, const char* json_data);

/**
 * @brief      Parse JSON array data.
 * @return     true if the JSON array data was parsed successfully, false otherwise.
 * @param fhttp The FlipperHTTP context
 * @param      key       The key to parse from the JSON array data.
 * @param      index     The index to parse from the JSON array data.
 * @param      json_data The JSON array data to parse.
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_parse_json_array(
    FlipperHTTP* fhttp,
    const char* key,
    int index,
    const char* json_data);

/**
 * @brief Process requests and parse JSON data asynchronously
 * @param fhttp The FlipperHTTP context
 * @param http_request The function to send the request
 * @param parse_json The function to parse the JSON
 * @return true if successful, false otherwise
 */
bool flipper_http_process_response_async(
    FlipperHTTP* fhttp,
    bool (*http_request)(void),
    bool (*parse_json)(void));

/**
 * @brief      Send a request to the specified URL.
 * @return     true if the request was successful, false otherwise.
 * @param      fhttp The FlipperHTTP context
 * @param      method The HTTP method to use.
 * @param      url  The URL to send the request to.
 * @param      headers  The headers to send with the request.
 * @param      payload  The data to send with the request.
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_request(
    FlipperHTTP* fhttp,
    HTTPMethod method,
    const char* url,
    const char* headers,
    const char* payload);

/**
 * @brief      Send a command to save WiFi settings.
 * @return     true if the request was successful, false otherwise.
 * @param fhttp The FlipperHTTP context
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_save_wifi(FlipperHTTP* fhttp, const char* ssid, const char* password);

/**
 * @brief      Send a command.
 * @return     true if the request was successful, false otherwise.
 * @param      fhttp The FlipperHTTP context
 * @param      command The command to send.
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_send_command(FlipperHTTP* fhttp, HTTPCommand command);

/**
 * @brief      Send data over UART with newline termination.
 * @return     true if the data was sent successfully, false otherwise.
 * @param fhttp The FlipperHTTP context
 * @param      data  The data to send over UART.
 * @note       The data will be sent over UART with a newline character appended.
 */
bool flipper_http_send_data(FlipperHTTP* fhttp, const char* data);

/**
 * @brief      Send a request to the specified URL to start a WebSocket connection.
 * @return     true if the request was successful, false otherwise.
 * @param fhttp The FlipperHTTP context
 * @param      url  The URL to send the WebSocket request to.
 * @param port The port to connect to
 * @param headers The headers to send with the WebSocket request
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_websocket_start(
    FlipperHTTP* fhttp,
    const char* url,
    uint16_t port,
    const char* headers);

/**
 * @brief      Send a request to stop the WebSocket connection.
 * @return     true if the request was successful, false otherwise.
 * @param fhttp The FlipperHTTP context
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_websocket_stop(FlipperHTTP* fhttp);