ESP32-C3学习笔记：HTTP的POST连接

注意：HTTP post示例(仅适用于HTTP)

1.配置结构体：esp_http_client_config_t
eg：
    esp_http_client_config_t config = {
        .url = "http:xxxxxxxxx",
        .event_handler = _http_event_handler,        
        .user_data = local_response_buffer,
        .keep_alive_enable = true,
        .method = HTTP_METHOD_POST,
    }; 
    
    其中：
        .event_handler：                   为回调函数，参考下文示例_http_event_handler
        .user_data：                          返回的Response数据
        .method：                              连接方式 POST/GET
        .keep_alive_enable：            使能keep-alive    

2.初始化，设置http连接句柄client
eg:
    esp_http_client_handle_t client = esp_http_client_init(&config);     

3.设置传输数据body，一般为json格式的字符串
eg：
    const char * post_data = "{\"testID\":\"12345678\",\"sign\":\"xxxxxxxxxxxxx\"}" ;    

4.设置请求报头
eg:
    esp_http_client_set_header(client, "Content-Type", "application/json");

5.设置POST传输数据包
eg:    
    esp_http_client_set_post_field(client, post_data, strlen(post_data));

6.发起请求，等待回调结束
eg:
    esp_err_t err = esp_http_client_perform(client);
    if (err == ESP_OK) 
    {
        ESP_LOGI(TAG, "HTTP POST Status = %d, content_length = %d",
                    esp_http_client_get_status_code(client),         //获取状态码
                    esp_http_client_get_content_length(client));    //获取http响应内容长度
    } 
    else 
    {
        ESP_LOGE(TAG, "HTTP POST request failed: %s", esp_err_to_name(err));
        esp_http_client_cleanup(client);
        return EXIT_FAILURE;
    }

7.检查是否有respose返回
eg:
    if( esp_http_client_is_chunked_response(client) == true )
    {
        ESP_LOGI(TAG, "response: %s", local_response_buffer );
    }
    else
    {
        ESP_LOGE(TAG, "get response err!" );
        esp_http_client_cleanup(client);
        return EXIT_FAILURE;
    }

附录1：回调函数_http_event_handler

static esp_err_t _http_event_handler(esp_http_client_event_t *evt)
{
    static char *output_buffer;  // Buffer to store response of http request from event handler
    static int output_len;       // Stores number of bytes read
    switch(evt->event_id) {
        case HTTP_EVENT_ERROR:
            ESP_LOGI(TAG, "HTTP_EVENT_ERROR");
            break;
        case HTTP_EVENT_ON_CONNECTED:
            ESP_LOGI(TAG, "HTTP_EVENT_ON_CONNECTED");
            break;
        case HTTP_EVENT_HEADER_SENT:
            ESP_LOGI(TAG, "HTTP_EVENT_HEADER_SENT");
            break;
        case HTTP_EVENT_ON_HEADER:
            ESP_LOGI(TAG, "HTTP_EVENT_ON_HEADER, key=%s, value=%s", evt->header_key, evt->header_value);
            break;
        case HTTP_EVENT_ON_DATA:
            ESP_LOGI(TAG, "HTTP_EVENT_ON_DATA, len=%d", evt->data_len);
            /*
             *  Check for chunked encoding is added as the URL for chunked encoding used in this example returns binary data.
             *  However, event handler can also be used in case chunked encoding is used.
             */
            if (esp_http_client_is_chunked_response(evt->client)) 
            {
                // If user_data buffer is configured, copy the response into the buffer
                if (evt->user_data) {
                    memcpy(evt->user_data + output_len, evt->data, evt->data_len);
                } else {
                    if (output_buffer == NULL) {
                        output_buffer = (char *) malloc(esp_http_client_get_content_length(evt->client));
                        output_len = 0;
                        if (output_buffer == NULL) {
                            ESP_LOGE(TAG, "Failed to allocate memory for output buffer");
                            return ESP_FAIL;
                        }
                    }
                    memcpy(output_buffer + output_len, evt->data, evt->data_len);
                }
                output_len += evt->data_len;
            }
            break;
        case HTTP_EVENT_ON_FINISH:
            ESP_LOGI(TAG, "HTTP_EVENT_ON_FINISH");
            if (output_buffer != NULL) {
                // Response is accumulated in output_buffer. Uncomment the below line to print the accumulated response
                // ESP_LOG_BUFFER_HEX(TAG, output_buffer, output_len);
                free(output_buffer);
                output_buffer = NULL;
            }
            output_len = 0;
            break;
        case HTTP_EVENT_DISCONNECTED:
            ESP_LOGI(TAG, "HTTP_EVENT_DISCONNECTED");
            int mbedtls_err = 0;
            esp_err_t err = esp_tls_get_and_clear_last_error(evt->data, &mbedtls_err, NULL);
            if (err != 0) {
                ESP_LOGI(TAG, "Last esp error code: 0x%x", err);
                ESP_LOGI(TAG, "Last mbedtls failure: 0x%x", mbedtls_err);
            }
            if (output_buffer != NULL) {
                free(output_buffer);
                output_buffer = NULL;
            }
            output_len = 0;
            break;
    }
    return ESP_OK;
}

附录2：结构体参数

typedef struct {
    const char                  *url; //url请求接口必须配置              
    const char                  *host; //服务器域名或ip地址              
    int                         port; //端口 http默认80 https 默认443               
    const char                  *username;  //用户名，认证使用        
    const char                  *password;  //用户密码，认证使用         
    esp_http_client_auth_type_t auth_type; //认证方式          
    const char                  *path;  //路径             
    const char                  *query;  //请求参数            
    const char                  *cert_pem;    //证书       
    const char                  *client_cert_pem;    
    const char                  *client_key_pem;     
    esp_http_client_method_t    method;  //请求方式 post get                
    int                         timeout_ms;  //请求超时           
    bool                        disable_auto_redirect;   
    int                         max_redirection_count;    
    int                         max_authorization_retries;   
    http_event_handle_cb        event_handler;  //可注册回调           
    esp_http_client_transport_t transport_type;  // 传输方式 tcp ssl       
    int                         buffer_size; //接收缓存大小            
    int                         buffer_size_tx; //发送缓存大小       
    void                        *user_data;  //http用户数据            
    bool                        is_async;  //同步模式               
    bool                        use_global_ca_store;      
    bool                        skip_cert_common_name_check; //跳过证书  
    esp_err_t (*crt_bundle_attach)(void *conf);      
    bool                        keep_alive_enable;
    int                         keep_alive_idle;     
    int                         keep_alive_interval;
    int                         keep_alive_count;    
    struct ifreq                *if_name;        
} esp_http_client_config_t;