Selfie Holder for T-LITE

//! Copyright (c) M5Stack. All rights reserved.
//! Licensed under the MIT license.
//! See LICENSE file in the project root for full license information.

#include "command_processor.hpp"
#include <esp_log.h>
#include <esp_sntp.h>
#include <esp_wifi.h>
#include <driver/gpio.h>

#include <vector>

#include <Preferences.h>
#include <WiFiServer.h>
#include <DNSServer.h>

#include <ArduinoJson.hpp>  // https://github.com/bblanchon/ArduinoJson/
#include <M5Unified.hpp>    // https://github.com/m5stack/M5Unified/
#include <lgfx/utility/lgfx_qrcode.h>

#include "common_header.h"
#include "screenshot_streamer.hpp"
#include "jpg/jpge.h"

#include "resource/bmp_logo.h"
#include "resource/jpg_staff.h"
#include "resource/wav_enter.h"

DNSServer dnsServer;

extern const unsigned char gWav_Click[112];

extern void webserverTask(void*);

auto& display = M5.Display;
// M5BurnerNVS burner_nvs;
screenshot_streamer_t screenshot_holder;
draw_param_t draw_param;

static constexpr const char* cloud_server_name = "ezdata.m5stack.com";

static constexpr const char* ntp_server[] = {"0.pool.ntp.org", "1.pool.ntp.org",
                                             "2.pool.ntp.org"};
volatile bool need_wifi_reconnect         = false;

extern "C" {
void esp_timer_impl_update_apb_freq(
    uint32_t apb_ticks_per_us);  // private in IDF
}

static constexpr const uint16_t label_ui_text_color = 0x8610u;

static constexpr const int32_t header_ui_height = 24;
static constexpr const int32_t battery_ui_width = 4;
static constexpr const uint8_t mlx_width        = 16;
static constexpr const uint8_t mlx_height       = 24;

static constexpr const char* graph_text_table[] = {"Cntr", "High", "Avrg",
                                                   "Low"};

static constexpr const uint32_t graph_color_table[] = {
    0x00909090u, 0x00FFCF00u, 0x0000A000u, 0x0000CFFFu};

static constexpr const int step_table[] = {1, 2, 5, 10, 20, 50, 100, 200};
static constexpr const size_t step_table_len =
    sizeof(step_table) / sizeof(step_table[0]);

const int32_t raw_step_offset = convertCelsiusToRaw(0.0f) - 128 * 1000;
// volatile size_t color_map_table_idx = 0;

static constexpr size_t framedata_len = 6;
framedata_t framedata[framedata_len];

volatile int idx_recv = -1;

static int smooth_move(int dst, int src) {
    return (dst == src) ? dst : ((dst + src + (src < dst ? 1 : 0)) >> 1);
    // return (dst == src) ? dst : ((dst * 3 + src * 5 + (src < dst ? 5 : 0)) >>
    // 3);
}

static void soundStartUp(void) {
    if (draw_param.misc_volume != draw_param.misc_volume_t::misc_volume_mute) {
        M5.Speaker.playRaw(wav_enter, sizeof(wav_enter), 48000);
        //     M5.Speaker.playRaw(wav_startup, sizeof(wav_startup), 24000);
    }
}
static void soundEnter(void) {
    if (draw_param.misc_volume != draw_param.misc_volume_t::misc_volume_mute) {
        M5.Speaker.playRaw(wav_enter, sizeof(wav_enter), 48000);
    }
}
static void soundExit(void) {
    if (draw_param.misc_volume != draw_param.misc_volume_t::misc_volume_mute) {
        M5.Speaker.playRaw(wav_enter, sizeof(wav_enter), 36000);
    }
}
static void soundMoveCursor(void) {
    if (draw_param.misc_volume != draw_param.misc_volume_t::misc_volume_mute) {
        M5.Speaker.playRaw(wav_enter, sizeof(wav_enter), 42000);
        // M5.Speaker.tone(4400, 80);
    }
}
static void soundValueChange(void) {
    if (draw_param.misc_volume != draw_param.misc_volume_t::misc_volume_mute) {
        M5.Speaker.playRaw(wav_enter, sizeof(wav_enter), 48000, false, 1, 0,
                           true);
        // M5.Speaker.tone(2200, 50, 0);
    }
}
static void soundOperate(void) {
    if (draw_param.misc_volume != draw_param.misc_volume_t::misc_volume_mute) {
        M5.Speaker.playRaw(wav_enter, sizeof(wav_enter), 48000);
        // M5.Speaker.playRaw(wav_confirm, sizeof(wav_confirm), 48000);
    }
}
static void soundUSBConnected(void) {
    if (draw_param.misc_volume != draw_param.misc_volume_t::misc_volume_mute) {
        M5.Speaker.tone(1046.502f, 64, 0, false);  // C6
        M5.Speaker.tone(880.000f, 64, 0, false);   // A5
        M5.Speaker.tone(1318.510f, 64, 0, false);  // E6
    }
}
static void soundUSBDisconnected(void) {
    if (draw_param.misc_volume != draw_param.misc_volume_t::misc_volume_mute) {
        M5.Speaker.tone(880.000f, 64, 0, false);  // A5
        M5.Speaker.tone(783.991f, 64, 0, false);  // G5
        M5.Speaker.tone(659.255f, 64, 0, false);  // E5
    }
}
static void soundWiFiConnected(void) {
    if (draw_param.misc_volume != draw_param.misc_volume_t::misc_volume_mute) {
        // M5.Speaker.playRaw(wav_connect, sizeof(wav_connect), 24000);
        M5.Speaker.tone(1046.502f, 64, 0, false);  // C6
        M5.Speaker.tone(1567.982f, 64, 0, false);  // G6
    }
}
static void soundWiFiDisconnected(void) {
    if (draw_param.misc_volume != draw_param.misc_volume_t::misc_volume_mute) {
        M5.Speaker.tone(1760.000f, 64, 0, false);  // A6
        M5.Speaker.tone(1174.659f, 64, 0, false);  // D6
    }
}
static void soundCloudSuccess(void) {
    if (draw_param.misc_volume != draw_param.misc_volume_t::misc_volume_mute) {
        // M5.Speaker.playRaw(wav_connect, sizeof(wav_connect), 24000);
        M5.Speaker.tone(2093.005f, 48, 0, false);  // C7
        M5.Speaker.tone(2637.020f, 48, 0, false);  // E7
        M5.Speaker.tone(3135.963f, 48, 0, false);  // G7
    }
}
static void soundCloudError(void) {
    if (draw_param.misc_volume != draw_param.misc_volume_t::misc_volume_mute) {
        M5.Speaker.tone(3520.000f, 48, 0, false);  // A7
        M5.Speaker.tone(2793.826f, 48, 0, false);  // F7
        M5.Speaker.tone(2349.318f, 48, 0, false);  // D7
    }
}

