a549989332
- move runtime policy/diag contracts to domain-owned facade and remove control_plane leapfrog usage - enforce single declaration point for direct debug config in domain public API (constraint #6) - harden timeout/idempotent semantics in REST/voice/printer/wifi/ble paths
434 lines
16 KiB
C
434 lines
16 KiB
C
#include "domain.h"
|
|
#include "printer_protocol_internal.h"
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
static bool is_direct_backend(void) {
|
|
return printer_protocol_get_backend() == PRINTER_BACKEND_DIRECT;
|
|
}
|
|
|
|
static esp_err_t unsupported_for_direct(char *err, size_t err_len, const char *op) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "%s not supported on direct backend", op);
|
|
}
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
|
|
static void write_err(char *err, size_t err_len, const char *msg) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "%s", msg);
|
|
}
|
|
}
|
|
|
|
esp_err_t printer_protocol_gap_move(uint32_t timeout_ms, char *err, size_t err_len) {
|
|
if (is_direct_backend()) {
|
|
return platform_direct_printer_gap_move(timeout_ms, err, err_len);
|
|
}
|
|
|
|
if (!ble_printer_client_is_connected()) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "printer not connected");
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
if (!printer_protocol_acquire_control_lane(runtime_policy_printer_control_lock_timeout_ms(), err, err_len)) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
uint8_t payload = 0x01;
|
|
esp_err_t rc = printer_protocol_send_cmd_wait_response(CMD_GAP_MOVE,
|
|
&payload,
|
|
1,
|
|
true,
|
|
timeout_ms,
|
|
true,
|
|
true,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
err,
|
|
err_len);
|
|
printer_protocol_release_control_lane();
|
|
return rc;
|
|
}
|
|
|
|
esp_err_t printer_protocol_get_label_offset(uint8_t *out_offset, uint32_t timeout_ms, char *err, size_t err_len) {
|
|
if (is_direct_backend()) {
|
|
return unsupported_for_direct(err, err_len, "label offset");
|
|
}
|
|
|
|
if (out_offset == NULL) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "invalid args");
|
|
}
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
if (!ble_printer_client_is_connected()) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "printer not connected");
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
if (!printer_protocol_acquire_control_lane(runtime_policy_printer_control_lock_timeout_ms(), err, err_len)) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
uint8_t req = 0x01;
|
|
uint8_t rsp[16];
|
|
uint16_t rsp_len = 0;
|
|
esp_err_t rc = printer_protocol_send_cmd_wait_response(CMD_GET_OFFSET,
|
|
&req,
|
|
1,
|
|
true,
|
|
timeout_ms,
|
|
false,
|
|
false,
|
|
rsp,
|
|
sizeof(rsp),
|
|
&rsp_len,
|
|
err,
|
|
err_len);
|
|
printer_protocol_release_control_lane();
|
|
if (rc != ESP_OK) {
|
|
return rc;
|
|
}
|
|
if (rsp_len < 1) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "invalid offset response");
|
|
}
|
|
return ESP_FAIL;
|
|
}
|
|
if (rsp[0] == 0xFF) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "offset unavailable");
|
|
}
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
*out_offset = rsp[0];
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t printer_protocol_set_label_offset(uint8_t offset, uint32_t timeout_ms, char *err, size_t err_len) {
|
|
if (is_direct_backend()) {
|
|
return unsupported_for_direct(err, err_len, "label offset");
|
|
}
|
|
|
|
if (!ble_printer_client_is_connected()) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "printer not connected");
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
if (!printer_protocol_acquire_control_lane(runtime_policy_printer_control_lock_timeout_ms(), err, err_len)) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
esp_err_t rc = printer_protocol_send_cmd_wait_response(CMD_SET_OFFSET,
|
|
&offset,
|
|
1,
|
|
true,
|
|
timeout_ms,
|
|
true,
|
|
true,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
err,
|
|
err_len);
|
|
printer_protocol_release_control_lane();
|
|
return rc;
|
|
}
|
|
|
|
esp_err_t printer_protocol_ota_jump_boot(uint32_t timeout_ms, char *err, size_t err_len) {
|
|
if (is_direct_backend()) {
|
|
return unsupported_for_direct(err, err_len, "ota jump boot");
|
|
}
|
|
|
|
if (!ble_printer_client_is_connected()) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "printer not connected");
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
if (!printer_protocol_acquire_control_lane(runtime_policy_printer_control_lock_timeout_ms(), err, err_len)) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
esp_err_t rc = printer_protocol_send_cmd_wait_response(CMD_BOOT_JUMP_BOOT,
|
|
NULL,
|
|
0,
|
|
true,
|
|
timeout_ms,
|
|
true,
|
|
true,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
err,
|
|
err_len);
|
|
printer_protocol_release_control_lane();
|
|
return rc;
|
|
}
|
|
|
|
esp_err_t printer_protocol_ota_jump_app(uint32_t timeout_ms, char *err, size_t err_len) {
|
|
if (is_direct_backend()) {
|
|
return unsupported_for_direct(err, err_len, "ota jump app");
|
|
}
|
|
|
|
if (!ble_printer_client_is_connected()) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "printer not connected");
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
if (!printer_protocol_acquire_control_lane(runtime_policy_printer_control_lock_timeout_ms(), err, err_len)) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
esp_err_t rc = printer_protocol_send_cmd_wait_response(CMD_BOOT_JUMP_APP,
|
|
NULL,
|
|
0,
|
|
true,
|
|
timeout_ms,
|
|
true,
|
|
true,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
err,
|
|
err_len);
|
|
printer_protocol_release_control_lane();
|
|
return rc;
|
|
}
|
|
|
|
esp_err_t printer_protocol_ota_erase_page(uint16_t page_num, uint32_t timeout_ms, char *err, size_t err_len) {
|
|
if (is_direct_backend()) {
|
|
return unsupported_for_direct(err, err_len, "ota erase");
|
|
}
|
|
|
|
if (!ble_printer_client_is_connected()) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "printer not connected");
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
if (!printer_protocol_acquire_control_lane(runtime_policy_printer_control_lock_timeout_ms(), err, err_len)) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
uint8_t payload[2] = {
|
|
(uint8_t)((page_num >> 8) & 0xFF),
|
|
(uint8_t)(page_num & 0xFF),
|
|
};
|
|
|
|
esp_err_t rc = printer_protocol_send_cmd_wait_response(CMD_BOOT_ERASE_PAGE,
|
|
payload,
|
|
sizeof(payload),
|
|
true,
|
|
timeout_ms,
|
|
true,
|
|
true,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
err,
|
|
err_len);
|
|
printer_protocol_release_control_lane();
|
|
return rc;
|
|
}
|
|
|
|
esp_err_t printer_protocol_ota_write_frame(uint16_t packet_num,
|
|
bool is_last_frame,
|
|
const uint8_t *data,
|
|
size_t data_len,
|
|
uint32_t timeout_ms,
|
|
char *err,
|
|
size_t err_len) {
|
|
if (is_direct_backend()) {
|
|
return unsupported_for_direct(err, err_len, "ota write");
|
|
}
|
|
|
|
if ((data_len > 0 && data == NULL) || data_len > OTA_MAX_DATA_PER_FRAME) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "invalid frame length");
|
|
}
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
if (!ble_printer_client_is_connected()) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "printer not connected");
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
if (!printer_protocol_acquire_control_lane(runtime_policy_printer_control_lock_timeout_ms(), err, err_len)) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
uint8_t payload[3 + OTA_MAX_DATA_PER_FRAME];
|
|
payload[0] = (uint8_t)((packet_num >> 8) & 0xFF);
|
|
payload[1] = (uint8_t)(packet_num & 0xFF);
|
|
payload[2] = is_last_frame ? 0x01 : 0x00;
|
|
if (data_len > 0) {
|
|
memcpy(&payload[3], data, data_len);
|
|
}
|
|
|
|
esp_err_t rc = printer_protocol_send_cmd_wait_response(CMD_BOOT_WRITE_DATA,
|
|
payload,
|
|
(uint16_t)(3 + data_len),
|
|
true,
|
|
timeout_ms,
|
|
true,
|
|
true,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
err,
|
|
err_len);
|
|
printer_protocol_release_control_lane();
|
|
return rc;
|
|
}
|
|
|
|
esp_err_t printer_protocol_ota_get_version(printer_ota_version_t *out_version,
|
|
uint32_t timeout_ms,
|
|
char *err,
|
|
size_t err_len) {
|
|
if (is_direct_backend()) {
|
|
return unsupported_for_direct(err, err_len, "ota version");
|
|
}
|
|
|
|
if (out_version == NULL) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "invalid args");
|
|
}
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
if (!ble_printer_client_is_connected()) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "printer not connected");
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
if (!printer_protocol_acquire_control_lane(runtime_policy_printer_control_lock_timeout_ms(), err, err_len)) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
uint8_t rsp[16];
|
|
uint16_t rsp_len = 0;
|
|
esp_err_t rc = printer_protocol_send_cmd_wait_response(CMD_BOOT_GET_VERSION,
|
|
NULL,
|
|
0,
|
|
true,
|
|
timeout_ms,
|
|
false,
|
|
false,
|
|
rsp,
|
|
sizeof(rsp),
|
|
&rsp_len,
|
|
err,
|
|
err_len);
|
|
printer_protocol_release_control_lane();
|
|
if (rc != ESP_OK) {
|
|
return rc;
|
|
}
|
|
|
|
if (rsp_len < 3) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "invalid version response");
|
|
}
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
out_version->major = rsp[0];
|
|
out_version->minor = rsp[1];
|
|
out_version->patch = rsp[2];
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t printer_protocol_get_direct_debug_config(printer_direct_debug_config_t *out_config,
|
|
char *err,
|
|
size_t err_len) {
|
|
if (out_config == NULL) {
|
|
write_err(err, err_len, "invalid args");
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
if (!runtime_policy_direct_printer_enabled()) {
|
|
write_err(err, err_len, "direct backend disabled");
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
|
|
esp_err_t rc = platform_direct_printer_get_debug_config(&out_config->shift_clock_high_us,
|
|
&out_config->shift_clock_low_us,
|
|
&out_config->latch_pulse_us,
|
|
&out_config->strobe_active_high,
|
|
&out_config->boost_active_high,
|
|
&out_config->override_strobe_on_us,
|
|
&out_config->override_strobe_interval_us,
|
|
&out_config->override_motor_step_us,
|
|
&out_config->override_steps_per_line);
|
|
if (rc != ESP_OK) {
|
|
write_err(err, err_len, "get direct debug config failed");
|
|
return rc;
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t printer_protocol_set_direct_debug_config(const printer_direct_debug_config_t *config,
|
|
bool reset_defaults,
|
|
char *err,
|
|
size_t err_len) {
|
|
if (config == NULL && !reset_defaults) {
|
|
write_err(err, err_len, "invalid args");
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
if (!runtime_policy_direct_printer_enabled()) {
|
|
write_err(err, err_len, "direct backend disabled");
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
|
|
return platform_direct_printer_set_debug_config(config != NULL,
|
|
config != NULL ? config->shift_clock_high_us : 0,
|
|
config != NULL ? config->shift_clock_low_us : 0,
|
|
config != NULL ? config->latch_pulse_us : 0,
|
|
config != NULL ? config->strobe_active_high : false,
|
|
config != NULL ? config->boost_active_high : false,
|
|
config != NULL ? config->override_strobe_on_us : 0,
|
|
config != NULL ? config->override_strobe_interval_us : 0,
|
|
config != NULL ? config->override_motor_step_us : 0,
|
|
config != NULL ? config->override_steps_per_line : 0,
|
|
reset_defaults,
|
|
err,
|
|
err_len);
|
|
}
|
|
|
|
const char *printer_protocol_job_state_str(print_job_state_t state) {
|
|
switch (state) {
|
|
case PRINT_JOB_STATE_NONE:
|
|
return "none";
|
|
case PRINT_JOB_STATE_QUEUED:
|
|
return "queued";
|
|
case PRINT_JOB_STATE_RUNNING:
|
|
return "running";
|
|
case PRINT_JOB_STATE_SUCCESS:
|
|
return "success";
|
|
case PRINT_JOB_STATE_FAILED:
|
|
return "failed";
|
|
case PRINT_JOB_STATE_CANCELED:
|
|
return "canceled";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|