struct rect_t {
    int16_t x;
    int16_t y;
    int16_t w;
    int16_t h;
    constexpr rect_t(void) : x{0}, y{0}, w{0}, h{0} {
    }
    constexpr rect_t(int x_, int y_, int w_, int h_)
        : x{(int16_t)x_}, y{(int16_t)y_}, w{(int16_t)w_}, h{(int16_t)h_} {
    }
    inline constexpr int top(void) const {
        return y;
    }
    inline constexpr int left(void) const {
        return x;
    }
    inline constexpr int right(void) const {
        return x + w;
    }
    inline constexpr int bottom(void) const {
        return y + h;
    }
    inline constexpr bool empty(void) const {
        return w <= 0 || h <= 0;
    }

    bool smooth_move(const rect_t& src) {
        if (operator==(src)) return false;
        int new_b = ::smooth_move(src.bottom(), bottom());
        int new_y = ::smooth_move(src.y, y);
        h         = new_b - new_y;
        y         = new_y;
        int new_r = ::smooth_move(src.right(), right());
        int new_x = ::smooth_move(src.x, x);
        w         = new_r - new_x;
        x         = new_x;
        return true;
    }
    inline bool operator==(const rect_t& src) const {
        return x == src.x && y == src.y && w == src.w && h == src.h;
    }
    inline bool operator!=(const rect_t& src) const {
        return !operator==(src);
    }
};

static constexpr const char NVS_NAMESPACE[]         = "__tlite_nvs__";
static constexpr const char KEY_ALARM_TEMPERATURE[] = "alm_temp";
static constexpr const char KEY_ALARM_REFERENCE[]   = "alm_ref";
static constexpr const char KEY_ALARM_MODE[]        = "alm_mode";
// static constexpr const char KEY_ALARM_BEHAVIOR[]    = "alm_behavior";
static constexpr const char KEY_SENS_REFRESHRATE[] = "refreshrate";
static constexpr const char KEY_SENS_NOISEFILTER[] = "noisefilter";
static constexpr const char KEY_SENS_MONITORAREA[] = "monitorarea";
static constexpr const char KEY_SENS_EMISSIVITY[]  = "emissivity";
static constexpr const char KEY_RANGE_AUTOSWITCH[] = "range_auto";
static constexpr const char KEY_RANGE_UPPER[]      = "range_upper";
static constexpr const char KEY_RANGE_LOWER[]      = "range_lower";
static constexpr const char KEY_NET_RUNNING_MODE[] = "net_running";
static constexpr const char KEY_NET_JPGQUALITY[]   = "jpg_quality";
static constexpr const char KEY_CLOUD_UPLOAD[]     = "upload_ena";
static constexpr const char KEY_CLOUD_INTERVAL[]   = "upload_int";
static constexpr const char KEY_CLOUD_TOKEN[]      = "ezdata_token";
static constexpr const char KEY_NET_TIMEZONE[]     = "timezone";
static constexpr const char KEY_MISC_CPUSPEED[]    = "cpuspeed";
static constexpr const char KEY_MISC_BRIGHTNESS[]  = "brightness";
static constexpr const char KEY_MISC_VOLUME[]      = "volume";
static constexpr const char KEY_MISC_LANGUAGE[]    = "language";
static constexpr const char KEY_MISC_LAYOUT[]      = "layout";
static constexpr const char KEY_MISC_COLOR[]       = "color";
static constexpr const char KEY_MISC_POINTER[]     = "pointer";
// static constexpr const char KEY_MISC_ROTATION[]     = "msc_rotation";

std::string convert(const std::string& src) {
    std::string res;
    int i = src.length();
    for (auto c : src) {
        i = (i + 1) & 15;
        c = c ^ i;
        res.append(1, c);
    }
    return res;
}

void config_param_t::saveNvs(void) {
    ESP_LOGD("DEBUG", "saveNvs in");
    /// ToDo:FlashROM
    Preferences pref;
    bool exist = pref.begin(NVS_NAMESPACE, false);
    pref.putUShort(KEY_ALARM_TEMPERATURE, alarm_temperature.get());
    pref.putUChar(KEY_ALARM_REFERENCE, alarm_reference);
    pref.putUChar(KEY_ALARM_MODE, alarm_mode);
    // pref.putUChar( KEY_ALARM_BEHAVIOR   , alarm_behavior       );
    pref.putUChar(KEY_MISC_CPUSPEED, misc_cpuspeed);
    pref.putUChar(KEY_SENS_REFRESHRATE, sens_refreshrate);
    pref.putUChar(KEY_SENS_NOISEFILTER, sens_noisefilter);
    pref.putUChar(KEY_SENS_MONITORAREA, sens_monitorarea);
    pref.putUChar(KEY_SENS_EMISSIVITY, sens_emissivity);
    pref.putUChar(KEY_RANGE_AUTOSWITCH, range_autoswitch);
    pref.putUShort(KEY_RANGE_UPPER, range_temp_upper);
    pref.putUShort(KEY_RANGE_LOWER, range_temp_lower);
    pref.putUChar(KEY_NET_RUNNING_MODE, net_running_mode);
    // pref.putUChar( KEY_NET_SETUP_MODE   , net_setup_mode       );
    // pref.putBool(  KEY_NET_WEBSERVER    , net_webserver        );
    pref.putUChar(KEY_NET_JPGQUALITY, net_jpg_quality);
    pref.putInt(KEY_NET_TIMEZONE, oncloud_timezone_sec);
    // pref.putBool(  KEY_CLOUD_UPLOAD     , cloud_upload         );
    pref.putUChar(KEY_CLOUD_INTERVAL, cloud_interval);
    pref.putUChar(KEY_MISC_BRIGHTNESS, misc_brightness);
    pref.putUChar(KEY_MISC_VOLUME, misc_volume);
    pref.putUChar(KEY_MISC_LANGUAGE, misc_language);
    pref.putUChar(KEY_MISC_POINTER, misc_pointer);
    pref.putUChar(KEY_MISC_LAYOUT, misc_layout);
    pref.putUChar(KEY_MISC_COLOR, misc_color);
    pref.putString(KEY_CLOUD_TOKEN, cloud_token.c_str());
    // pref.putString(KEY_NET_SSID         , net_ssid.c_str()     );
    // pref.putString(KEY_NET_PWD          , convert(net_pwd).c_str());
    // pref.putUChar( KEY_MISC_ROTATION    , misc_rotation        );
    pref.end();
    ESP_LOGD("DEBUG", "saveNvs out");
}

void config_param_t::loadNvs(void) {
    loadDefault();

    Preferences pref;
    if (pref.begin(NVS_NAMESPACE, true)) {
        alarm_temperature =
            pref.getUShort(KEY_ALARM_TEMPERATURE, alarm_temperature);
        alarm_reference = (alarm_reference_t)pref.getUChar(KEY_ALARM_REFERENCE,
                                                           alarm_reference);
        alarm_mode = (alarm_mode_t)pref.getUChar(KEY_ALARM_MODE, alarm_mode);
        // alarm_behavior       = (alarm_behavior_t)  pref.getUChar(
        // KEY_ALARM_BEHAVIOR   , alarm_behavior       );
        sens_refreshrate = (sens_refreshrate_t)pref.getUChar(
            KEY_SENS_REFRESHRATE, sens_refreshrate);
        sens_noisefilter = (sens_noisefilter_t)pref.getUChar(
            KEY_SENS_NOISEFILTER, sens_noisefilter);
        sens_monitorarea = (sens_monitorarea_t)pref.getUChar(
            KEY_SENS_MONITORAREA, sens_monitorarea);
        sens_emissivity  = pref.getUChar(KEY_SENS_EMISSIVITY, sens_emissivity);
        range_autoswitch = (range_autoswitch_t)pref.getUChar(
            KEY_RANGE_AUTOSWITCH, range_autoswitch);
        range_temp_upper = pref.getUShort(KEY_RANGE_UPPER, range_temp_upper);
        range_temp_lower = pref.getUShort(KEY_RANGE_LOWER, range_temp_lower);
        net_running_mode = (net_running_mode_t)pref.getUChar(
            KEY_NET_RUNNING_MODE, net_running_mode);
        // net_setup_mode       = (net_setup_mode_t)  pref.getUChar(
        // KEY_NET_SETUP_MODE   , net_setup_mode       ); net_webserver        =
        // pref.getBool(  KEY_NET_WEBSERVER    , net_webserver        );
        net_jpg_quality = pref.getUChar(KEY_NET_JPGQUALITY, net_jpg_quality);
        oncloud_timezone_sec =
            pref.getInt(KEY_NET_TIMEZONE, oncloud_timezone_sec);
        misc_cpuspeed =
            (misc_cpuspeed_t)pref.getUChar(KEY_MISC_CPUSPEED, misc_cpuspeed);
        misc_brightness = (misc_brightness_t)pref.getUChar(KEY_MISC_BRIGHTNESS,
                                                           misc_brightness);
        misc_volume =
            (misc_volume_t)pref.getUChar(KEY_MISC_VOLUME, misc_volume);
        misc_language =
            (misc_language_t)pref.getUChar(KEY_MISC_LANGUAGE, misc_language);
        misc_pointer =
            (misc_pointer_t)pref.getUChar(KEY_MISC_POINTER, misc_pointer);
        misc_layout = pref.getUChar(KEY_MISC_LAYOUT, misc_layout);
        misc_color  = (misc_color_t)pref.getUChar(KEY_MISC_COLOR, misc_color);
        // cloud_upload         = (cloud_upload_t)    pref.getUChar(
        // KEY_CLOUD_UPLOAD     , cloud_upload         );
        cloud_interval =
            (cloud_interval_t)pref.getUChar(KEY_CLOUD_INTERVAL, cloud_interval);
        cloud_token =
            pref.getString(KEY_CLOUD_TOKEN, cloud_token.c_str()).c_str();
        // net_ssid             = pref.getString(KEY_NET_SSID         ,
        // net_ssid.c_str()     ).c_str(); net_pwd              = convert(
        // pref.getString(KEY_NET_PWD          ,
        // convert(net_pwd).c_str()).c_str()).c_str(); misc_rotation        =
        // pref.getUChar( KEY_MISC_ROTATION    , misc_rotation        );
        pref.end();
    }

    config_save_countdown = 0;
}

void config_param_t::loadDefault(void) {
    // net_ssid.clear();
    // net_pwd.clear();
    net_running_mode  = net_running_mode_t::net_running_mode_offline;
    net_setup_mode    = net_setup_mode_t ::net_setup_mode_off;
    alarm_temperature = (100 + 64) * 128;
    alarm_mode        = alarm_mode_t ::alarm_mode_hightemp;
    alarm_reference   = alarm_reference_t ::alarm_reference_highest;
    // alarm_behavior    = alarm_behavior_t  ::alarm_behavior_beep_led ;
    sens_refreshrate = sens_refreshrate_t::sens_refreshrate_16;
    sens_noisefilter = sens_noisefilter_t::sens_noisefilter_medium;
    sens_monitorarea = sens_monitorarea_t::sens_monitorarea_30x24;
    sens_emissivity  = 98;
    range_autoswitch = range_autoswitch_t::range_autoswitch_on;
    range_temp_upper = (40 + 64) * 128;
    range_temp_lower = (20 + 64) * 128;
    misc_brightness  = misc_brightness_t ::misc_brightness_middle;
    misc_cpuspeed    = misc_cpuspeed_t ::misc_cpuspeed_160;
    misc_language    = misc_language_t ::misc_language_en;
    net_jpg_quality  = 60;
    cloud_interval   = cloud_interval_t ::cloud_interval_30sec;
    misc_layout      = 0;
    misc_color.setDefault();
    misc_pointer = misc_pointer_t ::misc_pointer_pointtxt;
    misc_volume  = misc_volume_t ::misc_volume_normal;
}

void config_param_t::setEmissivity(uint8_t emissivity) {
    sens_emissivity = emissivity;
    command_processor::setEmissivity(emissivity);
}

void config_param_t::setTimeZoneSec(int32_t sec) {
    oncloud_timezone_sec = sec;
    configTime(sec, 0, ntp_server[0], ntp_server[1], ntp_server[2]);
}

void config_param_t::referenceModeChange(int add) {
    alarm_reference.add(add);
    /*
        if (add) {
            int i = alarm_reference + add;
            if (i < 0)
                i = alarm_reference_t::alarm_reference_max - 1;
            else if (i >= alarm_reference_t::alarm_reference_max)
                i = 0;
            alarm_reference = (config_param_t::alarm_reference_t)i;
         // show_reference_name = 50; //
    alarm
        }
    //*/
}

/*
struct graph_filter_t {
    static constexpr const size_t hist_max = 3;
    // 5 : 13
    // 1 3
    uint16_t _hist[hist_max];
    uint8_t _idx = 0;
    uint16_t exec(uint16_t new_value) {
        _hist[_idx] = new_value;
        if (++_idx >= hist_max) { _idx = 0; }

        uint32_t avg_temp = 0;
        for (size_t i = 0; i < hist_max; ++i) {
            size_t k = abs((int)(i - _idx) * 2 + 1);
            if (k > hist_max) {
                k = hist_max * 2 - k;
            }
            avg_temp += _hist[i] * k;
        }
// ESP_LOGE("DEBUG","input:%d  avg:%d", new_value, avg_temp);
        return avg_temp / 5;
        // return new_value;
    }
};
static graph_filter_t graph_filter[4];
//*/

void draw_param_t::setup(LovyanGFX* gfx_, framedata_t* frame_array_,
                         int frameindex) {
    _frame_array = frame_array_;
    frame        = &frame_array_[frameindex];
    _lowest_value.set(frame->temp[frame->lowest]);
    _highest_value.set(frame->temp[frame->highest]);
    update(frameindex);

    for (int i = 0; i < 4; ++i) {
        auto tmp = frame->temp[i];
        for (int j = 0; j < graph_data.data_len; ++j) {
            graph_data.temp_arrays[i][j] = tmp;
        }
        // while (tmp != graph_filter[i].exec(tmp));
    }
    _prev_frameindex = -1;
}

void draw_param_t::setFont(const m5gfx::IFont* font_) {
    font = font_;
    display.setFont(font_);
    lgfx::FontMetrics fm;
    font->getDefaultMetric(&fm);
    font_height = fm.height;
}

void draw_param_t::setColorTable(const uint16_t* tbl) {
    color_map = tbl;
}

void draw_param_t::setColorTable(size_t idx) {
    color_map = color_map_table[idx];
}

bool draw_param_t::update(int frameindex) {
    if (_prev_frameindex == frameindex) return false;
    _prev_frameindex = frameindex;
    frame            = &_frame_array[frameindex];
    ++update_count;
    return true;
}

bool draw_param_t::range_update(void) {
    if (!frame) return false;
    if (range_autoswitch.get() == range_autoswitch_off) return true;

    int32_t lowest  = frame->temp[frame->lowest];
    int32_t highest = frame->temp[frame->highest];
    int32_t margin  = ((highest - lowest) >> 4) + 1;
    lowest          = _lowest_value.exec(lowest - margin, margin);
    highest         = _highest_value.exec(highest + margin, margin);
    if (range_temp_lower != lowest || range_temp_upper != highest) {
        range_temp_lower = lowest;
        range_temp_upper = highest;
        temp_diff        = (highest - lowest) + 1;
        ++modify_count;
        return true;
    }
    return false;
}

int32_t value_smooth_t::exec(int32_t src, int32_t margin) {
    /*
            int32_t new_target = src << 8;
            if (abs(new_target - _target) > (margin << 8)) {
                _target = new_target;
            }
            int diff = _target - _current;

            _add = ((_add + diff + 2) >> 5);
            if (diff) {
                _add += diff < 0 ? -1 : 1;
            }
            _current += _add;

            return _current >> 8;
    /*/
    int32_t new_target = src << 8;
    if (abs(new_target - _target) > (margin << 8)) {
        _target = new_target;
    }
    int diff = _target - _current;

    if (diff) {
        int ta    = 1;
        int tdiff = abs(diff);
        while (0 < (tdiff -= ta)) {
            ta *= 2;
        }
        ta += tdiff;

        if (diff < 0) {
            ta = -ta;
        }

        _add = (_add + (ta >> 1)) >> 1;
    }

    // _add = ((_add + diff + 2) >> 5);
    // if (diff) {
    //     _add += diff < 0 ? -1 : 1;
    // }
    _current += _add;

    return _current >> 8;
    //*/
}
void value_smooth_t::set(int32_t default_value) {
    _target  = default_value << 8;
    _current = default_value << 8;
}

// static constexpr const uint32_t jpeg_len_max = 8192 * 3;

screenshot_streamer_t::screenshot_streamer_t(void) {
    // JPEG (1)
    _queue_canvas = xQueueCreate(1, sizeof(screenshot_streamer_t::queue_ss_t));

    // WiFiClient
    _queue_bufdata =
        xQueueCreate(2, sizeof(screenshot_streamer_t::queue_bufdata_t));

    // 
    _queue_client = xQueueCreate(4, sizeof(WiFiClient*));
}

void screenshot_streamer_t::requestScreenShot(WiFiClient* client) {
    xQueueSendToBack(_queue_client, &client, 0);
    _is_requested = true;
}
/*
#include <lwip/sockets.h> // for 'send' function
static size_t write_fd(int socketFileDescriptor, const uint8_t *buf, size_t
size)
{
    int retry = 2;
    size_t totalBytesSent = 0;
    size_t bytesRemaining = size;

    if(socketFileDescriptor < 0) {
        return 0;
    }

    while(retry--) {
        //use select to make sure the socket is ready for writing
        fd_set set;
        struct timeval tv;
        FD_ZERO(&set);        // empties the set
        FD_SET(socketFileDescriptor, &set); // adds FD to the set
        tv.tv_sec = 0;
        tv.tv_usec = 100; // WIFI_CLIENT_SELECT_TIMEOUT_US;

        if (select(socketFileDescriptor + 1, NULL, &set, NULL, &tv) < 0) {
            return 0;
        }

        if (FD_ISSET(socketFileDescriptor, &set)) {
            int res = send(socketFileDescriptor, (void*) buf, bytesRemaining,
MSG_DONTWAIT); if(res > 0) { totalBytesSent += res; if (totalBytesSent >= size)
{
                    //completed successfully
                    retry = 0;
                } else {
                    buf += res;
                    bytesRemaining -= res;
                    retry = 2; // WIFI_CLIENT_MAX_WRITE_RETRY;
                }
            }
            else if(res < 0) {
                ESP_LOGE("DEBUG", "fail on fd %d, errno: %d, \"%s\"",
socketFileDescriptor, errno, strerror(errno)); if(errno != EAGAIN) {
                    //if resource was busy, can try again, otherwise give up
                    // stop();
                    retry = 0;
                }
            }
        }
    }
    return totalBytesSent;
}
//*/
void screenshot_streamer_t::streamTask(void* arg) {
    auto me = (screenshot_streamer_t*)arg;
    queue_bufdata_t qd;
    auto& cl = me->_wifi_client;
    while (pdTRUE == xQueueReceive(me->_queue_bufdata, &qd, portMAX_DELAY)) {
        auto len = qd.len;
        auto buf = qd.bufdata;
        if (qd.y0) {
            xQueueReceive(me->_queue_client, &cl, 0);
        }
        if (cl == nullptr) {
            continue;
        }
        if (cl->connected()) {
            if (len == cl->write(buf, len)) {
                continue;
            }
            cl->stop();
        }
        cl = nullptr;
    }
    vTaskDelete(nullptr);
}

bool screenshot_streamer_t::put_buf(const void* Pbuf, int len) {
    if (len) {
        _q_bufdata.len     = len;
        _q_bufdata.bufdata = (const uint8_t*)Pbuf;
        xQueueSendToBack(_queue_bufdata, &_q_bufdata, portMAX_DELAY);
        return true;
    }
    if (_wifi_client != nullptr) {
        requestScreenShot(_wifi_client);
    }
    return true;
}

bool screenshot_streamer_t::initCapture(uint16_t width, uint16_t height) {
    if (!_is_requested && !uxQueueMessagesWaiting(_queue_client)) {
        return false;
    }
    _is_requested = false;

    if (_width != width || _height != height) {
        int num_channels          = 3;
        jpge::params comp_params  = jpge::params();
        comp_params.m_subsampling = jpge::H2V2;
        comp_params.m_quality     = draw_param.net_jpg_quality;
        if (!_jpeg_enc.init(this, width, height, num_channels, comp_params)) {
            return false;
        }
        _y      = 0;
        _width  = width;
        _height = height;
    }
    return true;
}

bool screenshot_streamer_t::addQueue(M5Canvas* canvas, uint16_t y) {
    queue_ss_t queue_ss;
    queue_ss.canvas = canvas;
    queue_ss.y      = y;
    if (pdPASS != xQueueSendToBack(_queue_canvas, &queue_ss, 64)) {
        // ESP_LOGD("DEBUG","queue_timeout:y:%d", y);
        // 
        if (_wifi_client) {  // wifi_is_requested
            _is_requested = true;
        }
        return false;
    }
    return true;
}

screenshot_streamer_t::process_result_t screenshot_streamer_t::processCapture(
    void) {
    queue_ss_t queue_ss;
    // 
    // ()
    if (pdPASS != xQueuePeek(_queue_canvas, &queue_ss, 0)) {
        return pr_nothing;
    }

    if (_y != queue_ss.y) {
        // 
        xQueueReceive(_queue_canvas, &queue_ss, 0);
        return pr_error;
    }
    if (queue_ss.y == 0) {
        bool request  = uxQueueMessagesWaiting(_queue_client);
        _is_requested = request;
        if (!request) {
            xQueueReceive(_queue_canvas, &queue_ss, 0);
            return process_result_t::pr_nothing;
        }

        static constexpr const char headtext[] =
            "\r\n--tlite\r\nContent-type: image/jpeg\r\n\r\n";
        _q_bufdata.bufdata = (const uint8_t*)headtext;
        _q_bufdata.len     = sizeof(headtext) - 1;
        _q_bufdata.y0      = true;
        xQueueSendToBack(_queue_bufdata, &_q_bufdata, portMAX_DELAY);
        _q_bufdata.y0 = false;

        // JPEG ()
        _jpeg_enc.reinit(draw_param.net_jpg_quality);
    }

    _y += queue_ss.canvas->height();
    bool success = true;
    // bool lineend = false;
    auto framebuffer = (uint16_t*)(queue_ss.canvas->getBuffer());
    for (int i = 0; i < queue_ss.canvas->height(); ++i) {
        success = _jpeg_enc.process_scanline565(
            &framebuffer[i * queue_ss.canvas->width()]);
        if (++queue_ss.y >= _height) {
            break;
        }
        if (!success) {
            break;
        }
    }
    // 
    xQueueReceive(_queue_canvas, &queue_ss, 0);

    // JPEG
    if (success) {
        _jpeg_enc.process_mcu_row();
        if (_y >= _height) {
            _y = 0;
            _jpeg_enc.process_scanline565(nullptr);
        }
        return process_result_t::pr_progress;
    }
    // ESP_EARLY_LOGE("DEBUG","jpg encode error");
    return process_result_t::pr_error;

    //---------------------------------------------
}

struct ui_base_t {
    bool isModified(draw_param_t* param) const {
        return _prev_update_count != param->update_count ||
               _prev_modify_count != param->modify_count;
    }

    virtual void update(draw_param_t* param) {
    }

    virtual bool draw(draw_param_t* param) {
        bool res = _prev_update_count != param->update_count ||
                   _prev_modify_count != param->modify_count;

        _prev_update_count = param->update_count;
        _prev_modify_count = param->modify_count;

        return !_client_rect.empty() && res;
    }

    virtual void draw(draw_param_t* param, M5Canvas* canvas, int32_t y,
                      int32_t h) {
    }

    virtual bool smoothMove(void) {
        return _client_rect.smooth_move(_target_rect);
    }
    virtual void setTargetRect(const rect_t& rect) {
        _target_rect = rect;
    }
    void setClientRect(const rect_t& rect) {
        _client_rect = rect;
    }
    const rect_t& getTargetRect(void) const {
        return _target_rect;
    }
    const rect_t& getClientRect(void) const {
        return _client_rect;
    }

    void rotateCoordinate(int r, int& x, int& y, int& w, int& h) {
        if (r) {
            if (r & 1) {
                std::swap(x, y);
                std::swap(w, h);
            }
            if ((1u << r) & 0b0110) {
                x = _client_rect.w - (x + w);
            }
            if ((1u << r) & 0b1100) {
                y = _client_rect.h - (y + h);
            }
        }
    }

   protected:
    // inline void clearInvalidate(void) {
    //     _invalidate = false;
    // }
    // bool _invalidate;
    rect_t _client_rect;
    rect_t _target_rect;
    uint8_t _prev_update_count;
    uint8_t _prev_modify_count;
};

class qrcode_ui_t : public ui_base_t {
   public:
    std::string _qr_string = "teststring";
    M5Canvas _qr_canvas;
    void draw(draw_param_t* param, M5Canvas* canvas, int32_t canvas_y,
              int32_t h) override {
        canvas->fillScreen(TFT_WHITE);
        float zoom = (float)_client_rect.h / (_qr_canvas.height() + 4);
        _qr_canvas.pushRotateZoom(
            canvas, _client_rect.x + (_client_rect.w >> 1),
            _client_rect.y + (_client_rect.h >> 1) - canvas_y, 0, zoom, zoom);
    }
    void show(const char* data) {
        _qr_canvas.setColorDepth(1);
        _qr_string = data;
        for (uint8_t version = 1; version <= 40; ++version) {
            QRCode qrcode;
            auto qrcodeData =
                (uint8_t*)alloca(lgfx_qrcode_getBufferSize(version));
            if (0 !=
                lgfx_qrcode_initText(&qrcode, qrcodeData, version, 0, data))
                continue;
            _qr_canvas.createSprite(qrcode.size, qrcode.size);
            _qr_canvas.fillScreen(1);
            int_fast16_t thickness  = 1;
            int_fast16_t lineLength = qrcode.size;
            _qr_canvas.setColor(0);
            uint32_t y = 0;
            do {
                uint32_t x = 0;
                do {
                    if (lgfx_qrcode_getModule(&qrcode, x, y))
                        _qr_canvas.drawPixel(x, y);
                } while (++x < qrcode.size);
            } while (++y < qrcode.size);
            break;
        }

        int w = display.height();
        setTargetRect({(display.width() - w) >> 1, 0, w, w});
    }
    void hide(void) {
        setTargetRect({display.width() >> 1, display.height() >> 1, 0, 0});
    }
};

class overlay_ui_t : public ui_base_t {
    static constexpr const size_t lines_max = 6;
    std::string _text[lines_max];
    uint16_t _textwidth[lines_max];
    uint8_t _lines;
    uint8_t _countdown;

   public:
    void show(uint8_t count, const char* text0, const char* text1 = nullptr,
              const char* text2 = nullptr, const char* text3 = nullptr,
              const char* text4 = nullptr, const char* text5 = nullptr) {
        _countdown = count;
        _text[0]   = text0;
        _lines     = 1;
        if (text1) {
            _text[1] = text1;
            ++_lines;
            if (text2) {
                _text[2] = text2;
                ++_lines;
                if (text3) {
                    _text[3] = text3;
                    ++_lines;
                    if (text4) {
                        _text[4] = text4;
                        ++_lines;
                        if (text5) {
                            _text[5] = text5;
                            ++_lines;
                        }
                    }
                }
            }
        }
        int32_t w = 0;
        for (int32_t j = _lines - 1; j >= 0; --j) {
            int32_t tw    = display.textWidth(_text[j].c_str());
            _textwidth[j] = tw;
            if (w < tw) {
                w = tw;
            }
        }
        int32_t fh = display.fontHeight();
        w += fh;
        int32_t h = (_lines + 1) * fh;
        setTargetRect(
            {(display.width() - w) >> 1, (display.height() - h) >> 1, w, h});
    }

    void hide(void) {
        setTargetRect({display.width() >> 1, display.height() >> 1, 0, 0});
    }

    void update(draw_param_t* param) override {
        if (_countdown && (_countdown != 255)) {
            if (0 == --_countdown) {
                hide();
            }
        }
    }

    void draw(draw_param_t* param, M5Canvas* canvas, int32_t canvas_y,
              int32_t h) override {
        {
            auto canvas_w        = canvas->width();
            int32_t client_width = _client_rect.right() < canvas_w
                                       ? _client_rect.right()
                                       : canvas_w;
            int32_t client_x     = _client_rect.x < 0 ? 0 : _client_rect.x;
            client_width -= client_x;
            auto client_height = _client_rect.h;
            auto buf           = ((uint16_t*)canvas->getBuffer()) + client_x;

            int dy  = _client_rect.y - canvas_y;
            int dye = dy + client_height;
            if (dy < 0) dy = 0;
            if (dye > h) dye = h;

            uint32_t cw2 = (client_width + 1) >> 1;
            for (; dy < dye; ++dy) {
                auto b = (uint32_t*)(&buf[canvas_w * dy]);
                for (int x = 0; x < cw2; ++x) {
                    uint32_t tmp = b[x];
                    b[x] = (tmp >> 1) & 0x6F7B6F7B | ((tmp & 0x00010001) << 15);
                    // tmp = (tmp << 7 | tmp >> 9) & 0x7BEF;
                    // b[x] = tmp << 8 | tmp >> 8;
                }
            }
        }

        canvas->setTextSize(1);
        canvas->setTextColor(TFT_WHITE);
        canvas->setTextDatum(textdatum_t::top_left);
        auto fh = param->font_height;
        int32_t y =
            _client_rect.y - canvas_y + ((_client_rect.h - fh * _lines) >> 1);
        for (int j = 0; j < _lines; ++j, y += fh) {
            if (y > canvas->height() || 0 > y + fh) {
                continue;
            }
            if (0 == _textwidth[j]) {
                continue;
            }
            canvas->drawString(
                _text[j].c_str(),
                _client_rect.x + ((_client_rect.w - _textwidth[j]) >> 1), y);
        }
    }
};

qrcode_ui_t qrcode_ui;
overlay_ui_t overlay_ui;

void config_param_t::misc_backtofactory_func(uint8_t) {
    WiFi.mode(WIFI_MODE_STA);
    WiFi.disconnect(true, true);
    draw_param.loadDefault();
    draw_param.saveNvs();
    overlay_ui.show(64, "Reset Done.");
}

static rect_t _cursor_rect        = {0, 0, 240, 0};
static rect_t _cursor_target_rect = {0, 0, 240, 0};
class control_ui_t;
static control_ui_t* _cursor_target = nullptr;

class control_ui_t : public ui_base_t {
   protected:
    static control_ui_t* getCursorTarget(void) {
        return _cursor_target;
    }
    static void setCursorTarget(control_ui_t* target) {
        _cursor_target = target;
        if (target) {
            _cursor_target_rect = target->getDisplayTargetRect();
        }
    }

    rect_t getDisplayTargetRect(void) const {
        if (_parent) {
            auto r = _parent->getDisplayTargetRect();
            r.x += _target_rect.x;
            r.y += _target_rect.y;
            r.w = _target_rect.w;
            r.h = _target_rect.h;
            return r;
        }
        return {0, 0, _target_rect.w, _target_rect.h};
...

This file has been truncated, please download it to see its full contents.