--- /dev/null
+import usocket
+import _thread
+import utime
+import log
+
+
+log.basicConfig(level=log.INFO)
+clog = log.getLogger("lnudp")
+UDP_PACKET_HEADER_SIZE = 16
+TCP_FRAME_HEADER_SIZE = 2
+
+# 函数调用跟踪:调试时 True;关闭可减少日志量
+LNUDP_TRACE_CALLS = True
+# 是否记录 UDP<->TCP 转发路径(数据多时较吵)
+LNUDP_TRACE_FORWARD = True
+
+
+def _fn(name, detail=None):
+ if not LNUDP_TRACE_CALLS:
+ return
+ if detail is not None:
+ clog.info("[lnudp] -> %s | %s", name, detail)
+ print("[lnudp] -> %s | %s" % (name, detail))
+ else:
+ clog.info("[lnudp] -> %s", name)
+ print("[lnudp] -> %s" % name)
+
+
+def _start_phase(step, msg):
+ """分步打点:死机时看最后一条即可定位卡在 socket / bind / listen / 起线程 哪一步"""
+ clog.info("[lnudp] start.%s %s", step, msg)
+
+
+class LnUdpTcpBridge:
+ """
+ UDP <-> TCP bridge for modem side:
+ - 构造时即创建 TCP 监听并启动 accept 线程;UDP 由 start_udp_service() 单独拉起
+ - start(host, port) / start_udp_service(host, port) 传入 UDP 对端(TCP 已在 __init__ 就绪)
+ - Local TCP server accepts one client
+ - UDP datagrams from remote are forwarded to TCP client
+ - TCP payloads from local client are forwarded to UDP remote
+ - udp_local_port=0: bind 时端口 0,由系统分配临时端口,start_udp_service 后 self.udp_local_port 为实际端口
+ - UDP 对端地址在 start_udp_service(udp_remote_host, udp_remote_port) 时传入,不在 __init__ 传
+ """
+
+ def __init__(
+ self,
+ udp_bind_host="0.0.0.0",
+ tcp_bind_host="172.16.1.2",
+ tcp_bind_port=5001,
+ udp_local_port=0,
+ tcp_backlog=10,
+ recv_buf_size=4096,
+ on_tcp_client_connected=None,
+ ):
+ _fn(
+ "__init__",
+ "udp_bind=%s:%s tcp_bind=%s:%s cb=%s"
+ % (
+ udp_bind_host,
+ udp_local_port,
+ tcp_bind_host,
+ tcp_bind_port,
+ "yes" if on_tcp_client_connected else "no",
+ ),
+ )
+ self.udp_remote_host = None
+ self.udp_remote_port = None
+ self.udp_bind_host = udp_bind_host
+ self.tcp_bind_host = tcp_bind_host
+ self.tcp_bind_port = tcp_bind_port
+ self.udp_local_port = udp_local_port
+ self.tcp_backlog = tcp_backlog
+ self.recv_buf_size = recv_buf_size
+
+ self._udp_sock = None
+ self._tcp_srv_sock = None
+ self._tcp_cli_sock = None
+
+ self._running = False
+ self._tcp_service_started = False
+ self._udp_service_started = False
+ self._lock = _thread.allocate_lock()
+ self._accept_thread_started = False
+ self._udp_thread_started = False
+ self._tcp_rx_thread_started = False
+
+ self._last_udp_peer = None
+ self._tcp_rx_cache = bytearray()
+ self._on_tcp_client_connected = on_tcp_client_connected
+
+ if self.start_tcp_service() != 0:
+ raise RuntimeError("LnUdpTcpBridge: TCP service init failed")
+
+ def set_udp_remote(self, host, port):
+ """Update UDP remote endpoint."""
+ _fn("set_udp_remote", "%s:%s" % (host, port))
+ if not host or int(port) <= 0:
+ raise ValueError("invalid udp remote endpoint")
+ self._lock.acquire()
+ try:
+ self.udp_remote_host = host
+ self.udp_remote_port = int(port)
+ finally:
+ self._lock.release()
+ clog.info("UDP remote set: %s:%s", host, port)
+
+ def start_tcp_service(self):
+ """创建 TCP 监听并启动 accept 线程;正常由 __init__ 调用,也可手动重试(已就绪则直接返回 0)。"""
+ _fn("start_tcp_service")
+ if self._tcp_service_started:
+ clog.info("TCP service already running")
+ return 0
+ try:
+ # 与 tcpserver.TcpServiceInit.__socket_file_init 一致:AF_INET + STREAM + IPPROTO_TCP_SER
+ _start_phase("t01", "tcp socket()")
+ self._tcp_srv_sock = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM, usocket.IPPROTO_TCP_SER)
+ _start_phase("t02", "tcp setsockopt REUSEADDR")
+ self._tcp_srv_sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
+ _start_phase("t03", "tcp bind %s:%s" % (self.tcp_bind_host, int(self.tcp_bind_port)))
+ self._tcp_srv_sock.bind((self.tcp_bind_host, int(self.tcp_bind_port)))
+ _start_phase("t04", "tcp listen backlog=%s" % int(self.tcp_backlog))
+ self._tcp_srv_sock.listen(int(self.tcp_backlog))
+ _start_phase("t05", "tcp settimeout")
+ # self._tcp_srv_sock.settimeout(1)
+ except Exception as e:
+ clog.error("TCP service init failed: %s", e)
+ self._safe_close_server()
+ self._tcp_service_started = False
+ return -1
+
+ self._running = True
+ self._tcp_service_started = True
+ self._accept_thread_started = True
+ _start_phase("t06", "start_new_thread _tcp_accept_loop")
+ _thread.start_new_thread(self._tcp_accept_loop, ())
+ clog.info(
+ "TCP service started, listen %s:%s",
+ self.tcp_bind_host,
+ self.tcp_bind_port,
+ )
+ return 0
+
+ def start_udp_service(self, udp_remote_host, udp_remote_port):
+ """在 TCP 已就绪后创建 UDP,并在此传入对端 UDP 地址/端口。"""
+ _fn(
+ "start_udp_service",
+ "remote=%s:%s" % (udp_remote_host, udp_remote_port),
+ )
+ if not udp_remote_host or int(udp_remote_port) <= 0:
+ clog.error("start_udp_service: invalid udp_remote_host/port")
+ return -1
+ if not self._tcp_service_started or self._tcp_srv_sock is None:
+ clog.error("start_udp_service: TCP not ready (constructor failed?)")
+ return -1
+ self.udp_remote_host = str(udp_remote_host).strip()
+ self.udp_remote_port = int(udp_remote_port)
+ if self._udp_service_started:
+ clog.info(
+ "start_udp_service: UDP already up, remote updated to %s:%s",
+ self.udp_remote_host,
+ self.udp_remote_port,
+ )
+ return 0
+ try:
+ _start_phase("u01", "udp socket()")
+ self._udp_sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM)
+ _start_phase("u02", "udp setsockopt REUSEADDR")
+ self._udp_sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
+ bind_udp_port = int(self.udp_local_port)
+ _start_phase(
+ "u03",
+ "udp bind %s:%s"
+ % (
+ self.udp_bind_host,
+ bind_udp_port if bind_udp_port != 0 else "0(ephemeral)",
+ ),
+ )
+ self._udp_sock.bind((self.udp_bind_host, bind_udp_port))
+ try:
+ _addr, self.udp_local_port = self._udp_sock.getsockname()
+ clog.info("UDP bound as %s:%s", _addr, self.udp_local_port)
+ except Exception as e:
+ clog.info("UDP getsockname skip: %s", e)
+ _start_phase("u04", "udp settimeout")
+ self._udp_sock.settimeout(1)
+ except Exception as e:
+ clog.error("UDP service init failed: %s", e)
+ self._safe_close_udp()
+ return -1
+
+ self._udp_service_started = True
+ self._udp_thread_started = True
+ _start_phase("u05", "start_new_thread _udp_rx_loop")
+ _thread.start_new_thread(self._udp_rx_loop, ())
+ clog.info("UDP service started, local port=%s", self.udp_local_port)
+ return 0
+
+ def start(self, udp_remote_host, udp_remote_port):
+ """仅启动 UDP 侧;与 start_udp_service(udp_remote_host, udp_remote_port) 相同。"""
+ _fn("start")
+ return self.start_udp_service(udp_remote_host, udp_remote_port)
+
+ def stop(self):
+ _fn("stop")
+ if not self._tcp_service_started and not self._udp_service_started:
+ return 0
+ self._running = False
+ self._tcp_service_started = False
+ self._udp_service_started = False
+ self._close_all_sockets()
+ self._accept_thread_started = False
+ self._udp_thread_started = False
+ self._tcp_rx_thread_started = False
+ clog.info("Bridge stopped")
+ return 0
+
+ def send_udp(self, data):
+ """Actively send bytes to current UDP remote endpoint."""
+ _fn("send_udp", "len=%s" % len(data) if data else "0")
+ if not data:
+ return -1
+ if self._udp_sock is None:
+ clog.info("send_udp: UDP service not started")
+ return -1
+ endpoint = self._get_udp_endpoint()
+ if endpoint is None:
+ clog.info("No UDP remote endpoint set")
+ return -1
+ try:
+ self._udp_sock.sendto(data, endpoint)
+ return 0
+ except Exception as e:
+ clog.error("send_udp failed: %s", e)
+ return -1
+
+ def _get_udp_endpoint(self):
+ self._lock.acquire()
+ try:
+ if self.udp_remote_host and self.udp_remote_port:
+ return (self.udp_remote_host, int(self.udp_remote_port))
+ if self._last_udp_peer:
+ return self._last_udp_peer
+ finally:
+ self._lock.release()
+ return None
+
+ def _close_all_sockets(self):
+ _fn("_close_all_sockets")
+ self._safe_close_client()
+ self._safe_close_server()
+ self._safe_close_udp()
+
+ def _safe_close_client(self):
+ _fn("_safe_close_client")
+ self._lock.acquire()
+ try:
+ sock = self._tcp_cli_sock
+ self._tcp_cli_sock = None
+ finally:
+ self._lock.release()
+ if sock:
+ try:
+ sock.close()
+ except Exception:
+ pass
+
+ def _safe_close_server(self):
+ _fn("_safe_close_server")
+ self._lock.acquire()
+ try:
+ sock = self._tcp_srv_sock
+ self._tcp_srv_sock = None
+ finally:
+ self._lock.release()
+ if sock:
+ try:
+ sock.close()
+ except Exception:
+ pass
+
+ def _safe_close_udp(self):
+ _fn("_safe_close_udp")
+ self._lock.acquire()
+ try:
+ sock = self._udp_sock
+ self._udp_sock = None
+ finally:
+ self._lock.release()
+ if sock:
+ try:
+ sock.close()
+ except Exception:
+ pass
+
+ def _tcp_accept_loop(self):
+ """与 tcpserver.__Socket_File_Thread 相同:accept 解包为 conn, ip, port;异常时 sleep 再继续。"""
+ _fn("_tcp_accept_loop", "thread enter")
+ clog.info(
+ "[lnudp] TCP accept loop listen %s:%s",
+ self.tcp_bind_host,
+ self.tcp_bind_port,
+ )
+ while self._running:
+ try:
+ cli_conn, cli_ip_addr, cli_port = self._tcp_srv_sock.accept()
+ clog.info(
+ "[lnudp] accept client: ip=%s port=%s",
+ cli_ip_addr,
+ cli_port,
+ )
+ self._replace_tcp_client(cli_conn)
+ utime.sleep_ms(100)
+ except:
+ # 与 tcpserver.__Socket_File_Thread 相同:accept 异常时等待再试
+ utime.sleep_ms(2000)
+ self._accept_thread_started = False
+
+ def _replace_tcp_client(self, new_cli_sock):
+ _fn("_replace_tcp_client", "new_sock")
+ old_sock = None
+ self._lock.acquire()
+ try:
+ old_sock = self._tcp_cli_sock
+ self._tcp_cli_sock = new_cli_sock
+ self._tcp_rx_cache = bytearray()
+ try:
+ self._tcp_cli_sock.settimeout(1)
+ except Exception:
+ pass
+ finally:
+ self._lock.release()
+ if old_sock:
+ try:
+ old_sock.close()
+ except Exception:
+ pass
+ # TCP accept 成功后必须跑 recv;此前未 start_new_thread,recv 从未执行
+ if not self._tcp_rx_thread_started:
+ self._tcp_rx_thread_started = True
+ _thread.start_new_thread(self._tcp_rx_loop, ())
+ clog.info("[lnudp] TCP recv thread started (first client connected)")
+ cb = self._on_tcp_client_connected
+ if cb:
+ try:
+ cb()
+ except Exception as e:
+ clog.error("on_tcp_client_connected: %s", e)
+
+ def _udp_rx_loop(self):
+ _fn("_udp_rx_loop", "thread enter")
+ while self._running:
+ try:
+ data, peer = self._udp_sock.recvfrom(self.recv_buf_size)
+ if not data:
+ continue
+ self._log_udp_packet_info(data, peer)
+ self._lock.acquire()
+ try:
+ self._last_udp_peer = peer
+ finally:
+ self._lock.release()
+ self._forward_udp_to_tcp(data)
+ except Exception:
+ utime.sleep_ms(20)
+ _fn("_udp_rx_loop", "thread exit")
+ self._udp_thread_started = False
+
+ def _log_udp_packet_info(self, data, peer):
+ # Keep packet layout aligned with ln_UDP.c:
+ # type(1) + flags(1) + payload_len(2) + ssrc(4) + timestamp(4) + sequence(4)
+ if len(data) < UDP_PACKET_HEADER_SIZE:
+ return
+ try:
+ pkt_type = data[0]
+ flags = data[1]
+ payload_len = (data[2] << 8) | data[3]
+ ssrc = (data[4] << 24) | (data[5] << 16) | (data[6] << 8) | data[7]
+ timestamp = (data[8] << 24) | (data[9] << 16) | (data[10] << 8) | data[11]
+ sequence = (data[12] << 24) | (data[13] << 16) | (data[14] << 8) | data[15]
+ clog.info(
+ "UDP recv %s type=%s flags=%s payload_len=%s ssrc=%s ts=%s seq=%s total=%s",
+ peer,
+ pkt_type,
+ flags,
+ payload_len,
+ ssrc,
+ timestamp,
+ sequence,
+ len(data),
+ )
+ except Exception:
+ pass
+
+ def _tcp_rx_loop(self):
+ _fn("_tcp_rx_loop", "thread enter")
+ while self._running:
+ cli = None
+ self._lock.acquire()
+ try:
+ cli = self._tcp_cli_sock
+ finally:
+ self._lock.release()
+
+ if not cli:
+ utime.sleep_ms(100)
+ continue
+
+ try:
+ chunk = cli.recv(self.recv_buf_size)
+ if LNUDP_TRACE_FORWARD:
+ clog.info("[lnudp] TCP recv chunk len=%s", len(chunk) if chunk else 0)
+ if not chunk:
+ self._safe_close_client()
+ continue
+ self._tcp_rx_cache.extend(chunk)
+ self._forward_tcp_frames_to_udp()
+ except Exception as e:
+ # clog.info("[lnudp] TCP recv error: %s", e)
+ utime.sleep_ms(20)
+ _fn("_tcp_rx_loop", "thread exit")
+ self._tcp_rx_thread_started = False
+
+ def _forward_udp_to_tcp(self, data):
+ if LNUDP_TRACE_FORWARD:
+ _fn("_forward_udp_to_tcp", "len=%s" % len(data))
+ cli = None
+ self._lock.acquire()
+ try:
+ cli = self._tcp_cli_sock
+ finally:
+ self._lock.release()
+ if not cli:
+ return
+ try:
+ frame_len = len(data)
+ hdr = bytes([(frame_len >> 8) & 0xFF, frame_len & 0xFF])
+ self._send_tcp_all(cli, hdr + data)
+ except Exception as e:
+ clog.info("UDP->TCP forward failed: %s", e)
+ self._safe_close_client()
+
+ def _send_tcp_all(self, cli, data):
+ if LNUDP_TRACE_FORWARD:
+ _fn("_send_tcp_all", "len=%s" % len(data))
+ sent = 0
+ total = len(data)
+ while sent < total:
+ n = cli.send(data[sent:])
+ if n is None or n <= 0:
+ raise Exception("tcp send failed")
+ sent += n
+
+ def _forward_tcp_frames_to_udp(self):
+ if LNUDP_TRACE_FORWARD:
+ _fn("_forward_tcp_frames_to_udp", "cache_len=%s" % len(self._tcp_rx_cache))
+ if self._udp_sock is None:
+ return
+ endpoint = self._get_udp_endpoint()
+ if endpoint is None:
+ return
+ while len(self._tcp_rx_cache) >= TCP_FRAME_HEADER_SIZE:
+ frame_len = (self._tcp_rx_cache[0] << 8) | self._tcp_rx_cache[1]
+ if frame_len <= 0 or frame_len > self.recv_buf_size:
+ self._tcp_rx_cache = bytearray()
+ return
+ need = TCP_FRAME_HEADER_SIZE + frame_len
+ if len(self._tcp_rx_cache) < need:
+ return
+ payload = bytes(self._tcp_rx_cache[TCP_FRAME_HEADER_SIZE:need])
+ # MicroPython/Quectel 上 bytearray 不支持 del buf[:need],用切片重建
+ self._tcp_rx_cache = bytearray(self._tcp_rx_cache[need:])
+ try:
+ if LNUDP_TRACE_FORWARD:
+ clog.info("[lnudp] TCP->UDP payload len=%s", len(payload))
+ self._udp_sock.sendto(payload, endpoint)
+ except Exception as e:
+ clog.info("TCP->UDP forward failed: %s", e)
+ return
+
+# ///////////////////////////////////////////////////////////////
+# def create_ln_udp_bridge(
+# udp_remote_host="115.190.94.208",
+# udp_remote_port=50000,
+# tcp_bind_host="127.0.0.1",
+# tcp_bind_port=5600,
+# udp_local_port=0,
+# ):
+# b = LnUdpTcpBridge(
+# tcp_bind_host=tcp_bind_host,
+# tcp_bind_port=tcp_bind_port,
+# udp_local_port=udp_local_port,
+# )
+# b.start_udp_service(udp_remote_host, udp_remote_port)
+# return b
${ROOT_DIR}/zhihui/4g/cat1Service/include
${ROOT_DIR}/zhihui/4g/cat1Service/Service
${ROOT_DIR}/zhihui/4gTest
+ ${ROOT_DIR}/zhihui/ChangAan
${ROOT_DIR}/zhihui/leiniao/imsl_ln/
${ROOT_DIR}/zhihui/leiniao/imsl_ln/LN_MQTT/
)
#ifdef SUPPORT_AT_PPP
#include "ppp_at_cmd.h"
#endif
+#ifdef SUPPORT_AT_UARTTEST
+#include "uarttest_at_cmd.h"
+#endif
+
+#ifdef SUPPORT_AT_CHANGAN
+#include "changan_api_at.h"
+#endif
+
+#ifdef SUPPORT_AT_CT_AI
+#include "ct_ai_at_cmd.h"
+#endif
+
#include "log_file.h"
#ifdef CONFIG_OTA_UPDATE_SUPPORT
#include "upg.h"
at_cmd_add_moudle(ln_mqtt_at_table, ln_mqtt_at_cmd_count);
#endif
+#ifdef SUPPORT_AT_UARTTEST
+ /* UART/SLIP 测试 AT 命令:AT^UARTTEST / AT^TCPSPEED */
+ (void)uarttest_at_init();
+#endif
+ /* ChangAn AT 测试:AT^CHANGAN_TEST / AT^CHANGAN_HTTP_GET 等 */
+#endif
+
+#ifdef SUPPORT_AT_CHANGAN
+ /* ChangAn AT 测试:AT^CHANGAN_TEST / AT^CHANGAN_HTTP_GET 等 */
+ uint32_t changan_cmd_count;
+ at_cmd_table_t *changan_table = get_changan_at_table(&changan_cmd_count);
+ at_cmd_add_moudle(changan_table, changan_cmd_count);
+#endif
+
+#ifdef SUPPORT_AT_CT_AI
+ /* CT_AI AT 测试:AT^CTAI_* */
+ uint32_t ct_ai_cmd_count;
+ at_cmd_table_t *ct_ai_table = get_ct_ai_at_table(&ct_ai_cmd_count);
+ at_cmd_add_moudle(ct_ai_table, ct_ai_cmd_count);
#endif
#ifdef SUPPORT_ZHIHUI_AI_SERVICE
* 在此之前,先设置成默认0
*/
// thelanguage = 0;
- NativeAbility::GetInstance().SetDefaultSliceId(VIEW_LANGUAGE_SWITCH);
+ NativeAbility::GetInstance().SetDefaultSliceId(VIEW_PERSONAL_CENTER);
}
else
{
VIEW_MAIN_ALIPAY, // 支付宝
#endif
VIEW_HEART_CHART, // 心率曲线图检测
+ VIEW_PERSONAL_CENTER, // 个人中心(蓝牙/车控等)
VIEW_ADD_NEW_ID = 250,
/* -------------------------------------------------------------------------- */
VIEW_RECENT_APP,
* 在此之前,先设置成默认0
*/
// thelanguage = 0;
- NativeAbility::GetInstance().SetDefaultSliceId(VIEW_LANGUAGE_SWITCH);
+ NativeAbility::GetInstance().SetDefaultSliceId(VIEW_PERSONAL_CENTER);
}
else
{
OHOS::language::GetInstance()->ChangeLanguage(id);
if (LanguageSwitchView::GetInstance())
{
- NativeAbility::GetInstance().ChangeSlice(VIEW_LANGUAGE_SWITCH);
+ NativeAbility::GetInstance().ChangeSlice(VIEW_PERSONAL_CENTER);
}
}
return;
set_hint_code(id);
set_hint_flag(true);
#ifdef CUSTOM_ZHIHUI
- NativeAbility::GetInstance().EnterSlice(VIEW_LANGUAGE_SWITCH);
+ NativeAbility::GetInstance().EnterSlice(VIEW_PERSONAL_CENTER);
#endif
}
}
OHOS::language::GetInstance()->ChangeLanguage(id);
if (LanguageSwitchView::GetInstance())
{
- NativeAbility::GetInstance().ChangeSlice(VIEW_LANGUAGE_SWITCH);
+ NativeAbility::GetInstance().ChangeSlice(VIEW_PERSONAL_CENTER);
}
}
return;
--- /dev/null
+# 个人中心 Slice(VIEW_PERSONAL_CENTER)实现说明
+
+本文档描述 `nativeui/personal_center` 目录下各文件职责、主要符号及 Slice 内数据流,便于维护与排查。**入口注册**:`PersonalCenterPresenter.cpp` 中的 `REGIST_MENU_PRO(VIEW_PERSONAL_CENTER, ...)`。
+
+---
+
+## 1. 整体架构
+
+| 层次 | 职责 |
+|------|------|
+| **PersonalCenterPresenter** | 点击、拖拽侧滑、电源键;调用 `PersonalCenterView` 的 `Go*` 换页;`g_pPersonalCenterPresenter` + `GetInstance(void)` 供子 View 绑定监听(与 `phone`/DialingMethod 单例套路一致)。 |
+| **PersonalCenterView** | 纵向 **`group_` 下叠放** `pages_[]`(`SetVisible` 切换,**无纵向 UISwipeView**);`g_pPersonalCenterView` + `GetInstance(void)`;`PersonalCenterViewInit`→`BuildPageStack`;Hub 内横向滑动仍在 `PersonalCenterCarHubView::hSwipe_`。 |
+| **AppGroupView 子类** | 仅布局与控件创建:`InitView(void *caller)` 中 `caller` 为 `PersonalCenterView*`,通过 `GetUi*Listener()` 挂接 Presenter。 |
+
+纵向页顺序(`PersonalCenterPageIndex`):
+
+`DISCLAIMER(0) → LOGIN(1) → SELECT_CAR(2) → CAR_HUB(3) → ABOUT(4) → KEY_MODE(5)`。
+
+车联 **Hub**(`PC_PAGE_CAR_HUB`)内为**横向**四页:`蓝牙钥匙 | 车况 | 远程控车 | 个人中心菜单`,见 `PersonalCenterCarHubView`。
+
+```mermaid
+flowchart TB
+ subgraph vertical [纵向:UIViewGroup 叠页 + 显隐切换]
+ D[Disclaimer]
+ L[Login]
+ S[SelectCar]
+ H[CarHub 横向四页]
+ A[About]
+ K[KeyMode]
+ end
+ D --> L --> S --> H --> A
+ H --> K
+ subgraph hub [PersonalCenterCarHubView]
+ T0[蓝牙 CarControlView]
+ T1[车况 CarDashboardView]
+ T2[远程 RemoteControlView]
+ T3[菜单 HubMainTabView]
+ end
+ H --- hub
+```
+
+---
+
+## 2. 冗余与相似代码(梳理结论)
+
+| 项目 | 结论 |
+|------|------|
+| **PersonalCenterMainView** | 已与 **PersonalCenterHubMainTabView** 完全重复,且不再被 `CreatePage` 引用;**已删除** `.cpp/.h`。 |
+| **HubMainTabView 内 `CreateMenuButton`** | 仅此文件内局部静态函数,无第二份拷贝。 |
+| **CarControlView vs RemoteControlView** | 均为车控方形按键,但键数量(6 vs 4)、滚动、资源与布局不同;**不宜强行合并**,可接受的小范围重复(`MakeCarCtrlButton` / `MakeBtn`)。 |
+| **车况页** | UI 与资源宏集中在 `PersonalCenterCarDashboardView.*`(`BuildStatusDashboard`);与秒表 `CarStatusDashboardView` 布局对齐、代码独立。车控六键数据表见 `PersonalCenterCarUiConstants.h` + `PersonalCenterCarControlResources.cpp`。 |
+
+---
+
+## 3. 文件清单与函数说明
+
+### 3.1 `include/PersonalCenterUiConfig.h`
+
+| 内容 | 说明 |
+|------|------|
+| `PC_SCREEN_W/H`、`PC_BG_COLOR`、`PC_BTN_*`、`PC_TITLE_TOP` 等宏 | 多页共用的尺寸、字号、颜色;**无函数**。 |
+
+---
+
+### 3.1b `include/PersonalCenterUiScroll.h`
+
+| 内容 | 说明 |
+|------|------|
+| `PcApplyVerticalScrollBehavior(sv, maxDist, scrollBlank)` | 选车 / Hub 菜单 / 蓝牙车控 / 钥匙页共用的 `UIScrollView` 惯性参数(inline)。声明页滚动参数不同,仍在本文件内单独写。 |
+
+---
+
+### 3.2 `include/PersonalCenterPresenter.h` / `src/PersonalCenterPresenter.cpp`
+
+| 符号 | 说明 |
+|------|------|
+| `REGIST_MENU_PRO(...)` | 注册 `VIEW_PERSONAL_CENTER` Slice 与菜单元数据。 |
+| `GetInstance()` | 当前 Slice 存活期间的 Presenter 单例指针(用于 listener 绑定)。 |
+| `ResetSwipeExitSuppression()` | 清除 `suppressNextMainMenuSwipeExit_` 与 `dragFlag_` / `dragRtlFlag_`;各 `Go*` 换页时由 View 调用。 |
+| `OnStart` / `OnPause` / `OnResume` / `OnStop` | 生命周期;`OnResume` 内 `ApplyPendingMainMenuIfAny` + 设置 `RootView` 按键监听。 |
+| `OnKeyAct` | 亮屏状态下电源键释放 → `NativeAbility::Back()`。 |
+| `OnClick` | 处理全部 `ViewId`(声明/登录/选车/Hub 菜单/关于等);Hub 内先按横向 tab 分发给 `TryHandleCarButtonClick`(蓝牙六键 / 远程四键)。 |
+| `OnDrag` / `OnDragEnd` | 非 Hub 页记录横滑方向并触发返回应用列表、`GoMainPage`、秒表 `Back` 等;**Hub 页 OnDrag 清空累计标记并返回 false**;`OnDragEnd` 对非竖向主导的 LTR/RTL **不执行**侧滑跳转,减轻列表竖滑误进其它纵向页。 |
+
+**私有状态**:`dragFlag_`、`dragRtlFlag_`、`suppressNextMainMenuSwipeExit_`(含义见头文件注释)。
+
+---
+
+### 3.3 `include/PersonalCenterView.h` / `src/PersonalCenterView.cpp`
+
+| 符号 | 说明 |
+|------|------|
+| `PersonalCenterPageIndex` | 纵向页枚举。 |
+| `GetInstance()` | 当前 View 单例(供其它 Slice 如秒表调用 `RequestShowMainMenuOnNextActivate`)。 |
+| `RequestShowMainMenuOnNextActivate` / `ApplyPendingMainMenuIfAny` | 秒表侧滑进个人中心时延迟到 `OnResume` 再 `GoCarHubPage(..., 3)`。 |
+| `GetUiClickListener` / `GetUiDragListener` | 将 `presenter_` 转为 UI 监听接口。 |
+| `GetCarHubPage` | 返回 `pages_[CAR_HUB]` 强转为 `PersonalCenterCarHubView*`。 |
+| `GoLoginPage` / `GoSelectCarPage` / `GoLoginFlowPage` | 纵向切页 ± `ResetSwipeExitSuppression`。 |
+| `GoCarHubPage(tab)` | 进入 Hub 并 `SetHorizontalIndex`。 |
+| `GoMainPage` | 等价 `GoCarHubPage(..., 3)`(个人中心菜单 tab)。 |
+| `GoAboutPage` / `GoKeyModePage` / `GoDisclaimerPage` | 纵向切页;钥匙页额外 `RefreshToggles`。 |
+| `GoCarControlPage` / `GoCarDashboardPage` | 兼容入口,等价 Hub tab 0 / 1。 |
+| `GetSwipeIndex` | 当前纵向页索引 `currentPageIndex_`(与 `PersonalCenterPageIndex` 一致)。 |
+| `OnStart` | 创建 `group_`、`BuildPageStack`、`ApplyPendingMainMenuIfAny`。 |
+| `ClearAll` | 析构时逐页 `Remove` 再 `RemoveAndDeleteAllRecursively`,避免纵向 swipe 整树误删顺序问题。 |
+| `BuildPageStack` | 各页 `InitView(this)` 后加入 `group_`,`SetVerticalPage` 只亮一页。 |
+| `CreatePage` / `Page*Init` | 各纵向页工厂。 |
+
+---
+
+### 3.4 `include/PersonalCenterCarHubView.h` / `src/PersonalCenterCarHubView.cpp`
+
+| 符号 | 说明 |
+|------|------|
+| `InitView` | 创建横向 `hSwipe_`,依次添加蓝牙/车况/远程/菜单四 tab;`BuildDotBar`;为蓝牙与菜单的 `UIScrollView` 设置 **本 Hub** 为 `OnDragListener`(四点显隐,且 `OnDrag` 返回 false)。 |
+| `GetHorizontalIndex` / `SetHorizontalIndex` | 横向当前页;同步底部四点。 |
+| `GetBluetoothTab` / `GetRemoteTab` | 供 Presenter 分发车控点击。 |
+| `OnSwipe` | 横滑结束刷新四点。 |
+| `OnDrag` / `OnDragEnd` | 竖滑时 `OnDrag` 隐藏四点;**竖滑结束不再显示四点**,仅 **`OnSwipe`(横向换 tab)与 `SetHorizontalIndex`** 会 `ShowDotBar(true)`。 |
+| `BuildDotBar` / `UpdateDots` / `ShowDotBar` | 底部指示器 UI。 |
+
+---
+
+### 3.5 `include/PersonalCenterHubMainTabView.h` / `src/PersonalCenterHubMainTabView.cpp`
+
+| 符号 | 说明 |
+|------|------|
+| `InitView` | 「个人中心」标题 + 菜单按钮(`PcMyAccount` 等)+ 缓存 `50MB` 文案 + `UIScrollView`;点击监听为 `GetUiClickListener()`;**不在此**给 scroll 设 `OnDragListener`(由 Hub 统一设,便于四点逻辑)。 |
+| `GetMenuScroll` | 暴露 `scroll_` 给 Hub 注册拖动监听。 |
+
+**匿名** `CreateMenuButton`:创建统一样式 `UILabelButton`。
+
+---
+
+### 3.6 `include/PersonalCenterCarControlView.h` / `src/PersonalCenterCarControlView.cpp`
+
+| 符号 | 说明 |
+|------|------|
+| `InitView` | 根上 `SetOnDragListener(GetUiDragListener())`;`BuildUi`。 |
+| `BuildUi` | `UIScrollView` 内标题「蓝牙钥匙」、状态、`UIImageView`、**6** 个 `CAR_CTRL_BTN_VIEWID` 按钮。 |
+| `GetContentScroll` | 供 Hub 绑定竖滑与四点。 |
+| `MakeCarCtrlButton` | 创建扩展按钮并设 `OnClickListener`。 |
+| `TryHandleCarButtonClick` / `ToggleButtonState` / `GetButton` | 车控按键状态与点击吞掉判定。 |
+
+车控状态数据来自 **`PersonalCenterCarUiConstants.h`** 中 **`g_carCtrlBtnStates` / `CAR_CTRL_BTN_VIEWID`**(与秒表车控共用同一张表)。
+
+---
+
+### 3.7 `include/PersonalCenterCarDashboardView.h` / `src/PersonalCenterCarDashboardView.cpp`
+
+| 符号 | 说明 |
+|------|------|
+| `InitView` | 页壳:`SetOnDragListener`、主题色;`BuildStatusDashboard` 创建 `statusRoot_` 子树(标题「车况信息」等);`Add(statusRoot_)`。 |
+| `BuildStatusDashboard` | 车况 UILabel/UIImage 布局;`PC_CAR_STATUS_*` 资源宏在本头文件。 |
+| `AbandonStatusWidgetPointers` | 析构前断开裸指针,避免 swipe 整树先删子节点后二次访问。 |
+
+---
+
+### 3.8 `include/PersonalCenterRemoteControlView.h` / `src/PersonalCenterRemoteControlView.cpp`
+
+| 符号 | 说明 |
+|------|------|
+| `InitView` | 无内层 Scroll;标题「远程控车」、连接区、**4** 个按钮(`g_carCtrlBtnStates[0..3]`)。 |
+| `MakeBtn` | 与蓝牙页类似的单键创建。 |
+| `TryHandleCarButtonClick` | 仅处理前 4 个 `VIEWID`。 |
+
+---
+
+### 3.9 `include/PersonalCenterDisclaimerView.h` / `src/PersonalCenterDisclaimerView.cpp`
+
+| 符号 | 说明 |
+|------|------|
+| `InitView` | 上区纵向滚动声明正文;底部双按钮 **`PcdCancel`**(退应用列表)、**`PcdConfirm`**(进登录)。 |
+
+---
+
+### 3.10 `include/PersonalCenterLoginView.h` / `src/PersonalCenterLoginView.cpp`
+
+| 符号 | 说明 |
+|------|------|
+| `InitView` | 扫码区域占位文案;**`PcGoSelectCar`** 进选车页。 |
+
+---
+
+### 3.11 `include/PersonalCenterSelectCarView.h` / `src/PersonalCenterSelectCarView.cpp`
+
+| 符号 | 说明 |
+|------|------|
+| `InitView` | `UIScrollView` 内列表;**`PcPickCar`** → Presenter 中 `GoCarControlPage`(Hub 蓝牙 tab)。 |
+
+---
+
+### 3.12 `include/PersonalCenterAboutView.h` / `src/PersonalCenterAboutView.cpp`
+
+| 符号 | 说明 |
+|------|------|
+| `InitView` | 静态展示版本号、热线等;根 `SetOnDragListener` 便于侧滑回 Hub(由 Presenter 处理)。 |
+
+---
+
+### 3.13 `include/PersonalCenterKeyModeView.h` / `src/PersonalCenterKeyModeView.cpp`
+
+| 符号 | 说明 |
+|------|------|
+| `InitView` | 纵向滚动;两路 **`UIToggleButton`** + 进程内静态 `g_peUnlock` / `g_welcomeLock` 及 `OnChangeListener`。 |
+| `RefreshToggles` | 进入页时与静态状态同步 UI。 |
+| `GetPassiveEntryUnlock` / `GetWelcomeLockUnlock` | 静态读当前开关(供业务层扩展)。 |
+
+---
+
+## 4. 常用 ViewId 与 Presenter 行为(OnClick)
+
+| ViewId | 行为概要 |
+|--------|-----------|
+| `PcdCancel` | `ExitPersonalCenterToAppList` |
+| `PcdConfirm` | `GoLoginPage` |
+| `PcPickCar` | `GoCarControlPage`(Hub tab0) |
+| `PcMyVehicle` | `GoLoginFlowPage(false, false)`(选车) |
+| `PcGoSelectCar` | `GoSelectCarPage` |
+| `PcKeySettings` | `GoKeyModePage` |
+| `PcAbout` | `GoAboutPage` |
+| `PcMyAccount` / `PcClearCache` / `PcLogout` | 当前仅日志 stub |
+| Hub 内车控 `CAR_CTRL_BTN_VIEWID[*]` | 由 `TryHandleCarButtonClick` 吞噬 |
+
+---
+
+## 5. 外部协作
+
+- **秒表车控**(`MainStopWatchPresenter` 等):可 `PersonalCenterView::RequestShowMainMenuOnNextActivate()` 后 `EnterSlice(VIEW_PERSONAL_CENTER)`,在用户可见时落到 Hub 第 4 页。
+- **侧滑**:`GetPreSliceId() == VIEW_MAIN_STOPWATCH` 时,部分「退应用列表」逻辑会被跳过或改为 `Back`,详见 `PersonalCenterPresenter::OnDragEnd`。
+
+---
+
+## 6. 维护建议
+
+- 新增纵向页:扩展 `PersonalCenterPageIndex`、`CreatePage`、新增 `AppGroupView` 子类,并在 Presenter 中补全 `ViewId` 或侧滑分支。
+- 新增 Hub 横向 tab:改 `PersonalCenterCarHubView::InitView`、四点数量/布局,并更新 Presenter 内 Hub 相关分发。
+- 若需**消除**蓝牙/远程按钮构建的重复,可抽小工具函数到 `personal_center` 内新 `.cpp`(避免拉上秒表循环依赖),属可选重构。
+
+文档Revision:与源码目录一致;若 Slice 行为变更,请同步更新本节与 `PersonalCenterPresenter.cpp` 顶部块注释。
--- /dev/null
+/*
+ * @file PersonalCenterAboutView.h
+ * @brief 关于我们(p2)
+ */
+#ifndef PERSONAL_CENTER_ABOUT_VIEW_H
+#define PERSONAL_CENTER_ABOUT_VIEW_H
+
+#include "AppGroupView.h"
+
+namespace OHOS
+{
+
+class PersonalCenterAboutView : public AppGroupView
+{
+public:
+ PersonalCenterAboutView();
+ ~PersonalCenterAboutView() override;
+
+ bool InitView(void *caller) override;
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterCarControlView.h
+ * @brief 个人中心 — 蓝牙钥匙车控页(六键,纵向可滚动)
+ */
+#ifndef PERSONAL_CENTER_CAR_CONTROL_VIEW_H
+#define PERSONAL_CENTER_CAR_CONTROL_VIEW_H
+
+#include "AppGroupView.h"
+#include "components/ui_scroll_view.h"
+#include "components/ui_label.h"
+#include "components/ui_image_view.h"
+#include "components/ui_label_button_ext.h"
+#include "components/ui_view.h"
+
+namespace OHOS
+{
+
+class PersonalCenterView;
+
+class PersonalCenterCarControlView : public AppGroupView
+{
+public:
+ PersonalCenterCarControlView();
+
+ bool InitView(void *caller) override;
+
+ UILabelButtonExt *GetButton(int index);
+ void ToggleButtonState(int index);
+ /** @return true if viewId is one of the six car control buttons */
+ bool TryHandleCarButtonClick(const char *viewId);
+
+ UIScrollView *GetContentScroll() const { return scrollView_; }
+
+private:
+ void BuildUi(PersonalCenterView *pcView);
+ UILabelButtonExt *MakeCarCtrlButton(int x, int y, int index, UIView::OnClickListener *clickListener);
+
+private:
+ UIScrollView *scrollView_{nullptr};
+ UILabel *titleLabel_{nullptr};
+ UILabel *statusLabel_{nullptr};
+ UIImageView *btIconView_{nullptr};
+ UILabelButtonExt *btnButton_[6]{nullptr};
+ bool btnState_[6]{false};
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterCarDashboardView.h
+ * @brief 个人中心 — 车况总览页(Hub 横向一页,内含车况 UIView 树)
+ */
+#ifndef PERSONAL_CENTER_CAR_DASHBOARD_VIEW_H
+#define PERSONAL_CENTER_CAR_DASHBOARD_VIEW_H
+
+#include "AppGroupView.h"
+#include "components/ui_image_view.h"
+#include "components/ui_label.h"
+#include "components/ui_view.h"
+#include "components/ui_view_group.h"
+
+namespace OHOS
+{
+
+#define PC_CAR_STATUS_REFRESH_IMG "/user/res/car_control/status_refresh.bin"
+#define PC_CAR_STATUS_CAR_HERO_IMG "/user/res/car_control/car_hero_uni_v.bin"
+#define PC_CAR_STATUS_BATTERY_IMG "/user/res/car_control/status_battery.bin"
+#define PC_CAR_STATUS_FUEL_IMG "/user/res/car_control/status_fuel.bin"
+
+#define PC_CAR_STATUS_BG_COLOR 0xff000000
+#define PC_CAR_STATUS_TITLE_FONT 35
+#define PC_CAR_STATUS_SUBTITLE_FONT 27
+#define PC_CAR_STATUS_RANGE_FONT 51
+#define PC_CAR_STATUS_UNIT_FONT 27
+#define PC_CAR_STATUS_PCT_FONT 24
+#define PC_CAR_STATUS_CIRCLE_D 70
+#define PC_CAR_STATUS_REFRESH_SZ 34
+#define PC_CAR_STATUS_CAR_W 426
+#define PC_CAR_STATUS_CAR_H 166
+
+class PersonalCenterCarDashboardView : public AppGroupView
+{
+public:
+ PersonalCenterCarDashboardView();
+ ~PersonalCenterCarDashboardView() override;
+
+ bool InitView(void *caller) override;
+
+ /** 用车况模型字段刷新副标题等(不强制读云端,可在 Pull 后调用) */
+ void ApplyVehicleLabelsFromModel();
+
+private:
+ /** UISwipe 整树先拆时避免对子指针二次释放;与原先独立 Status 类 AbandonUiOwnership 语义一致 */
+ void AbandonStatusWidgetPointers();
+ bool BuildStatusDashboard(UIView::OnDragListener *dragListener, UIView::OnClickListener *clickListener,
+ const char *titleText);
+
+ UIViewGroup *statusRoot_{nullptr};
+ UILabel *titleLabel_{nullptr};
+ UILabel *modelLabel_{nullptr};
+ UILabel *parkLabel_{nullptr};
+ UIImageView *refreshImg_{nullptr};
+ UIImageView *carImg_{nullptr};
+ UILabel *rangeLeftNum_{nullptr};
+ UILabel *rangeLeftUnit_{nullptr};
+ UILabel *rangeRightNum_{nullptr};
+ UILabel *rangeRightUnit_{nullptr};
+ UIImageView *batteryCircle_{nullptr};
+ UILabel *batteryPct_{nullptr};
+ UIImageView *fuelCircle_{nullptr};
+ UILabel *fuelPct_{nullptr};
+ UIView *dots_[4]{nullptr};
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterCarHubView.h
+ * @brief 横向四页:蓝牙钥匙 | 车况 | 远程控车 | 个人中心;底部四点指示器
+ */
+#ifndef PERSONAL_CENTER_CAR_HUB_VIEW_H
+#define PERSONAL_CENTER_CAR_HUB_VIEW_H
+
+#include "AppGroupView.h"
+#include "components/ui_swipe_view.h"
+#include "drag_event.h"
+#include "gfx_utils/graphic_math.h"
+
+namespace OHOS
+{
+
+class PersonalCenterView;
+class PersonalCenterCarControlView;
+class PersonalCenterCarDashboardView;
+class PersonalCenterRemoteControlView;
+class PersonalCenterHubMainTabView;
+class UIScrollView;
+
+class PersonalCenterCarHubView : public AppGroupView,
+ public UISwipeView::OnSwipeListener,
+ public UIView::OnDragListener
+{
+public:
+ PersonalCenterCarHubView();
+ ~PersonalCenterCarHubView() override;
+
+ bool InitView(void *caller) override;
+
+ uint16_t GetHorizontalIndex() const;
+ void SetHorizontalIndex(uint16_t index, bool needAnimator);
+
+ PersonalCenterCarControlView *GetBluetoothTab() { return tabBluetooth_; }
+
+ PersonalCenterCarDashboardView *GetDashboardTab() { return tabDash_; }
+
+ PersonalCenterRemoteControlView *GetRemoteTab() { return tabRemote_; }
+
+ void OnSwipe(UISwipeView &view) override;
+ bool OnDrag(UIView &view, const DragEvent &event) override;
+ bool OnDragEnd(UIView &view, const DragEvent &event) override;
+
+private:
+ void BuildDotBar();
+ void UpdateDots(uint16_t activeIdx);
+ void ShowDotBar(bool show);
+
+ UISwipeView *hSwipe_{nullptr};
+ UIViewGroup *dotBar_{nullptr};
+ UIView *dots_[4]{nullptr};
+
+ PersonalCenterCarControlView *tabBluetooth_{nullptr};
+ PersonalCenterCarDashboardView *tabDash_{nullptr};
+ PersonalCenterRemoteControlView *tabRemote_{nullptr};
+ PersonalCenterHubMainTabView *tabMain_{nullptr};
+ UIScrollView *mainMenuScroll_{nullptr};
+ UIScrollView *bluetoothScroll_{nullptr};
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterCarUiConstants.h
+ * @brief 车控/远程/Hub 共用资源常量(与蓝牙钥匙 Slice 布局一致;数据表在 MainStopWatchView.cpp 定义)
+ */
+#ifndef PERSONAL_CENTER_CAR_UI_CONSTANTS_H
+#define PERSONAL_CENTER_CAR_UI_CONSTANTS_H
+
+namespace OHOS
+{
+
+/* 蓝牙车控界面 - 图片路径(与 MainStopWatchView 一致) */
+#define CAR_CTRL_BG_COLOR 0xff000000
+#define CAR_CTRL_BTN_BG_COLOR 0xff191919
+#define CAR_CTRL_BTN_SIZE 146
+#define CAR_CTRL_ICON_SIZE 94
+#define CAR_CTRL_TEXT_W 53
+#define CAR_CTRL_TEXT_H 27
+
+#define CAR_CTRL_GAP_CLOSE_IMG "/user/res/car_control/gap_close.bin"
+#define CAR_CTRL_GAP_OPEN_IMG "/user/res/car_control/gap_open.bin"
+#define CAR_CTRL_LOCK_CLOSE_IMG "/user/res/car_control/lock_close.bin"
+#define CAR_CTRL_LOCK_OPEN_IMG "/user/res/car_control/lock_open.bin"
+#define CAR_CTRL_AC_CLOSE_IMG "/user/res/car_control/ac_close.bin"
+#define CAR_CTRL_AC_OPEN_IMG "/user/res/car_control/ac_open.bin"
+#define CAR_CTRL_FIND_STOP_IMG "/user/res/car_control/find_car_stop.bin"
+#define CAR_CTRL_FIND_START_IMG "/user/res/car_control/find_car_start.bin"
+#define CAR_CTRL_REMOTE_CLOSE_IMG "/user/res/car_control/remote_close.bin"
+#define CAR_CTRL_REMOTE_START_IMG "/user/res/car_control/remote_start.bin"
+#define CAR_CTRL_SUNROOF_CLOSE_IMG "/user/res/car_control/sunroof_close.bin"
+#define CAR_CTRL_SUNROOF_OPEN_IMG "/user/res/car_control/sunroof_open.bin"
+#define CAR_CTRL_BT_ICON_IMG "/user/res/car_control/bluetooth_icon.bin"
+
+static const char *CAR_CTRL_BTN_VIEWID[] = {
+ "CarCtrlGap", "CarCtrlLock", "CarCtrlAC",
+ "CarCtrlFind", "CarCtrlRemote", "CarCtrlSunroof"
+};
+
+struct CarCtrlButtonState {
+ const char *textOff;
+ const char *textOn;
+ const char *imgOff;
+ const char *imgOn;
+};
+
+/** 定义在 PersonalCenterCarControlResources.cpp;蓝牙钥匙 Slice 与个人中心共用 */
+extern const CarCtrlButtonState g_carCtrlBtnStates[6];
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterDisclaimerView.h
+ * @brief 声明页(AppGroupView 子页,由 UISwipeView 承载)
+ */
+#ifndef PERSONAL_CENTER_DISCLAIMER_VIEW_H
+#define PERSONAL_CENTER_DISCLAIMER_VIEW_H
+
+#include "AppGroupView.h"
+
+namespace OHOS
+{
+
+class PersonalCenterDisclaimerView : public AppGroupView
+{
+public:
+ PersonalCenterDisclaimerView();
+ ~PersonalCenterDisclaimerView() override;
+
+ bool InitView(void *caller) override;
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterHubMainTabView.h
+ * @brief 车联 Hub 第 4 页:个人中心菜单(账户/车辆/钥匙/缓存/关于/退出等),纵向 UIScrollView 供 Hub 挂载四点显隐监听
+ */
+#ifndef PERSONAL_CENTER_HUB_MAIN_TAB_VIEW_H
+#define PERSONAL_CENTER_HUB_MAIN_TAB_VIEW_H
+
+#include "AppGroupView.h"
+
+namespace OHOS
+{
+
+class UIScrollView;
+
+class PersonalCenterHubMainTabView : public AppGroupView
+{
+public:
+ PersonalCenterHubMainTabView();
+ ~PersonalCenterHubMainTabView() override;
+
+ bool InitView(void *caller) override;
+
+ UIScrollView *GetMenuScroll() const { return scroll_; }
+
+private:
+ UIScrollView *scroll_{nullptr};
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterKeyModeView.h
+ * @brief 钥匙模式子页(开关为进程内静态状态,无独立 Model)
+ */
+#ifndef PERSONAL_CENTER_KEY_MODE_VIEW_H
+#define PERSONAL_CENTER_KEY_MODE_VIEW_H
+
+#include "AppGroupView.h"
+
+namespace OHOS
+{
+
+class UIToggleButton;
+
+class PersonalCenterKeyModeView : public AppGroupView
+{
+public:
+ PersonalCenterKeyModeView();
+ ~PersonalCenterKeyModeView() override;
+
+ bool InitView(void *caller) override;
+
+ void RefreshToggles();
+
+ static bool GetPassiveEntryUnlock();
+ static bool GetWelcomeLockUnlock();
+
+private:
+ UIToggleButton *togglePe_{nullptr};
+ UIToggleButton *toggleWelcome_{nullptr};
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterLoginView.h
+ * @brief 个人中心 — 登录页(扫码说明 + 进入选车)
+ */
+#ifndef PERSONAL_CENTER_LOGIN_VIEW_H
+#define PERSONAL_CENTER_LOGIN_VIEW_H
+
+#include "AppGroupView.h"
+#include "cmsis_os2.h"
+#include <atomic>
+
+namespace OHOS
+{
+
+class UIImageView;
+
+class PersonalCenterLoginView : public AppGroupView
+{
+public:
+ PersonalCenterLoginView();
+ ~PersonalCenterLoginView() override;
+
+ bool InitView(void *caller) override;
+
+ /** 由 PersonalCenterView 在纵向切到登录页时调用,触发拉码(勿在 InitView 里调用) */
+ void OnLoginPageBecameVisible();
+ /** 离开登录页时重置,下次进入可再次拉码 */
+ void OnLoginPageBecameHidden();
+
+ /** @return 0 成功;-1 失败 */
+ int LoadChanganQrSync();
+ /**
+ * 查询扫码状态(须先 LoadChanganQrSync 成功且已保存 qrcode_id)
+ * @return 1 已授权(authorized);0 未授权或 pending;-1 错误(无 id、HTTP 非 200 等)
+ */
+ int CheckQrCodeScan();
+
+private:
+ static void LoginQrMonitorTimerCallback(void *arg);
+ void StartLoginQrMonitorTimer();
+ void StopLoginQrMonitorTimer();
+
+ UIImageView *qrImage_{ nullptr };
+ /** 本轮进入登录页后是否已成功拉码并刷图 */
+ bool qrCodeSuccess_{ false };
+ /** Generate 返回的 qrcode_id,供 getQrcodeStatusNoBackend */
+ char last_qrcode_id_[128]{ 0 };
+ /** 登录页可见且定时器应继续 tick(离开后回调里应早退) */
+ std::atomic<bool> login_monitor_active_{ false };
+
+ /** 周期拉码 / 查询扫码状态(osTimerPeriodic),与 ThunderBird 同类用法 */
+ osTimerId_t login_qr_monitor_timer_{ nullptr };
+
+ void PostRefreshQrImageOnUiThread();
+ void OnQrScanAuthorizedUi();
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterModel.h
+ * @brief 个人中心业务数据:首次引导 Config、选车列表、账户信息、车况摘要、蓝牙车控点击桩、AT 调试入口。
+ */
+#ifndef PERSONAL_CENTER_MODEL_H
+#define PERSONAL_CENTER_MODEL_H
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace OHOS
+{
+
+class PersonalCenterModel
+{
+public:
+ static PersonalCenterModel *GetInstance();
+
+ void LoadPersistedState();
+ void SavePersistedState();
+
+ /** Config:是否已完成「声明 + 登录流程」;未完成则冷启动从声明页开始 */
+ bool IsOnboardingCompleted() const;
+ void MarkOnboardingCompleted();
+ /** 调试:AT+PCONBOARD 写入配置项 */
+ void ForceOnboardingFlagForTest(bool completed);
+
+ /** 退出登录:清理会话桩数据(不撤销首次引导标志) */
+ void LogoutClearSession();
+
+ /* ----- 选车 ----- */
+ const std::vector<std::string> &GetCarOptions() const { return carOptions_; }
+ void ClearCarOptions();
+ void AddCarOption(const std::string &displayName);
+ void SetCarOptionsForTest(const std::vector<std::string> &names);
+ void SetSelectedCarIndex(size_t index);
+ size_t GetSelectedCarIndex() const { return selectedCarIndex_; }
+
+ /* ----- 车况展示(桩数据,可由后续云端刷新替换) ----- */
+ void RefreshVehicleStatusSnapshot();
+ std::string GetVehicleModelLine() const { return vehicleModelLine_; }
+ std::string GetParkStatusText() const { return parkStatusText_; }
+ std::string GetRangeEvKmText() const { return rangeEvKm_; }
+ std::string GetRangeFuelKmText() const { return rangeFuelKm_; }
+ std::string GetBatteryPercentText() const { return batteryPct_; }
+ std::string GetFuelPercentText() const { return fuelPct_; }
+
+ void SetVehicleModelLineForTest(const std::string &line);
+
+ /* ----- 账户(桩 + AT 注入) ----- */
+ std::string GetAccountDisplayName() const { return accountDisplayName_; }
+ std::string GetAccountPhone() const { return accountPhone_; }
+ void SetAccountProfile(const std::string &name, const std::string &phone);
+
+ /* ----- 蓝牙钥匙页:车锁/闭锁等按键(index 同 CAR_CTRL_BTN_VIEWID) ----- */
+ void OnCarControlButtonClicked(int buttonIndex, bool isOn);
+
+ /** 蓝牙钥匙界面「闭锁」类操作(index 0 车窗/间隙、1 车锁 —— 与车机协议对接前为桩) */
+ void OnBluetoothCarGapAction(bool isOn);
+ void OnBluetoothCarLockAction(bool isOn);
+
+ /**
+ * AT 测试串口(示例):
+ * AT+PCCAR=uni-v 追加选车项
+ * AT+PCUSER=昵称,186xxxx 设置账户展示名与手机号
+ * AT+PCMODEL=长安UNI-V 设置车况页车款文案并刷新快照
+ * AT+PCONBOARD=0 清除「已完成引导」标志(下次进个人中心从声明开始)
+ * AT+PCONBOARD=1 标记已完成引导(下次直进关于页)
+ */
+ static void ProcessAtCommandLine(const char *line);
+
+private:
+ PersonalCenterModel();
+ ~PersonalCenterModel() = default;
+ PersonalCenterModel(const PersonalCenterModel &) = delete;
+ PersonalCenterModel &operator=(const PersonalCenterModel &) = delete;
+
+ void EnsureDefaultCarListUnlocked();
+
+ bool configLoaded_{false};
+ bool onboardingCompleted_{false};
+
+ std::vector<std::string> carOptions_;
+ size_t selectedCarIndex_{0};
+
+ std::string vehicleModelLine_;
+ std::string parkStatusText_;
+ std::string rangeEvKm_;
+ std::string rangeFuelKm_;
+ std::string batteryPct_;
+ std::string fuelPct_;
+
+ std::string accountDisplayName_;
+ std::string accountPhone_;
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterModelC.h
+ * @brief C 侧可调用的个人中心调试入口(如串口/工厂 AT 转发)
+ */
+#ifndef PERSONAL_CENTER_MODELC_H
+#define PERSONAL_CENTER_MODELC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** 处理一行 AT 文本,语义见 PersonalCenterModel::ProcessAtCommandLine */
+void uapi_personal_center_at_cmd(const char *line);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterMyAccountView.h
+ * @brief 个人中心 — 我的账户(用户名 / 手机号展示)
+ */
+#ifndef PERSONAL_CENTER_MY_ACCOUNT_VIEW_H
+#define PERSONAL_CENTER_MY_ACCOUNT_VIEW_H
+
+#include "AppGroupView.h"
+#include "components/ui_label.h"
+
+namespace OHOS
+{
+
+class PersonalCenterMyAccountView : public AppGroupView
+{
+public:
+ PersonalCenterMyAccountView();
+ ~PersonalCenterMyAccountView() override;
+
+ bool InitView(void *caller) override;
+ void RefreshFromModel();
+
+private:
+ UILabel *lblUserLine_{nullptr};
+ UILabel *lblPhoneLine_{nullptr};
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterPresenter.h
+ * @brief 个人中心 Slice:导航/点击/滑动业务逻辑;View 与 AppGroupView 子类仅负责布局与显示。
+ *
+ * 与 phone 模块 Presenter 一致:构造注册 `GetInstance()` 单例,析构置空;子 View 的 OnClick/OnDrag 指向此实例。
+ *
+ * Slice 结构概览(纵向为 group 叠页 + 显隐,仅代码/点击切页):
+ * 0 声明 → 1 登录 → 2 选车 → 3 车联 Hub → 4 关于 → 5 钥匙模式 → 6 我的账户
+ * 车联 Hub 内为横向四页:蓝牙钥匙 | 车况信息 | 远程控车 | 个人中心菜单(底部四点指示)。
+ */
+#ifndef PERSONAL_CENTER_PRESENTER_H
+#define PERSONAL_CENTER_PRESENTER_H
+
+namespace OHOS {
+class PersonalCenterView;
+}
+
+#include "Presenter.h"
+#include "components/root_view.h"
+#include "components/ui_view.h"
+
+namespace OHOS
+{
+
+class PersonalCenterPresenter : public Presenter<PersonalCenterView>,
+ public UIView::OnClickListener,
+ public UIView::OnDragListener,
+ public RootView::OnKeyActListener
+{
+public:
+ PersonalCenterPresenter();
+ ~PersonalCenterPresenter() override;
+
+ /** Slice 存活期间唯一 Presenter,供 UI 绑定监听(对齐 DialingMethod 等模块用法) */
+ static PersonalCenterPresenter *GetInstance(void);
+
+ void OnStart() override;
+ void OnPause() override;
+ void OnResume() override;
+ void OnStop() override;
+
+ /** 纵向换页时清除:侧滑抑制标记 + 横向拖拽累计标记(避免竖滑后误触退出/跳转) */
+ void ResetSwipeExitSuppression();
+
+private:
+ bool OnClick(UIView &view, const ClickEvent &event) override;
+ bool OnDrag(UIView &view, const DragEvent &event) override;
+ bool OnDragEnd(UIView &view, const DragEvent &event) override;
+ bool OnKeyAct(UIView &view, const KeyEvent &event) override;
+
+ /** OnDrag 中识别的「横向以左→右为主」分量,供 OnDragEnd 与系统 DragDirection 交叉判断 */
+ bool dragFlag_{false};
+ /** 以右→左为主的横向分量 */
+ bool dragRtlFlag_{false};
+ /** 为真时下一次 RTL 结束可优先走业务跳转(如车况 tab),而非 Back;由 ResetSwipeExitSuppression 与各 Go* 清除 */
+ bool suppressNextMainMenuSwipeExit_{false};
+ static constexpr int kDragOffset = 50;
+ static constexpr double kDragRatio = 2.0;
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterRemoteControlView.h
+ * @brief 远程控车:2×2 四键,无纵向滚动(窗缝/关锁/空调/寻车,对应 g_carCtrlBtnStates[0..3])
+ */
+#ifndef PERSONAL_CENTER_REMOTE_CONTROL_VIEW_H
+#define PERSONAL_CENTER_REMOTE_CONTROL_VIEW_H
+
+#include "AppGroupView.h"
+#include "components/ui_label.h"
+#include "components/ui_image_view.h"
+#include "components/ui_label_button_ext.h"
+#include "components/ui_view.h"
+
+namespace OHOS
+{
+
+class PersonalCenterView;
+
+class PersonalCenterRemoteControlView : public AppGroupView
+{
+public:
+ PersonalCenterRemoteControlView();
+
+ bool InitView(void *caller) override;
+
+ bool TryHandleCarButtonClick(const char *viewId);
+
+private:
+ UILabelButtonExt *MakeBtn(int x, int y, int index, UIView::OnClickListener *clickListener);
+ UILabel *titleLabel_{nullptr};
+ UILabel *statusLabel_{nullptr};
+ UIImageView *refreshIcon_{nullptr};
+ UILabelButtonExt *btn_[4]{nullptr};
+ bool btnState_[4]{false};
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterSelectCarView.h
+ * @brief 个人中心 — 选车页(车款列表由 PersonalCenterModel 提供)
+ */
+#ifndef PERSONAL_CENTER_SELECT_CAR_VIEW_H
+#define PERSONAL_CENTER_SELECT_CAR_VIEW_H
+
+#include "AppGroupView.h"
+#include "components/ui_label_button.h"
+#include "components/ui_scroll_view.h"
+#include <vector>
+
+namespace OHOS
+{
+
+class PersonalCenterView;
+
+class PersonalCenterSelectCarView : public AppGroupView
+{
+public:
+ PersonalCenterSelectCarView();
+ ~PersonalCenterSelectCarView() override;
+
+ bool InitView(void *caller) override;
+ void RebuildCarList(PersonalCenterView *pc);
+
+private:
+ UIScrollView *scroll_{nullptr};
+ UIViewGroup *carListHost_{nullptr};
+ UIViewGroup *spacer_{nullptr};
+ std::vector<UILabelButton *> carButtons_;
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterUiConfig.h
+ * @brief 个人中心相关界面共用尺寸与颜色(非 Slice,供多个 View 源文件包含)
+ */
+#ifndef PERSONAL_CENTER_UI_CONFIG_H
+#define PERSONAL_CENTER_UI_CONFIG_H
+
+/** 个人中心布局按固定圆屏分辨率(与产品约定一致) */
+#define PC_SCREEN_W 466
+#define PC_SCREEN_H 466
+
+#define PC_BG_COLOR 0xff000000
+#define PC_BTN_BG_COLOR 0xff191919
+#define PC_TITLE_FONT 35
+#define PC_BTN_FONT 35
+#define PC_SUB_FONT 24
+#define PC_DISC_BODY_FONT 26
+#define PC_BTN_W 430
+#define PC_BTN_H 144
+#define PC_BTN_GAP 9
+#define PC_TITLE_TOP 24
+#define PC_DISC_BOTTOM_BLUE 0xff2563eb
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterUiScroll.h
+ * @brief 个人中心内多处共用的纵向 UIScrollView 惯性参数(固定 466 屏宽无关)
+ */
+#ifndef PERSONAL_CENTER_UI_SCROLL_H
+#define PERSONAL_CENTER_UI_SCROLL_H
+
+#include "components/ui_scroll_view.h"
+
+namespace OHOS
+{
+
+/** 选车 / Hub 菜单 / 钥匙页等:统一回弹与加速度;KeyMode 传入 scrollBlank=80 */
+inline void PcApplyVerticalScrollBehavior(UIScrollView *sv, int maxScrollDistance, int scrollBlank = 75)
+{
+ if (sv == nullptr) {
+ return;
+ }
+ sv->SetReboundSize(50);
+ sv->SetHorizontalScrollState(false);
+ sv->SetScrollBlankSize(scrollBlank);
+ sv->SetThrowDrag(true);
+ sv->SetMaxScrollDistance(maxScrollDistance);
+ sv->SetSwipeACCLevel(200);
+ sv->SetDragACCLevel(5);
+ sv->SetRotateFactor(2);
+}
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+/*
+ * @file PersonalCenterView.h
+ * @brief 个人中心:声明 → 登录 → 选车 → 车联 Hub → 关于 / 钥匙设置。
+ *
+ * 与 phone 模块 View 一致:构造注册进程内单例 `GetInstance()`,析构 `ClearAll()` 后清空单例指针;
+ * 根 UI 在 `PersonalCenterViewInit()` 中创建(由 `OnStart` 调用)。业务侧滑/点击在 PersonalCenterPresenter。
+ */
+#ifndef PERSONAL_CENTER_VIEW_H
+#define PERSONAL_CENTER_VIEW_H
+
+#include "personal_center/include/PersonalCenterPresenter.h"
+#include "View.h"
+#include "AppGroupView.h"
+#include "components/ui_view_group.h"
+#include "personal_center/include/PersonalCenterDisclaimerView.h"
+#include "personal_center/include/PersonalCenterAboutView.h"
+#include "personal_center/include/PersonalCenterKeyModeView.h"
+
+namespace OHOS
+{
+
+typedef enum {
+ PC_PAGE_DISCLAIMER = 0,
+ PC_PAGE_LOGIN,
+ PC_PAGE_SELECT_CAR,
+ PC_PAGE_CAR_HUB, /* 蓝牙钥匙 | 车况 | 远程 | 个人中心(横向) */
+ PC_PAGE_ABOUT,
+ PC_PAGE_KEY_MODE,
+ PC_PAGE_MY_ACCOUNT,
+ PC_MAX_PAGE,
+} PersonalCenterPageIndex;
+
+class PersonalCenterCarHubView;
+
+class PersonalCenterView : public View<PersonalCenterPresenter>
+{
+public:
+ PersonalCenterView();
+ ~PersonalCenterView() override;
+
+ /** Slice 存活期间指向当前 PersonalCenterView,与 DialingMethodView::GetInstance 用法一致 */
+ static PersonalCenterView *GetInstance(void);
+
+ static void RequestShowMainMenuOnNextActivate();
+ void ApplyPendingMainMenuIfAny();
+
+ void OnStart() override;
+
+ UIView::OnClickListener *GetUiClickListener();
+ UIView::OnDragListener *GetUiDragListener();
+
+ PersonalCenterCarHubView *GetCarHubPage();
+
+ void GoLoginPage(bool needAnimator = true);
+ void GoSelectCarPage(bool needAnimator = true);
+ void GoLoginFlowPage(bool needAnimator = true, bool startAtLogin = true);
+ /** 车联 Hub:tab 0 蓝牙钥匙,1 车况,2 远程,3 个人中心 */
+ void GoCarHubPage(bool needAnimator = true, uint16_t tab = 0);
+ void GoMainPage(bool needAnimator = true);
+ void GoAboutPage(bool needAnimator = true);
+ void GoKeyModePage(bool needAnimator = true);
+ void GoMyAccountPage(bool needAnimator = true);
+ void GoDisclaimerPage(bool needAnimator = true);
+ void GoCarControlPage(bool needAnimator = true);
+ void GoCarDashboardPage(bool needAnimator = true);
+ uint16_t GetSwipeIndex() const;
+
+ /** AT/车型变更后刷新选车列表 */
+ void RefreshSelectCarListUi();
+ /** AT/车况变更后刷新 Hub 车况 tab 文案 */
+ void RefreshVehicleDashboardUi();
+ /** AT 修改账户后刷新「我的账户」页 */
+ void RefreshMyAccountUi();
+
+private:
+ /** 释放 group_ 与各纵向页;析构与重复进入前兜底 */
+ void ClearAll(void);
+ /** 创建根容器并在其下叠加全部子页(仅点击换页,无纵向 UISwipeView) */
+ void PersonalCenterViewInit(void);
+ /** 在 group_ 上创建各全屏页,仅当前页 SetVisible(true) */
+ bool BuildPageStack(void);
+ /** 切换纵向页;needAnimator 保留接口,当前无动画 */
+ void SetVerticalPage(uint16_t index, bool needAnimator);
+ AppGroupView *CreatePage(uint8_t pageId);
+
+ AppGroupView *PageDisclaimerInit();
+ AppGroupView *PageLoginInit();
+ AppGroupView *PageSelectCarInit();
+ AppGroupView *PageCarHubInit();
+ AppGroupView *PageAboutInit();
+ AppGroupView *PageKeyModeInit();
+ AppGroupView *PageMyAccountInit();
+
+ UIViewGroup *group_{nullptr};
+ AppGroupView *pages_[PC_MAX_PAGE]{nullptr};
+ uint16_t currentPageIndex_{0};
+
+ static bool showMainMenuPending_;
+};
+
+} // namespace OHOS
+
+#endif
--- /dev/null
+#include "personal_center/include/PersonalCenterAboutView.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "personal_center/include/PersonalCenterUiConfig.h"
+#include "components/ui_label.h"
+#include "components/ui_view_group.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+
+namespace OHOS
+{
+
+namespace
+{
+constexpr uint32_t PC_ABOUT_ACCENT = 0xff5cb8ff;
+constexpr char PC_APP_VER[] = "v1.0.0";
+constexpr char PC_HOTLINE[] = "951999";
+}
+
+PersonalCenterAboutView::PersonalCenterAboutView()
+{
+ SetViewIndex(static_cast<uint16_t>(PC_PAGE_ABOUT));
+ SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+}
+
+PersonalCenterAboutView::~PersonalCenterAboutView() = default;
+
+bool PersonalCenterAboutView::InitView(void *caller)
+{
+ auto *pc = static_cast<PersonalCenterView *>(caller);
+ if (pc == nullptr) {
+ return false;
+ }
+ (void)pc;
+
+ SetStyle(STYLE_BACKGROUND_COLOR, PC_BG_COLOR);
+ SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ SetTouchable(true);
+ SetDraggable(true);
+ SetOnDragListener(pc->GetUiDragListener());
+
+ int y = 48;
+
+ auto *title = new UILabel();
+ if (title != nullptr) {
+ title->SetPosition(0, y, 466, 48);
+ title->SetText("关于我们");
+ title->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ title->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 36);
+ title->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ Add(title);
+ }
+ y += 100;
+
+ auto *name = new UILabel();
+ if (name != nullptr) {
+ name->SetPosition(0, y, 466, 44);
+ name->SetText("腕有引力");
+ name->SetStyle(STYLE_TEXT_COLOR, PC_ABOUT_ACCENT);
+ name->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 32);
+ name->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ Add(name);
+ }
+ y += 52;
+
+ auto *ver = new UILabel();
+ if (ver != nullptr) {
+ ver->SetPosition(0, y, 466, 36);
+ ver->SetText(PC_APP_VER);
+ ver->SetStyle(STYLE_TEXT_COLOR, 0xffaaaaaa);
+ ver->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 26);
+ ver->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ Add(ver);
+ }
+ y += 120;
+
+ auto *hotlineLbl = new UILabel();
+ if (hotlineLbl != nullptr) {
+ hotlineLbl->SetPosition(0, y, 466, 40);
+ hotlineLbl->SetText("服务热线");
+ hotlineLbl->SetStyle(STYLE_TEXT_COLOR, PC_ABOUT_ACCENT);
+ hotlineLbl->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 28);
+ hotlineLbl->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ Add(hotlineLbl);
+ }
+ y += 48;
+
+ auto *phone = new UILabel();
+ if (phone != nullptr) {
+ phone->SetPosition(0, y, 466, 40);
+ phone->SetText(PC_HOTLINE);
+ phone->SetStyle(STYLE_TEXT_COLOR, 0xffdddddd);
+ phone->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 28);
+ phone->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ Add(phone);
+ }
+
+ initViewStatus = true;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterAboutView::InitView ok");
+ return true;
+}
+
+} // namespace OHOS
--- /dev/null
+#include "personal_center/include/PersonalCenterCarUiConstants.h"
+
+namespace OHOS
+{
+
+const CarCtrlButtonState g_carCtrlBtnStates[] = {
+ {"关缝", "开缝", CAR_CTRL_GAP_CLOSE_IMG, CAR_CTRL_GAP_OPEN_IMG},
+ {"关锁", "开锁", CAR_CTRL_LOCK_CLOSE_IMG, CAR_CTRL_LOCK_OPEN_IMG},
+ {"关空调", "开空调", CAR_CTRL_AC_CLOSE_IMG, CAR_CTRL_AC_OPEN_IMG},
+ {"停止寻车", "开始寻车", CAR_CTRL_FIND_STOP_IMG, CAR_CTRL_FIND_START_IMG},
+ {"远程关闭", "远程启动", CAR_CTRL_REMOTE_CLOSE_IMG, CAR_CTRL_REMOTE_START_IMG},
+ {"关天窗", "开天窗", CAR_CTRL_SUNROOF_CLOSE_IMG, CAR_CTRL_SUNROOF_OPEN_IMG},
+};
+
+} // namespace OHOS
--- /dev/null
+#include "personal_center/include/PersonalCenterCarControlView.h"
+#include "personal_center/include/PersonalCenterCarUiConstants.h"
+#include "personal_center/include/PersonalCenterModel.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "personal_center/include/PersonalCenterUiConfig.h"
+#include "personal_center/include/PersonalCenterUiScroll.h"
+#include "UiConfig.h"
+#include "common/image_cache_manager.h"
+#include "wearable_log.h"
+#include <cstring>
+
+namespace OHOS
+{
+
+PersonalCenterCarControlView::PersonalCenterCarControlView()
+{
+ SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+}
+/** 获取按钮 */
+UILabelButtonExt *PersonalCenterCarControlView::GetButton(int index)
+{
+ if (index >= 0 && index < 6) {
+ return btnButton_[index];
+ }
+ return nullptr;
+}
+
+/** 切换按钮状态 */
+void PersonalCenterCarControlView::ToggleButtonState(int index)
+{
+ if (index < 0 || index >= 6) {
+ return;
+ }
+
+ btnState_[index] = !btnState_[index];
+ const CarCtrlButtonState &s = g_carCtrlBtnStates[index];
+
+ UILabelButtonExt *btn = GetButton(index);
+ if (btn != nullptr) {
+ ImageInfo *img = ImageCacheManager::GetInstance().LoadSingleRes(
+ btnState_[index] ? s.imgOn : s.imgOff);
+ btn->SetImageSrc(img, img);
+ btn->SetText(btnState_[index] ? s.textOn : s.textOff);
+ btn->Invalidate();
+ }
+}
+
+/** 处理按钮点击 */
+bool PersonalCenterCarControlView::TryHandleCarButtonClick(const char *viewId)
+{
+ if (viewId == nullptr) {
+ return false;
+ }
+ for (int i = 0; i < 6; i++) {
+ if (strcmp(viewId, CAR_CTRL_BTN_VIEWID[i]) == 0) {
+ ToggleButtonState(i);
+ PersonalCenterModel::GetInstance()->OnCarControlButtonClicked(i, btnState_[i]);
+ return true;
+ }
+ }
+ return false;
+}
+
+/** 创建按钮 */
+UILabelButtonExt *PersonalCenterCarControlView::MakeCarCtrlButton(int x, int y, int index,
+ UIView::OnClickListener *clickListener)
+{
+ UILabelButtonExt *button = new UILabelButtonExt();
+ if (button == nullptr) {
+ return nullptr;
+ }
+
+ button->SetPosition(x, y, CAR_CTRL_BTN_SIZE, CAR_CTRL_BTN_SIZE);
+ button->SetViewId(CAR_CTRL_BTN_VIEWID[index]);
+ button->SetStyle(STYLE_BACKGROUND_COLOR, CAR_CTRL_BTN_BG_COLOR);
+ button->SetStyle(STYLE_BORDER_RADIUS, 25);
+ button->SetImagePosition(26, 8);
+ ImageInfo *img = ImageCacheManager::GetInstance().LoadSingleRes(g_carCtrlBtnStates[index].imgOff);
+ button->SetImageSrc(img, img);
+ button->SetLabelPosition(0, 107);
+ button->SetText(g_carCtrlBtnStates[index].textOff);
+ button->SetAlign(TEXT_ALIGNMENT_CENTER);
+ button->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 27);
+ button->SetStyle(STYLE_LINE_HEIGHT, CAR_CTRL_TEXT_H);
+ button->SetStyleForState(STYLE_BACKGROUND_OPA, 0x00, UIButton::PRESSED);
+ button->SetStyleForState(STYLE_BORDER_RADIUS, CAR_CTRL_BTN_SIZE / 2, UIButton::PRESSED);
+ if (clickListener != nullptr) {
+ button->SetOnClickListener(clickListener);
+ }
+ return button;
+}
+
+/** 构建 UI */
+void PersonalCenterCarControlView::BuildUi(PersonalCenterView *pcView)
+{
+ if (scrollView_ != nullptr) {
+ return;
+ }
+
+ UIView::OnClickListener *clickListener =
+ (pcView != nullptr) ? pcView->GetUiClickListener() : nullptr;
+ UIView::OnDragListener *dragListener =
+ (pcView != nullptr) ? pcView->GetUiDragListener() : nullptr;
+
+ scrollView_ = new UIScrollView();
+ if (scrollView_ == nullptr) {
+ return;
+ }
+ scrollView_->SetPosition(0, 0, 466, 466);
+ scrollView_->SetStyle(STYLE_BACKGROUND_COLOR, CAR_CTRL_BG_COLOR);
+ scrollView_->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ scrollView_->SetTouchable(true);
+ scrollView_->SetDraggable(true);
+ if (dragListener != nullptr) {
+ scrollView_->SetOnDragListener(dragListener);
+ }
+ PcApplyVerticalScrollBehavior(scrollView_, 1000);
+ scrollView_->RequestFocus();
+
+ titleLabel_ = new UILabel();
+ if (titleLabel_ != nullptr) {
+ titleLabel_->SetPosition(162, 21, 140, 35);
+ titleLabel_->SetText("蓝牙钥匙");
+ titleLabel_->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ titleLabel_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 35);
+ titleLabel_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ scrollView_->Add(titleLabel_);
+ }
+
+ statusLabel_ = new UILabel();
+ if (statusLabel_ != nullptr) {
+ statusLabel_->SetPosition(172, 70, 81, 27);
+ statusLabel_->SetText("已连接");
+ statusLabel_->SetStyle(STYLE_TEXT_COLOR, 0xff4fc3f7);
+ statusLabel_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 27);
+ statusLabel_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ scrollView_->Add(statusLabel_);
+ }
+
+ btIconView_ = new UIImageView();
+ if (btIconView_ != nullptr) {
+ btIconView_->SetPosition(263, 65, 34, 34);
+ btIconView_->SetSrc(CAR_CTRL_BT_ICON_IMG);
+ scrollView_->Add(btIconView_);
+ }
+
+ int gap = 20;
+ int gapY = 9;
+ int startX = 79;
+ int startY = 104;
+
+ for (int i = 0; i < 6; i++) {
+ int col = i % 2;
+ int row = i / 2;
+ int x = startX + col * (CAR_CTRL_BTN_SIZE + gap);
+ int y = startY + row * (CAR_CTRL_BTN_SIZE + gapY);
+
+ btnButton_[i] = MakeCarCtrlButton(x, y, i, clickListener);
+ if (btnButton_[i] == nullptr) {
+ continue;
+ }
+ scrollView_->Add(btnButton_[i]);
+ }
+
+ UIViewGroup *spacer = new UIViewGroup();
+ if (spacer != nullptr) {
+ spacer->SetPosition(0, 620, 1, 150);
+ spacer->SetStyle(STYLE_BACKGROUND_OPA, 0);
+ scrollView_->Add(spacer);
+ }
+
+ Add(scrollView_);
+}
+
+/** 初始化视图 */
+bool PersonalCenterCarControlView::InitView(void *caller)
+{
+ auto *pc = static_cast<PersonalCenterView *>(caller);
+ if (pc == nullptr) {
+ return false;
+ }
+
+ SetStyle(STYLE_BACKGROUND_COLOR, CAR_CTRL_BG_COLOR);
+ SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ SetTouchable(true);
+ SetDraggable(true);
+ SetOnDragListener(pc->GetUiDragListener());
+
+ BuildUi(pc);
+ if (scrollView_ == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterCarControlView init fail");
+ return false;
+ }
+
+ SetPosition(0, 0, 466, 466);
+ return true;
+}
+
+} // namespace OHOS
--- /dev/null
+#include "personal_center/include/PersonalCenterCarDashboardView.h"
+#include "personal_center/include/PersonalCenterCarUiConstants.h"
+#include "personal_center/include/PersonalCenterModel.h"
+#include "personal_center/include/PersonalCenterUiConfig.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+
+namespace OHOS
+{
+namespace {
+constexpr uint32_t COLOR_STATUS_BLUE = 0xff4fc3f7;
+constexpr uint32_t COLOR_DOT_INACTIVE = 0xff666666;
+constexpr uint32_t COLOR_DOT_ACTIVE = 0xff4fc3f7;
+} // namespace
+
+PersonalCenterCarDashboardView::PersonalCenterCarDashboardView()
+{
+ SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+}
+
+/** 释放状态小部件指针 */
+void PersonalCenterCarDashboardView::AbandonStatusWidgetPointers()
+{
+ titleLabel_ = nullptr;
+ modelLabel_ = nullptr;
+ parkLabel_ = nullptr;
+ refreshImg_ = nullptr;
+ carImg_ = nullptr;
+ rangeLeftNum_ = nullptr;
+ rangeLeftUnit_ = nullptr;
+ rangeRightNum_ = nullptr;
+ rangeRightUnit_ = nullptr;
+ batteryCircle_ = nullptr;
+ batteryPct_ = nullptr;
+ fuelCircle_ = nullptr;
+ fuelPct_ = nullptr;
+ statusRoot_ = nullptr;
+}
+
+/** 析构 */
+PersonalCenterCarDashboardView::~PersonalCenterCarDashboardView()
+{
+ AbandonStatusWidgetPointers();
+}
+
+/** 构建状态仪表盘 */
+bool PersonalCenterCarDashboardView::BuildStatusDashboard(UIView::OnDragListener *dragListener,
+ UIView::OnClickListener *clickListener, const char *titleText)
+{
+ if (statusRoot_ != nullptr || dragListener == nullptr) {
+ return false;
+ }
+
+ statusRoot_ = new UIViewGroup();
+ if (statusRoot_ == nullptr) {
+ return false;
+ }
+ statusRoot_->SetPosition(0, 0, 466, 466);
+ statusRoot_->SetStyle(STYLE_BACKGROUND_COLOR, PC_CAR_STATUS_BG_COLOR);
+ statusRoot_->SetTouchable(true);
+ statusRoot_->SetDraggable(true);
+ statusRoot_->SetOnDragListener(dragListener);
+ statusRoot_->SetVisible(false);
+
+ titleLabel_ = new UILabel();
+ if (titleLabel_ != nullptr) {
+ titleLabel_->SetPosition(162, 21, 140, 35);
+ titleLabel_->SetText((titleText != nullptr && titleText[0] != '\0') ? titleText : "蓝牙钥匙");
+ titleLabel_->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ titleLabel_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_CAR_STATUS_TITLE_FONT);
+ titleLabel_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ statusRoot_->Add(titleLabel_);
+ }
+
+ modelLabel_ = new UILabel();
+ if (modelLabel_ != nullptr) {
+ modelLabel_->SetPosition(140, 70, 79, 24);
+ modelLabel_->SetText("Uni-V");
+ modelLabel_->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ modelLabel_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_CAR_STATUS_SUBTITLE_FONT);
+ modelLabel_->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_CENTER);
+ statusRoot_->Add(modelLabel_);
+ }
+
+ parkLabel_ = new UILabel();
+ if (parkLabel_ != nullptr) {
+ parkLabel_->SetPosition(224, 70, 81, 27);
+ parkLabel_->SetText("已驻车");
+ parkLabel_->SetStyle(STYLE_TEXT_COLOR, COLOR_STATUS_BLUE);
+ parkLabel_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_CAR_STATUS_SUBTITLE_FONT);
+ parkLabel_->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_CENTER);
+ statusRoot_->Add(parkLabel_);
+ }
+
+ refreshImg_ = new UIImageView();
+ if (refreshImg_ != nullptr) {
+ refreshImg_->SetPosition(312, 72, PC_CAR_STATUS_REFRESH_SZ, PC_CAR_STATUS_REFRESH_SZ);
+ refreshImg_->SetSrc(PC_CAR_STATUS_REFRESH_IMG);
+ refreshImg_->SetTouchable(true);
+ if (clickListener != nullptr) {
+ refreshImg_->SetViewId("PcCarDashboardRefresh");
+ refreshImg_->SetOnClickListener(clickListener);
+ }
+ statusRoot_->Add(refreshImg_);
+ }
+
+ const int carX = 20;
+ const int carY = 120;
+ carImg_ = new UIImageView();
+ if (carImg_ != nullptr) {
+ carImg_->SetPosition(carX, carY, PC_CAR_STATUS_CAR_W, PC_CAR_STATUS_CAR_H);
+ carImg_->SetSrc(PC_CAR_STATUS_CAR_HERO_IMG);
+ statusRoot_->Add(carImg_);
+ }
+
+ rangeLeftNum_ = new UILabel();
+ if (rangeLeftNum_ != nullptr) {
+ rangeLeftNum_->SetPosition(63, 282, 107, 51);
+ rangeLeftNum_->SetText("359");
+ rangeLeftNum_->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ rangeLeftNum_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_CAR_STATUS_RANGE_FONT);
+ rangeLeftNum_->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_CENTER);
+ statusRoot_->Add(rangeLeftNum_);
+ }
+ rangeLeftUnit_ = new UILabel();
+ if (rangeLeftUnit_ != nullptr) {
+ rangeLeftUnit_->SetPosition(177, 303, 51, 27);
+ rangeLeftUnit_->SetText("Km");
+ rangeLeftUnit_->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ rangeLeftUnit_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_CAR_STATUS_UNIT_FONT);
+ rangeLeftUnit_->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_CENTER);
+ statusRoot_->Add(rangeLeftUnit_);
+ }
+
+ rangeRightNum_ = new UILabel();
+ if (rangeRightNum_ != nullptr) {
+ rangeRightNum_->SetPosition(261, 282, 73, 51);
+ rangeRightNum_->SetText("24");
+ rangeRightNum_->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ rangeRightNum_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_CAR_STATUS_RANGE_FONT);
+ rangeRightNum_->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_CENTER);
+ statusRoot_->Add(rangeRightNum_);
+ }
+ rangeRightUnit_ = new UILabel();
+ if (rangeRightUnit_ != nullptr) {
+ rangeRightUnit_->SetPosition(350, 303, 51, 27);
+ rangeRightUnit_->SetText("Km");
+ rangeRightUnit_->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ rangeRightUnit_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_CAR_STATUS_UNIT_FONT);
+ rangeRightUnit_->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_CENTER);
+ statusRoot_->Add(rangeRightUnit_);
+ }
+
+ batteryCircle_ = new UIImageView();
+ if (batteryCircle_ != nullptr) {
+ batteryCircle_->SetPosition(87, 342, PC_CAR_STATUS_CIRCLE_D, PC_CAR_STATUS_CIRCLE_D);
+ batteryCircle_->SetSrc(PC_CAR_STATUS_BATTERY_IMG);
+ statusRoot_->Add(batteryCircle_);
+ }
+ batteryPct_ = new UILabel();
+ if (batteryPct_ != nullptr) {
+ batteryPct_->SetPosition(164, 365, 72, 32);
+ batteryPct_->SetText("75%");
+ batteryPct_->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ batteryPct_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_CAR_STATUS_PCT_FONT);
+ batteryPct_->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_CENTER);
+ statusRoot_->Add(batteryPct_);
+ }
+
+ fuelCircle_ = new UIImageView();
+ if (fuelCircle_ != nullptr) {
+ fuelCircle_->SetPosition(244, 342, PC_CAR_STATUS_CIRCLE_D, PC_CAR_STATUS_CIRCLE_D);
+ fuelCircle_->SetSrc(PC_CAR_STATUS_FUEL_IMG);
+ statusRoot_->Add(fuelCircle_);
+ }
+ fuelPct_ = new UILabel();
+ if (fuelPct_ != nullptr) {
+ fuelPct_->SetPosition(325, 365, 68, 32);
+ fuelPct_->SetText("24%");
+ fuelPct_->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ fuelPct_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_CAR_STATUS_PCT_FONT);
+ fuelPct_->SetAlign(TEXT_ALIGNMENT_RIGHT, TEXT_ALIGNMENT_CENTER);
+ statusRoot_->Add(fuelPct_);
+ }
+
+ return true;
+}
+
+//获取车辆数据
+void PersonalCenterCarDashboardView::ApplyVehicleLabelsFromModel()
+{
+ PersonalCenterModel *m = PersonalCenterModel::GetInstance();
+ if (m == nullptr) {
+ return;
+ }
+ m->RefreshVehicleStatusSnapshot();
+ if (modelLabel_ != nullptr) {
+ modelLabel_->SetText(m->GetVehicleModelLine().c_str());
+ modelLabel_->Invalidate();
+ }
+ if (parkLabel_ != nullptr) {
+ parkLabel_->SetText(m->GetParkStatusText().c_str());
+ parkLabel_->Invalidate();
+ }
+ if (rangeLeftNum_ != nullptr) {
+ rangeLeftNum_->SetText(m->GetRangeEvKmText().c_str());
+ rangeLeftNum_->Invalidate();
+ }
+ if (rangeRightNum_ != nullptr) {
+ rangeRightNum_->SetText(m->GetRangeFuelKmText().c_str());
+ rangeRightNum_->Invalidate();
+ }
+ if (batteryPct_ != nullptr) {
+ batteryPct_->SetText(m->GetBatteryPercentText().c_str());
+ batteryPct_->Invalidate();
+ }
+ if (fuelPct_ != nullptr) {
+ fuelPct_->SetText(m->GetFuelPercentText().c_str());
+ fuelPct_->Invalidate();
+ }
+}
+
+bool PersonalCenterCarDashboardView::InitView(void *caller)
+{
+ auto *pc = static_cast<PersonalCenterView *>(caller);
+ if (pc == nullptr) {
+ return false;
+ }
+
+ SetStyle(STYLE_BACKGROUND_COLOR, CAR_CTRL_BG_COLOR);
+ SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ SetTouchable(true);
+ SetDraggable(true);
+ SetOnDragListener(pc->GetUiDragListener());
+
+ if (!BuildStatusDashboard(pc->GetUiDragListener(), pc->GetUiClickListener(), "车况信息")) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterCarDashboardView: BuildStatusDashboard fail");
+ return false;
+ }
+ if (statusRoot_ != nullptr) {
+ statusRoot_->SetVisible(true);
+ }
+ Add(statusRoot_);
+
+ SetPosition(0, 0, 466, 466);
+ ApplyVehicleLabelsFromModel();
+ return true;
+}
+
+} // namespace OHOS
--- /dev/null
+#include "personal_center/include/PersonalCenterCarHubView.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "personal_center/include/PersonalCenterCarControlView.h"
+#include "personal_center/include/PersonalCenterCarDashboardView.h"
+#include "personal_center/include/PersonalCenterRemoteControlView.h"
+#include "personal_center/include/PersonalCenterHubMainTabView.h"
+#include "personal_center/include/PersonalCenterCarUiConstants.h"
+#include "personal_center/include/PersonalCenterUiConfig.h"
+#include "components/ui_view.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+
+namespace OHOS
+{
+
+namespace
+{
+constexpr uint32_t PC_HUB_DOT_ON = 0xff4fc3f7;
+constexpr uint32_t PC_HUB_DOT_OFF = 0xff666666;
+constexpr int PC_HUB_DOT_STEP = 20;
+constexpr int PC_HUB_DOT_SZ = 8;
+constexpr int PC_HUB_DOT_BOTTOM = 20;
+}
+
+PersonalCenterCarHubView::PersonalCenterCarHubView()
+{
+ SetViewIndex(static_cast<uint16_t>(PC_PAGE_CAR_HUB));
+ SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+}
+
+PersonalCenterCarHubView::~PersonalCenterCarHubView() = default;
+
+void PersonalCenterCarHubView::BuildDotBar()
+{
+ dotBar_ = new UIViewGroup();
+ if (dotBar_ == nullptr) {
+ return;
+ }
+ dotBar_->SetPosition(0, 422, 466, 44);
+ dotBar_->SetStyle(STYLE_BACKGROUND_OPA, 0);
+ dotBar_->SetTouchable(false);
+
+ const int dotX = 199;
+ const int dotY = 12;
+ for (int i = 0; i < 4; i++) {
+ dots_[i] = new UIView();
+ if (dots_[i] != nullptr) {
+ dots_[i]->SetPosition(dotX + i * PC_HUB_DOT_STEP, dotY, PC_HUB_DOT_SZ, PC_HUB_DOT_SZ);
+ dots_[i]->SetStyle(STYLE_BACKGROUND_COLOR, PC_HUB_DOT_OFF);
+ dots_[i]->SetStyle(STYLE_BORDER_RADIUS, PC_HUB_DOT_SZ / 2);
+ dots_[i]->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ dotBar_->Add(dots_[i]);
+ }
+ }
+}
+
+void PersonalCenterCarHubView::UpdateDots(uint16_t activeIdx)
+{
+ if (activeIdx > 3) {
+ activeIdx = 0;
+ }
+ for (int i = 0; i < 4; i++) {
+ if (dots_[i] != nullptr) {
+ dots_[i]->SetStyle(STYLE_BACKGROUND_COLOR,
+ (static_cast<uint16_t>(i) == activeIdx) ? PC_HUB_DOT_ON : PC_HUB_DOT_OFF);
+ dots_[i]->Invalidate();
+ }
+ }
+}
+
+void PersonalCenterCarHubView::ShowDotBar(bool show)
+{
+ if (dotBar_ != nullptr) {
+ dotBar_->SetVisible(show);
+ dotBar_->Invalidate();
+ }
+}
+
+uint16_t PersonalCenterCarHubView::GetHorizontalIndex() const
+{
+ if (hSwipe_ == nullptr) {
+ return 0;
+ }
+ return hSwipe_->GetCurrentPage();
+}
+
+/** 代码或外部切 tab:同步 UISwipeView 页码与底部四点,并强制显示点条 */
+void PersonalCenterCarHubView::SetHorizontalIndex(uint16_t index, bool needAnimator)
+{
+ if (hSwipe_ == nullptr) {
+ return;
+ }
+ if (index > 3) {
+ index = 3;
+ }
+ hSwipe_->SetCurrentPage(index, needAnimator);
+ UpdateDots(index);
+ ShowDotBar(true);
+}
+
+/** 用户手指横滑换页结束后的回调:恢复与当前页一致的四点显示 */
+void PersonalCenterCarHubView::OnSwipe(UISwipeView &view)
+{
+ UNUSED(view);
+ UpdateDots(GetHorizontalIndex());
+ ShowDotBar(true);
+}
+
+/** 仅处理蓝牙/个人中心菜单内竖向 ScrollView:主方向为竖滑时隐藏四点;返回 false 以不拦截横向滑动 */
+bool PersonalCenterCarHubView::OnDrag(UIView &view, const DragEvent &event)
+{
+ const bool isMainScroll = (mainMenuScroll_ != nullptr && &view == mainMenuScroll_);
+ const bool isBtScroll = (bluetoothScroll_ != nullptr && &view == bluetoothScroll_);
+ if (!isMainScroll && !isBtScroll) {
+ return true; /* 非 Hub 内负责四点显隐的 ScrollView,不处理 */
+ }
+ if (MATH_ABS(event.GetDeltaY()) > 10 && (MATH_ABS(event.GetDeltaY()) > MATH_ABS(event.GetDeltaX()))) {
+ ShowDotBar(false);
+ }
+ /* 必须返回 false:否则 UIScrollView 会吞掉事件,父级横向 UISwipeView 无法左右切页 */
+ return false;
+}
+
+/**
+ * 蓝牙/个人中心菜单竖滑结束后不再自动显示四点(需求:仅横向从其它 tab 滑入时由 OnSwipe / SetHorizontalIndex 显示)。
+ */
+bool PersonalCenterCarHubView::OnDragEnd(UIView &view, const DragEvent &event)
+{
+ UNUSED(view);
+ UNUSED(event);
+ return false;
+}
+
+/** 构建横向四 tab + 底部点条;子 tab 的 InitView 由 PersonalCenterView * 传入以绑定 Presenter 监听 */
+bool PersonalCenterCarHubView::InitView(void *caller)
+{
+ auto *pc = static_cast<PersonalCenterView *>(caller);
+ if (pc == nullptr) {
+ return false;
+ }
+
+ SetStyle(STYLE_BACKGROUND_COLOR, PC_BG_COLOR);
+ SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ SetTouchable(true);
+ SetDraggable(true);
+ SetOnDragListener(pc->GetUiDragListener());
+
+ hSwipe_ = new UISwipeView(UISwipeView::HORIZONTAL);
+ if (hSwipe_ == nullptr) {
+ return false;
+ }
+ hSwipe_->SetStyle(STYLE_BACKGROUND_COLOR, CAR_CTRL_BG_COLOR);
+ hSwipe_->SetPosition(0, 0, 466, 466);
+ hSwipe_->SetAnimatorTime(0);
+ hSwipe_->SetLoopState(false);
+ hSwipe_->SetDraggable(true);
+ hSwipe_->SetTouchable(true);
+ hSwipe_->SetOnSwipeListener(this);
+
+ tabBluetooth_ = new PersonalCenterCarControlView();
+ if (tabBluetooth_ == nullptr || !tabBluetooth_->InitView(pc)) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CarHub bluetooth init fail");
+ return false;
+ }
+ hSwipe_->Add(tabBluetooth_);
+ bluetoothScroll_ = tabBluetooth_->GetContentScroll();
+ if (bluetoothScroll_ != nullptr) {
+ bluetoothScroll_->SetOnDragListener(this);
+ }
+
+ tabDash_ = new PersonalCenterCarDashboardView();
+ if (tabDash_ == nullptr || !tabDash_->InitView(pc)) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CarHub dashboard init fail");
+ return false;
+ }
+ hSwipe_->Add(tabDash_);
+
+ tabRemote_ = new PersonalCenterRemoteControlView();
+ if (tabRemote_ == nullptr || !tabRemote_->InitView(pc)) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CarHub remote init fail");
+ return false;
+ }
+ hSwipe_->Add(tabRemote_);
+
+ tabMain_ = new PersonalCenterHubMainTabView();
+ if (tabMain_ == nullptr || !tabMain_->InitView(pc)) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CarHub main tab init fail");
+ return false;
+ }
+ hSwipe_->Add(tabMain_);
+ mainMenuScroll_ = tabMain_->GetMenuScroll();
+ if (mainMenuScroll_ != nullptr) {
+ mainMenuScroll_->SetOnDragListener(this);
+ }
+
+ Add(hSwipe_);
+
+ BuildDotBar();
+ if (dotBar_ != nullptr) {
+ Add(dotBar_);
+ }
+ UpdateDots(0);
+ hSwipe_->SetCurrentPage(0, false);
+
+ initViewStatus = true;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterCarHubView::InitView ok");
+ return true;
+}
+
+} // namespace OHOS
--- /dev/null
+#include "personal_center/include/PersonalCenterDisclaimerView.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "personal_center/include/PersonalCenterUiConfig.h"
+#include "components/ui_label.h"
+#include "components/ui_label_button.h"
+#include "components/ui_scroll_view.h"
+#include "components/ui_view.h"
+#include "components/ui_view_group.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+
+namespace OHOS
+{
+
+namespace
+{
+constexpr uint32_t PC_DIS_BG = 0xff000000;
+constexpr int PC_DIS_TITLE_TOP = 28;
+}
+
+PersonalCenterDisclaimerView::PersonalCenterDisclaimerView()
+{
+ SetViewIndex(static_cast<uint16_t>(PC_PAGE_DISCLAIMER));
+ SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+}
+
+PersonalCenterDisclaimerView::~PersonalCenterDisclaimerView() = default;
+
+bool PersonalCenterDisclaimerView::InitView(void *caller)
+{
+ auto *pc = static_cast<PersonalCenterView *>(caller);
+ if (pc == nullptr) {
+ return false;
+ }
+
+ SetStyle(STYLE_BACKGROUND_COLOR, PC_DIS_BG);
+ SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ SetTouchable(true);
+ SetDraggable(true);
+
+ auto *scroll = new UIScrollView();
+ if (scroll == nullptr) {
+ return false;
+ }
+ scroll->SetPosition(0, 0, 466, 338);
+ scroll->SetStyle(STYLE_BACKGROUND_COLOR, PC_DIS_BG);
+ scroll->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ scroll->SetTouchable(true);
+ scroll->SetDraggable(true);
+ scroll->SetOnDragListener(pc->GetUiDragListener());
+ scroll->SetReboundSize(40);
+ scroll->SetHorizontalScrollState(false);
+ scroll->SetScrollBlankSize(60);
+ scroll->SetThrowDrag(true);
+ scroll->SetRotateFactor(2);
+
+ int y = PC_DIS_TITLE_TOP;
+ auto *lblTitle = new UILabel();
+ if (lblTitle != nullptr) {
+ lblTitle->SetPosition(0, 30, 466, 48);
+ lblTitle->SetText("「腕有引力」声明");
+ lblTitle->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ lblTitle->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 35);
+ lblTitle->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ scroll->Add(lblTitle);
+ }
+ y += 52;
+
+ auto *lblBody = new UILabel();
+ if (lblBody != nullptr) {
+ lblBody->SetPosition(55, 110, 360, 210);
+ lblBody->SetStyle(STYLE_TEXT_COLOR, 0xffdddddd);
+ lblBody->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 32);
+ lblBody->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
+ lblBody->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_TOP);
+ lblBody->SetText(
+ "「腕有引力」APP是用于长安车联网用户在智能手表上远程控车、定位查询、车况查看的软件。为了实现上述目的,我们在向你提供服务时会"
+ "收集、使用、存储必要的信息,并依法采取安全保护措施。请仔细阅读相关协议及隐私政策。点击「确定」表示你已阅读并同意上述内容;"
+ "点击「取消」将返回上级。");
+ scroll->Add(lblBody);
+ }
+ Add(scroll);
+
+ /* 底部双按钮区:单层 UIViewGroup,圆角蓝底画在容器自身,子视图仅分割线 + 透明按钮 */
+ constexpr int kBarW = 304;
+ constexpr int kBarH = 100;
+ constexpr int kBarX = 81;
+ constexpr int kBarY = 320;
+
+ auto *bottom = new UIViewGroup();
+ if (bottom == nullptr) {
+ return false;
+ }
+ bottom->SetPosition(kBarX, kBarY, kBarW, kBarH);
+ bottom->SetStyle(STYLE_BACKGROUND_COLOR, PC_DISC_BOTTOM_BLUE);
+ bottom->SetStyle(STYLE_BORDER_RADIUS, 44);
+ bottom->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ bottom->SetTouchable(true);
+
+ auto *div = new UIView();
+ if (div != nullptr) {
+ div->SetPosition(140, 35, 2, 37);
+ div->SetStyle(STYLE_BACKGROUND_COLOR, 0x66ffffff);
+ bottom->Add(div);
+ }
+
+ UIView::OnClickListener *click = pc->GetUiClickListener();
+
+ auto *btnCancel = new UILabelButton();
+ if (btnCancel != nullptr) {
+ btnCancel->SetPosition(0, 0, 152, kBarH);
+ btnCancel->SetViewId("PcdCancel");
+ btnCancel->SetStyle(STYLE_BACKGROUND_OPA, 0);
+ btnCancel->SetText("取消");
+ btnCancel->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 28);
+ btnCancel->SetAlign(TEXT_ALIGNMENT_CENTER);
+ btnCancel->SetOnClickListener(click);
+ bottom->Add(btnCancel);
+ }
+
+ auto *btnConfirm = new UILabelButton();
+ if (btnConfirm != nullptr) {
+ btnConfirm->SetPosition(140, 0, 152, kBarH);
+ btnConfirm->SetViewId("PcdConfirm");
+ btnConfirm->SetStyle(STYLE_BACKGROUND_OPA, 0);
+ btnConfirm->SetText("确定");
+ btnConfirm->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 28);
+ btnConfirm->SetAlign(TEXT_ALIGNMENT_CENTER);
+ btnConfirm->SetOnClickListener(click);
+ bottom->Add(btnConfirm);
+ }
+
+ Add(bottom);
+
+ initViewStatus = true;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterDisclaimerView::InitView ok");
+ return true;
+}
+
+} // namespace OHOS
--- /dev/null
+#include "personal_center/include/PersonalCenterHubMainTabView.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "personal_center/include/PersonalCenterUiConfig.h"
+#include "personal_center/include/PersonalCenterUiScroll.h"
+#include "components/ui_label.h"
+#include "components/ui_label_button.h"
+#include "components/ui_scroll_view.h"
+#include "components/ui_view_group.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+
+namespace OHOS
+{
+
+namespace
+{
+static UILabelButton *CreateMenuButton(int x, int y, const char *viewId, const char *text)
+{
+ UILabelButton *btn = new UILabelButton();
+ if (btn == nullptr) {
+ return nullptr;
+ }
+ btn->SetPosition(x, y, PC_BTN_W, PC_BTN_H);
+ btn->SetViewId(viewId);
+ btn->SetStyle(STYLE_BACKGROUND_COLOR, PC_BTN_BG_COLOR);
+ btn->SetStyle(STYLE_BORDER_RADIUS, 100);
+ btn->SetText(text);
+ btn->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_BTN_FONT);
+ btn->SetAlign(TEXT_ALIGNMENT_CENTER);
+ return btn;
+}
+}
+
+PersonalCenterHubMainTabView::PersonalCenterHubMainTabView()
+{
+ SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+}
+
+PersonalCenterHubMainTabView::~PersonalCenterHubMainTabView() = default;
+
+bool PersonalCenterHubMainTabView::InitView(void *caller)
+{
+ auto *pc = static_cast<PersonalCenterView *>(caller);
+ if (pc == nullptr) {
+ return false;
+ }
+
+ SetStyle(STYLE_BACKGROUND_COLOR, PC_BG_COLOR);
+ SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ SetTouchable(true);
+ SetDraggable(true);
+
+ scroll_ = new UIScrollView();
+ if (scroll_ == nullptr) {
+ return false;
+ }
+ scroll_->SetPosition(0, 0, 466, 466);
+ scroll_->SetStyle(STYLE_BACKGROUND_COLOR, PC_BG_COLOR);
+ scroll_->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ scroll_->SetTouchable(true);
+ scroll_->SetDraggable(true);
+ PcApplyVerticalScrollBehavior(scroll_, 2000);
+ scroll_->RequestFocus();
+
+ int y = PC_TITLE_TOP;
+ auto *title = new UILabel();
+ if (title != nullptr) {
+ title->SetPosition(0, y, 466, 56);
+ title->SetText("个人中心");
+ title->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ title->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_TITLE_FONT);
+ title->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ scroll_->Add(title);
+ }
+ y += 56 + PC_BTN_GAP;
+
+ UIView::OnClickListener *onClick = pc->GetUiClickListener();
+
+ UILabelButton *btn = CreateMenuButton(18, y, "PcMyAccount", "我的账户");
+ if (btn != nullptr) {
+ btn->SetOnClickListener(onClick);
+ scroll_->Add(btn);
+ }
+ y += PC_BTN_H + PC_BTN_GAP;
+
+ btn = CreateMenuButton(18, y, "PcMyVehicle", "我的车辆");
+ if (btn != nullptr) {
+ btn->SetOnClickListener(onClick);
+ scroll_->Add(btn);
+ }
+ y += PC_BTN_H + PC_BTN_GAP;
+
+ btn = CreateMenuButton(18, y, "PcKeySettings", "钥匙设置");
+ if (btn != nullptr) {
+ btn->SetOnClickListener(onClick);
+ scroll_->Add(btn);
+ }
+ y += PC_BTN_H + PC_BTN_GAP;
+
+ btn = CreateMenuButton(18, y, "PcClearCache", "清除缓存");
+ if (btn != nullptr) {
+ btn->SetOnClickListener(onClick);
+ scroll_->Add(btn);
+ }
+
+ auto *lblCache = new UILabel();
+ if (lblCache != nullptr) {
+ lblCache->SetTouchable(false);
+ lblCache->SetPosition(18, y + PC_BTN_H - 40, PC_BTN_W, 32);
+ lblCache->SetText("50MB");
+ lblCache->SetStyle(STYLE_TEXT_COLOR, 0xff888888);
+ lblCache->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_SUB_FONT);
+ lblCache->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ scroll_->Add(lblCache);
+ }
+ y += PC_BTN_H + PC_BTN_GAP;
+
+ btn = CreateMenuButton(18, y, "PcAbout", "关于我们");
+ if (btn != nullptr) {
+ btn->SetOnClickListener(onClick);
+ scroll_->Add(btn);
+ }
+ y += PC_BTN_H + PC_BTN_GAP;
+
+ btn = CreateMenuButton(18, y, "PcLogout", "退出登录");
+ if (btn != nullptr) {
+ btn->SetOnClickListener(onClick);
+ scroll_->Add(btn);
+ }
+ y += PC_BTN_H + PC_BTN_GAP;
+
+ auto *spacer = new UIViewGroup();
+ if (spacer != nullptr) {
+ spacer->SetPosition(0, 1288, 1, 200);
+ spacer->SetStyle(STYLE_BACKGROUND_OPA, 0);
+ scroll_->Add(spacer);
+ }
+
+ Add(scroll_);
+ initViewStatus = true;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterHubMainTabView::InitView ok");
+ return true;
+}
+
+} // namespace OHOS
--- /dev/null
+#include "personal_center/include/PersonalCenterKeyModeView.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "personal_center/include/PersonalCenterUiConfig.h"
+#include "personal_center/include/PersonalCenterUiScroll.h"
+#include "components/ui_checkbox.h"
+#include "components/ui_scroll_view.h"
+#include "components/ui_image_view.h"
+#include "components/ui_label.h"
+#include "components/ui_label_ext.h"
+#include "components/ui_toggle_button.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+
+namespace OHOS
+{
+
+namespace
+{
+constexpr uint32_t KM_ROW_BG = 0xff191919;
+
+bool g_peUnlock = true;
+bool g_welcomeLock = false;
+
+class PeUnlockListener : public UICheckBox::OnChangeListener
+{
+public:
+ bool OnChange(UICheckBox::UICheckBoxState state) override
+ {
+ g_peUnlock = (state == UICheckBox::SELECTED);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "KeyMode 无感PE = %d", g_peUnlock ? 1 : 0);
+ return true;
+ }
+};
+
+class WelcomeListener : public UICheckBox::OnChangeListener
+{
+public:
+ bool OnChange(UICheckBox::UICheckBoxState state) override
+ {
+ g_welcomeLock = (state == UICheckBox::SELECTED);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "KeyMode 迎宾 = %d", g_welcomeLock ? 1 : 0);
+ return true;
+ }
+};
+
+static PeUnlockListener g_listenerPe;
+static WelcomeListener g_listenerWelcome;
+} // namespace
+
+PersonalCenterKeyModeView::PersonalCenterKeyModeView()
+{
+ SetViewIndex(static_cast<uint16_t>(PC_PAGE_KEY_MODE));
+ SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+}
+
+PersonalCenterKeyModeView::~PersonalCenterKeyModeView() = default;
+
+bool PersonalCenterKeyModeView::GetPassiveEntryUnlock()
+{
+ return g_peUnlock;
+}
+
+bool PersonalCenterKeyModeView::GetWelcomeLockUnlock()
+{
+ return g_welcomeLock;
+}
+
+void PersonalCenterKeyModeView::RefreshToggles()
+{
+ if (togglePe_ != nullptr) {
+ togglePe_->SetState(g_peUnlock);
+ }
+ if (toggleWelcome_ != nullptr) {
+ toggleWelcome_->SetState(g_welcomeLock);
+ }
+}
+
+bool PersonalCenterKeyModeView::InitView(void *caller)
+{
+ auto *pc = static_cast<PersonalCenterView *>(caller);
+ if (pc == nullptr) {
+ return false;
+ }
+
+ const int rowW = 380;
+
+ SetStyle(STYLE_BACKGROUND_COLOR, PC_BG_COLOR);
+ SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ SetTouchable(true);
+ SetDraggable(true);
+
+ auto *scroll = new UIScrollView();
+ if (scroll == nullptr) {
+ return false;
+ }
+ scroll->SetPosition(0, 0, 466, 466);
+ scroll->SetStyle(STYLE_BACKGROUND_COLOR, PC_BG_COLOR);
+ scroll->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ scroll->SetTouchable(true);
+ scroll->SetDraggable(true);
+ scroll->SetOnDragListener(pc->GetUiDragListener());
+ PcApplyVerticalScrollBehavior(scroll, 2000, 80);
+
+ int y = 36;
+ auto *title = new UILabel();
+ if (title != nullptr) {
+ title->SetPosition(0, y, 466, 44);
+ title->SetText("钥匙模式");
+ title->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ title->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 32);
+ title->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ scroll->Add(title);
+ }
+ y += 56;
+
+ auto *rowPe = new UIImageView();
+ if (rowPe != nullptr) {
+ rowPe->SetPosition(43, y, rowW, 100);
+ rowPe->SetStyle(STYLE_BACKGROUND_COLOR, KM_ROW_BG);
+ rowPe->SetStyle(STYLE_BORDER_RADIUS, 50);
+ scroll->Add(rowPe);
+ }
+
+ auto *lblPe = new UILabelExt();
+ if (lblPe != nullptr) {
+ lblPe->SetPosition(71, y + 30, 220, 40);
+ lblPe->SetText("无感PE解锁");
+ lblPe->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ lblPe->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 26);
+ lblPe->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_CENTER);
+ lblPe->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
+ scroll->Add(lblPe);
+ }
+
+ togglePe_ = new UIToggleButton();
+ if (togglePe_ != nullptr) {
+ togglePe_->SetPosition(295, y + 25, 100, 50);
+ togglePe_->SetStyle(STYLE_BACKGROUND_OPA, 0);
+ togglePe_->SetImages(PNG_TOGGLEBUTTON_ON_IMAGE, PNG_TOGGLEBUTTON_OFF_IMAGE);
+ togglePe_->SetOnChangeListener(&g_listenerPe);
+ scroll->Add(togglePe_);
+ }
+ y += 112;
+
+ auto *rowWelcome = new UIImageView();
+ if (rowWelcome != nullptr) {
+ rowWelcome->SetPosition(43, y, rowW, 100);
+ rowWelcome->SetStyle(STYLE_BACKGROUND_COLOR, KM_ROW_BG);
+ rowWelcome->SetStyle(STYLE_BORDER_RADIUS, 50);
+ scroll->Add(rowWelcome);
+ }
+
+ auto *lblWelcome = new UILabelExt();
+ if (lblWelcome != nullptr) {
+ lblWelcome->SetPosition(71, y + 30, 220, 40);
+ lblWelcome->SetText("迎宾解闭锁");
+ lblWelcome->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ lblWelcome->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 26);
+ lblWelcome->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_CENTER);
+ scroll->Add(lblWelcome);
+ }
+
+ toggleWelcome_ = new UIToggleButton();
+ if (toggleWelcome_ != nullptr) {
+ toggleWelcome_->SetPosition(295, y + 25, 100, 50);
+ toggleWelcome_->SetStyle(STYLE_BACKGROUND_OPA, 0);
+ toggleWelcome_->SetImages(PNG_TOGGLEBUTTON_ON_IMAGE, PNG_TOGGLEBUTTON_OFF_IMAGE);
+ toggleWelcome_->SetOnChangeListener(&g_listenerWelcome);
+ scroll->Add(toggleWelcome_);
+ }
+ y += 120;
+
+ auto *hint = new UILabel();
+ if (hint != nullptr) {
+ hint->SetPosition(43, y, rowW, 120);
+ hint->SetText("以上功能常开,会增加功耗,可酌情开启");
+ hint->SetStyle(STYLE_TEXT_COLOR, 0xff999999);
+ hint->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 22);
+ hint->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
+ hint->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_TOP);
+ scroll->Add(hint);
+ }
+
+ Add(scroll);
+ RefreshToggles();
+ initViewStatus = true;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterKeyModeView::InitView ok");
+ return true;
+}
+
+} // namespace OHOS
--- /dev/null
+#include "personal_center/include/PersonalCenterLoginView.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "personal_center/include/PersonalCenterUiConfig.h"
+#include "changan_http_api.h"
+#include "cmsis_os.h"
+#include "common/image_decode_ability.h"
+#include "components/ui_image_view.h"
+#include "components/ui_label.h"
+#include "components/ui_label_button.h"
+#include "components/ui_view.h"
+#include "graphic_config.h"
+#include "gfx_utils/color.h"
+#include "service/graphic_service.h"
+#include "securec.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+namespace OHOS
+{
+
+namespace
+{
+constexpr int PC_QR_BOX = 200;
+constexpr char kPcChanganQrPngPath[] = "/user/userdata/personal_center_changan_qr.png";
+#ifndef CHANGAN_PC_QR_RESP_CAP
+#define CHANGAN_PC_QR_RESP_CAP (64U * 1024U)
+#endif
+#ifndef CHANGAN_PC_QR_STATUS_RSP_CAP
+#define CHANGAN_PC_QR_STATUS_RSP_CAP 4096U
+#endif
+
+constexpr uint32_t kLoginQrMonitorPeriodMs = 1000U;
+
+#if 0 /* 原同步 changan_http_qrcode_generate 写盘路径,异步接入后与 LoadChanganQrSync 同开 */
+static bool PcWriteQrPngFile(const uint8_t *data, uint32_t len)
+{
+ if (data == nullptr || len < 8U) {
+ return false;
+ }
+ if (data[0] != 0x89U || data[1] != 0x50U || data[2] != 0x4EU || data[3] != 0x47U) {
+ return false;
+ }
+ FILE *fp = fopen(kPcChanganQrPngPath, "wb");
+ if (fp == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: fopen qr png fail");
+ return false;
+ }
+ const size_t w = fwrite(data, 1U, (size_t)len, fp);
+ fclose(fp);
+ if (w != (size_t)len) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: fwrite qr png fail");
+ return false;
+ }
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: fwrite qr png success");
+ return true;
+}
+#endif
+
+static void PcEnsurePngDecodeAbilityForQr()
+{
+#if ENABLE_JPEG_AND_PNG
+ uint32_t ab = ImageDecodeAbility::GetInstance().GetImageDecodeAbility();
+ ImageDecodeAbility::GetInstance().SetImageDecodeAbility(ab | IMG_SUPPORT_PNG | IMG_SUPPORT_JPEG);
+#endif
+}
+
+#if 0 /* 原同步 changan_http_qrcode_status 解析路径,异步接入后与 CheckQrCodeScan 同开 */
+#include "cJSON.h"
+
+/**
+ * 与 py/qrcode_status_no_backend_v1_test.py 一致:body 里 data 可能为嵌套 JSON 字符串,
+ * inner.result == "authorized" 表示已扫码授权。
+ */
+static bool PcQrStatusBodyIsAuthorized(const char *respJson)
+{
+ if (respJson == nullptr || respJson[0] == '\0') {
+ return false;
+ }
+ cJSON *root = cJSON_Parse(respJson);
+ if (root == nullptr) {
+ return false;
+ }
+ bool ok = false;
+ cJSON *dataItem = cJSON_GetObjectItem(root, "data");
+ if (dataItem == nullptr || dataItem->type == cJSON_NULL) {
+ cJSON_Delete(root);
+ return false;
+ }
+ cJSON *inner = nullptr;
+ if (dataItem->type == cJSON_String && dataItem->valuestring != nullptr) {
+ inner = cJSON_Parse(dataItem->valuestring);
+ } else if (dataItem->type == cJSON_Object) {
+ inner = cJSON_Duplicate(dataItem, 1);
+ }
+ if (inner != nullptr) {
+ cJSON *result = cJSON_GetObjectItem(inner, "result");
+ if (result != nullptr && result->type == cJSON_String && result->valuestring != nullptr &&
+ strcmp(result->valuestring, "authorized") == 0) {
+ ok = true;
+ }
+ cJSON_Delete(inner);
+ }
+ cJSON_Delete(root);
+ return ok;
+}
+#endif
+
+} // namespace
+
+PersonalCenterLoginView::PersonalCenterLoginView()
+{
+ SetViewIndex(static_cast<uint16_t>(PC_PAGE_LOGIN));
+ SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+}
+
+PersonalCenterLoginView::~PersonalCenterLoginView()
+{
+ login_monitor_active_.store(false, std::memory_order_release);
+ StopLoginQrMonitorTimer();
+}
+
+bool PersonalCenterLoginView::InitView(void *caller)
+{
+ auto *pc = static_cast<PersonalCenterView *>(caller);
+ if (pc == nullptr) {
+ return false;
+ }
+
+ SetPosition(0, 0, 466, 466);
+ SetStyle(STYLE_BACKGROUND_COLOR, PC_BG_COLOR);
+ SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ SetTouchable(true);
+ SetDraggable(true);
+ SetOnDragListener(pc->GetUiDragListener());
+
+ UIView::OnClickListener *onClick = pc->GetUiClickListener();
+
+ int y = 36;
+ auto *lblLoginTitle = new UILabel();
+ if (lblLoginTitle != nullptr) {
+ lblLoginTitle->SetPosition(0, y, 466, 48);
+ lblLoginTitle->SetText("登录");
+ lblLoginTitle->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ lblLoginTitle->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 36);
+ lblLoginTitle->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ Add(lblLoginTitle);
+ }
+ y += 56;
+
+ qrImage_ = new UIImageView();
+ if (qrImage_ != nullptr) {
+ qrImage_->SetPosition(133, y, PC_QR_BOX, PC_QR_BOX);
+ qrImage_->SetStyle(STYLE_BACKGROUND_COLOR, 0xffffffff);
+ qrImage_->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ qrImage_->SetStyle(STYLE_IMAGE_OPA, OPA_OPAQUE);
+ qrImage_->SetStyle(STYLE_BORDER_RADIUS, 12);
+ qrImage_->SetTouchable(false);
+ qrImage_->SetAutoEnable(false);
+ qrImage_->SetResizeMode(UIImageView::ImageResizeMode::SCALE_DOWN);
+ Add(qrImage_);
+ }
+ y += PC_QR_BOX + 24;
+
+ auto *lblQrHint = new UILabel();
+ if (lblQrHint != nullptr) {
+ lblQrHint->SetPosition(32, y, 402, 80);
+ lblQrHint->SetText("用手机引力域扫码登录");
+ lblQrHint->SetStyle(STYLE_TEXT_COLOR, 0xffcccccc);
+ lblQrHint->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 26);
+ lblQrHint->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
+ lblQrHint->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_TOP);
+ Add(lblQrHint);
+ }
+ y += 88;
+ auto *btnPick = new UILabelButton();
+ if (btnPick != nullptr) {
+ btnPick->SetPosition(18, y, PC_BTN_W, PC_BTN_H);
+ btnPick->SetViewId("PcGoSelectCar");
+ btnPick->SetStyle(STYLE_BACKGROUND_COLOR, PC_BTN_BG_COLOR);
+ btnPick->SetStyle(STYLE_BORDER_RADIUS, 40);
+ btnPick->SetText("选车");
+ btnPick->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_BTN_FONT);
+ btnPick->SetAlign(TEXT_ALIGNMENT_CENTER);
+ btnPick->SetOnClickListener(onClick);
+ Add(btnPick);
+ }
+
+ initViewStatus = true;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView::InitView ok");
+ return true;
+}
+
+void PersonalCenterLoginView::OnQrScanAuthorizedUi()
+{
+ GraphicService::GetInstance()->PostGraphicEvent([this]() {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: QR authorized (UI thread)");
+ /* TODO: 写登录态 / Presenter 切页,例如 PersonalCenterView::GetInstance()->GoSelectCarPage(); */
+ });
+}
+
+void PersonalCenterLoginView::LoginQrMonitorTimerCallback(void *arg)
+{
+ auto *self = static_cast<PersonalCenterLoginView *>(arg);
+ if (self == nullptr) {
+ return;
+ }
+ if (!self->login_monitor_active_.load(std::memory_order_acquire)) {
+ return;
+ }
+ GraphicService::GetInstance()->PostGraphicEvent([self]() {
+ if (!self->login_monitor_active_.load(std::memory_order_acquire)) {
+ return;
+ }
+ if (!self->qrCodeSuccess_) {
+ (void)self->LoadChanganQrSync();
+ return;
+ }
+ const int scan = self->CheckQrCodeScan();
+ if (scan == 1) {
+ self->StopLoginQrMonitorTimer();
+ self->login_monitor_active_.store(false, std::memory_order_release);
+ self->OnQrScanAuthorizedUi();
+ return;
+ }
+ if (scan == -1) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: CheckQrCodeScan error, retry");
+ }
+ });
+}
+//启动二维码扫描定时器
+void PersonalCenterLoginView::StartLoginQrMonitorTimer()
+{
+ if (login_qr_monitor_timer_ != nullptr) {
+ return;
+ }
+ login_qr_monitor_timer_ = osTimerNew(
+ (osTimerFunc_t)LoginQrMonitorTimerCallback, osTimerPeriodic, this, nullptr);
+ if (login_qr_monitor_timer_ == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: osTimerNew login QR monitor fail");
+ return;
+ }
+ const uint32_t tick = (uint32_t)osMs2Tick(kLoginQrMonitorPeriodMs);
+ const osStatus_t ret = osTimerStart(login_qr_monitor_timer_, tick);
+ if (ret != osOK) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: osTimerStart login QR monitor fail ret=%d", (int)ret);
+ (void)osTimerDelete(login_qr_monitor_timer_);
+ login_qr_monitor_timer_ = nullptr;
+ return;
+ }
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: login QR monitor timer %u ms", (unsigned)kLoginQrMonitorPeriodMs);
+}
+
+//停止二维码扫描定时器
+void PersonalCenterLoginView::StopLoginQrMonitorTimer()
+{
+ if (login_qr_monitor_timer_ != nullptr) {
+ (void)osTimerStop(login_qr_monitor_timer_);
+ (void)osTimerDelete(login_qr_monitor_timer_);
+ login_qr_monitor_timer_ = nullptr;
+ }
+}
+
+//登录页面可见时调用
+void PersonalCenterLoginView::OnLoginPageBecameVisible()
+{
+ StopLoginQrMonitorTimer();
+ login_monitor_active_.store(true, std::memory_order_release);
+ StartLoginQrMonitorTimer();
+ /* 首帧立即尝试一次,不必空等一个周期 */
+ LoginQrMonitorTimerCallback(this);
+}
+
+//登录页面不可见时调用
+void PersonalCenterLoginView::OnLoginPageBecameHidden()
+{
+ login_monitor_active_.store(false, std::memory_order_release);
+ StopLoginQrMonitorTimer();
+ qrCodeSuccess_ = false;
+ last_qrcode_id_[0] = '\0';
+}
+
+//刷新二维码图片
+void PersonalCenterLoginView::PostRefreshQrImageOnUiThread()
+{
+ const char *path = kPcChanganQrPngPath;
+ GraphicService::GetInstance()->PostGraphicEvent([this, path]() {
+ if (qrImage_ == nullptr) {
+ return;
+ }
+ PcEnsurePngDecodeAbilityForQr();
+ qrImage_->SetSrc(path);
+ qrImage_->SetStyle(STYLE_IMAGE_OPA, OPA_OPAQUE);
+ qrImage_->Invalidate();
+ Invalidate();
+ UIView *parent = qrImage_->GetParent();
+ if (parent != nullptr) {
+ parent->Invalidate();
+ }
+ });
+}
+
+int PersonalCenterLoginView::LoadChanganQrSync()
+{
+ /* changan_http_qrcode_generate_v1 仅保留异步形态 (params, cb, user_data);原同步缓冲调用已注释,待接入回调后再开。 */
+#if 0
+ changan_qrcode_generate_v1_params_t p;
+ (void)memset(&p, 0, sizeof(p));
+ p.client_id = CHANGAN_HTTP_QRCODE_DEFAULT_CLIENT_ID;
+ // p.device_id = "8c046d6f4ed0ec77";
+ p.nonce = "WYYL";
+ p.size = "L";
+ p.state = "OPPOWATCH";
+ p.timestamp_ms = nullptr;
+ p.app_key = CHANGAN_HTTP_QRCODE_DEFAULT_APP_KEY;
+ p.app_code = CHANGAN_HTTP_QRCODE_DEFAULT_APP_CODE;
+ p.exclude_app_code_from_sign = true;
+
+ uint8_t *resp = static_cast<uint8_t *>(malloc((size_t)CHANGAN_PC_QR_RESP_CAP));
+ if (resp == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: QR_GEN malloc fail");
+ return -1;
+ }
+
+ uint32_t body_len = 0;
+ char qid[128];
+ qid[0] = '\0';
+
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: QR_GEN start");
+ const int http_st =
+ changan_http_qrcode_generate_v1(&p, resp, CHANGAN_PC_QR_RESP_CAP, &body_len, qid, (uint32_t)sizeof(qid));
+ const bool ok = (http_st == 200) && PcWriteQrPngFile(resp, body_len);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: QR_GEN end");
+ free(resp);
+
+ if (!ok) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+ "PersonalCenterLoginView: QR_GEN fail http=%d body_len=%u", http_st, (unsigned)body_len);
+ return -1;
+ }
+ if (qid[0] != '\0') {
+ (void)strncpy_s(last_qrcode_id_, sizeof(last_qrcode_id_), qid, sizeof(last_qrcode_id_) - 1U);
+ last_qrcode_id_[sizeof(last_qrcode_id_) - 1U] = '\0';
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: qrcode_id=%s", last_qrcode_id_);
+ } else {
+ last_qrcode_id_[0] = '\0';
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: qrcode_id empty (status API may fail)");
+ }
+
+ PostRefreshQrImageOnUiThread();
+ qrCodeSuccess_ = true;
+ return 0;
+#else
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: QR_GEN skipped (async API only)");
+ return -1;
+#endif
+}
+
+int PersonalCenterLoginView::CheckQrCodeScan()
+{
+ if (last_qrcode_id_[0] == '\0') {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: CheckQrCodeScan no qrcode_id");
+ return -1;
+ }
+
+ /* changan_http_qrcode_status_no_backend_v1 仅保留异步形态 (params, cb, user_data);原同步缓冲调用已注释。 */
+#if 0
+ changan_qrcode_status_no_backend_v1_params_t p = {};
+ p.nonce = "WYYL";
+ p.timestamp_sec = nullptr;
+ p.qrcode_id = last_qrcode_id_;
+ p.app_key = CHANGAN_HTTP_QRCODE_DEFAULT_APP_KEY;
+ p.no_app_key = false;
+
+ char *rsp = static_cast<char *>(malloc((size_t)CHANGAN_PC_QR_STATUS_RSP_CAP));
+ if (rsp == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: QR_ST malloc fail");
+ return -1;
+ }
+ (void)memset(rsp, 0, (size_t)CHANGAN_PC_QR_STATUS_RSP_CAP);
+
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: QR_ST start");
+ const int http_st =
+ changan_http_qrcode_status_no_backend_v1(&p, rsp, CHANGAN_PC_QR_STATUS_RSP_CAP);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: QR_ST end http=%d", http_st);
+
+ int ret = -1;
+ if (http_st == 200) {
+ if (PcQrStatusBodyIsAuthorized(rsp)) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: QR_ST authorized");
+ ret = 1;
+ } else {
+ ret = 0;
+ }
+ } else {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+ "PersonalCenterLoginView: QR_ST fail http=%d", http_st);
+ ret = -1;
+ }
+ free(rsp);
+ return ret;
+#else
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenterLoginView: QR_ST skipped (async API only)");
+ return -1;
+#endif
+}
+
+} // namespace OHOS
--- /dev/null
+/*
+ * @file PersonalCenterModel.cpp
+ */
+#include "personal_center/include/PersonalCenterModel.h"
+#include "personal_center/include/PersonalCenterModelC.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "ConfigModel.h"
+#include "wearable_log.h"
+#include <algorithm>
+#include <cctype>
+#include <cstdlib>
+#include <cstring>
+
+namespace OHOS
+{
+
+namespace
+{
+static void TrimInPlace(std::string &s)
+{
+ while (!s.empty() && std::isspace(static_cast<unsigned char>(s.front()))) {
+ s.erase(s.begin());
+ }
+ while (!s.empty() && std::isspace(static_cast<unsigned char>(s.back()))) {
+ s.pop_back();
+ }
+}
+
+static bool StartsWithIgnoreCase(const char *s, const char *prefix)
+{
+ if (s == nullptr || prefix == nullptr) {
+ return false;
+ }
+ while (*prefix != '\0') {
+ const unsigned char c = static_cast<unsigned char>(*s++);
+ const unsigned char p = static_cast<unsigned char>(*prefix++);
+ if (std::tolower(c) != std::tolower(p)) {
+ return false;
+ }
+ }
+ return true;
+}
+} // namespace
+
+PersonalCenterModel::PersonalCenterModel()
+{
+ EnsureDefaultCarListUnlocked();
+ vehicleModelLine_ = "Uni-V";
+ parkStatusText_ = "已驻车";
+ rangeEvKm_ = "359";
+ rangeFuelKm_ = "120";
+ batteryPct_ = "86%";
+ fuelPct_ = "24%";
+ accountDisplayName_ = "我的账户";
+ accountPhone_ = "18600123456";
+}
+
+PersonalCenterModel *PersonalCenterModel::GetInstance()
+{
+ static PersonalCenterModel instance;
+ return &instance;
+}
+
+//确保默认车辆列表已解锁
+void PersonalCenterModel::EnsureDefaultCarListUnlocked()
+{
+ if (!carOptions_.empty()) {
+ return;
+ }
+ carOptions_ = {"Uni-V", "CS75 PLUS", "深蓝 SL03"};
+}
+
+//登录后加载持久化状态
+void PersonalCenterModel::LoadPersistedState()
+{
+ if (configLoaded_) {
+ return;
+ }
+ configLoaded_ = true;
+ onboardingCompleted_ = ConfigModel::GetInstance()->GetPersonalCenterOnboardingDone();
+}
+
+//登录后保存持久化状态
+void PersonalCenterModel::SavePersistedState()
+{
+ ConfigModel::GetInstance()->SetPersonalCenterOnboardingDone(onboardingCompleted_);
+}
+
+//检查是否完成新手引导
+bool PersonalCenterModel::IsOnboardingCompleted() const
+{
+ return onboardingCompleted_;
+}
+
+//标记新手引导完成
+void PersonalCenterModel::MarkOnboardingCompleted()
+{
+ if (onboardingCompleted_) {
+ return;
+ }
+ onboardingCompleted_ = true;
+ SavePersistedState();
+}
+
+//强制设置新手引导完成标志
+void PersonalCenterModel::ForceOnboardingFlagForTest(bool completed)
+{
+ onboardingCompleted_ = completed;
+ SavePersistedState();
+}
+
+//退出登录清除会话
+void PersonalCenterModel::LogoutClearSession()
+{
+ accountDisplayName_.clear();
+ accountPhone_.clear();
+ selectedCarIndex_ = 0;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterModel::LogoutClearSession");
+}
+
+//清除车辆列表
+void PersonalCenterModel::ClearCarOptions()
+{
+ carOptions_.clear();
+}
+
+//添加车辆
+void PersonalCenterModel::AddCarOption(const std::string &displayName)
+{
+ std::string n = displayName;
+ //去除空格
+ TrimInPlace(n);
+ if (n.empty()) {
+ return;
+ }
+ carOptions_.push_back(n);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterModel::AddCarOption %s", n.c_str());
+}
+
+//设置车辆列表用于测试
+void PersonalCenterModel::SetCarOptionsForTest(const std::vector<std::string> &names)
+{
+ carOptions_ = names;
+}
+
+//设置选中车辆
+void PersonalCenterModel::SetSelectedCarIndex(size_t index)
+{
+ if (!carOptions_.empty() && index < carOptions_.size()) {
+ selectedCarIndex_ = index;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterModel::SetSelectedCarIndex %zu %s", index,
+ carOptions_[index].c_str());
+ }
+}
+
+//刷新车辆状态快照
+void PersonalCenterModel::RefreshVehicleStatusSnapshot()
+{
+ if (!carOptions_.empty() && selectedCarIndex_ < carOptions_.size()) {
+ vehicleModelLine_ = carOptions_[selectedCarIndex_];
+ }
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterModel::RefreshVehicleStatusSnapshot model=%s",
+ vehicleModelLine_.c_str());
+}
+
+//设置车辆型号用于测试
+void PersonalCenterModel::SetVehicleModelLineForTest(const std::string &line)
+{
+ vehicleModelLine_ = line;
+ RefreshVehicleStatusSnapshot();
+}
+
+//设置账户信息用于测试
+void PersonalCenterModel::SetAccountProfile(const std::string &name, const std::string &phone)
+{
+ accountDisplayName_ = name;
+ accountPhone_ = phone;
+}
+
+//蓝牙车门开关
+void PersonalCenterModel::OnBluetoothCarGapAction(bool isOn)
+{
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterModel::OnBluetoothCarGapAction isOn=%d", isOn);
+}
+
+//蓝牙车门锁
+void PersonalCenterModel::OnBluetoothCarLockAction(bool isOn)
+{
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterModel::OnBluetoothCarLockAction isOn=%d", isOn);
+}
+
+//车辆控制按钮点击
+void PersonalCenterModel::OnCarControlButtonClicked(int buttonIndex, bool isOn)
+{
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterModel::OnCarControlButtonClicked idx=%d isOn=%d",
+ buttonIndex, isOn);
+ if (buttonIndex == 0) {
+ OnBluetoothCarGapAction(isOn);
+ } else if (buttonIndex == 1) {
+ OnBluetoothCarLockAction(isOn);
+ }
+}
+
+//处理AT命令
+void PersonalCenterModel::ProcessAtCommandLine(const char *line)
+{
+ if (line == nullptr) {
+ return;
+ }
+ while (*line == ' ' || *line == '\t') {
+ ++line;
+ }
+ if (StartsWithIgnoreCase(line, "AT+PCCAR=")) {
+ const char *v = line + 9;
+ PersonalCenterModel::GetInstance()->AddCarOption(std::string(v));
+ PersonalCenterView *pcv = PersonalCenterView::GetInstance();
+ if (pcv != nullptr) {
+ pcv->RefreshSelectCarListUi();
+ }
+ return;
+ }
+ if (StartsWithIgnoreCase(line, "AT+PCUSER=")) {
+ const char *v = line + 10;
+ std::string rest(v);
+ const auto comma = rest.find(',');
+ std::string name = (comma == std::string::npos) ? rest : rest.substr(0, comma);
+ std::string phone = (comma == std::string::npos) ? std::string() : rest.substr(comma + 1);
+ TrimInPlace(name);
+ TrimInPlace(phone);
+ PersonalCenterModel::GetInstance()->SetAccountProfile(name, phone);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AT+PCUSER name=%s phone=%s", name.c_str(), phone.c_str());
+ PersonalCenterView *pcv = PersonalCenterView::GetInstance();
+ if (pcv != nullptr) {
+ pcv->RefreshMyAccountUi();
+ }
+ return;
+ }
+ if (StartsWithIgnoreCase(line, "AT+PCMODEL=")) {
+ const char *v = line + 11;
+ PersonalCenterModel::GetInstance()->SetVehicleModelLineForTest(std::string(v));
+ PersonalCenterView *pcv = PersonalCenterView::GetInstance();
+ if (pcv != nullptr) {
+ pcv->RefreshVehicleDashboardUi();
+ }
+ return;
+ }
+ if (StartsWithIgnoreCase(line, "AT+PCONBOARD=")) {
+ const char *v = line + 13;
+ int x = std::atoi(v);
+ PersonalCenterModel::GetInstance()->ForceOnboardingFlagForTest(x != 0);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AT+PCONBOARD=%d", x);
+ return;
+ }
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterModel::ProcessAtCommandLine unknown: %s", line);
+}
+
+} // namespace OHOS
+
+extern "C" void uapi_personal_center_at_cmd(const char *line)
+{
+ OHOS::PersonalCenterModel::ProcessAtCommandLine(line);
+}
--- /dev/null
+#include "personal_center/include/PersonalCenterMyAccountView.h"
+#include "personal_center/include/PersonalCenterModel.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "personal_center/include/PersonalCenterUiConfig.h"
+#include "components/ui_view_group.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+#include <string>
+
+namespace OHOS
+{
+
+namespace
+{
+constexpr uint32_t PC_ACCOUNT_PILL_BG = 0xff33333d;
+constexpr int PC_ACCOUNT_PILL_H = 144;
+constexpr int PC_ACCOUNT_PILL_W = 440;
+constexpr int PC_ACCOUNT_PILL_X = 12;
+}
+
+PersonalCenterMyAccountView::PersonalCenterMyAccountView()
+{
+ SetViewIndex(static_cast<uint16_t>(PC_PAGE_MY_ACCOUNT));
+ SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+}
+
+PersonalCenterMyAccountView::~PersonalCenterMyAccountView() = default;
+
+bool PersonalCenterMyAccountView::InitView(void *caller)
+{
+ auto *pc = static_cast<PersonalCenterView *>(caller);
+ if (pc == nullptr) {
+ return false;
+ }
+
+ SetStyle(STYLE_BACKGROUND_COLOR, PC_BG_COLOR);
+ SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ SetTouchable(true);
+ SetDraggable(true);
+ SetOnDragListener(pc->GetUiDragListener());
+
+ int y = 36;
+ auto *title = new UILabel();
+ if (title != nullptr) {
+ title->SetPosition(0, y, 466, 48);
+ title->SetText("我的账户");
+ title->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ title->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 36);
+ title->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ Add(title);
+ }
+ y += 72;
+
+ auto *pillUser = new UIViewGroup();
+ if (pillUser != nullptr) {
+ pillUser->SetPosition(PC_ACCOUNT_PILL_X, y, PC_ACCOUNT_PILL_W, PC_ACCOUNT_PILL_H);
+ pillUser->SetStyle(STYLE_BACKGROUND_COLOR, PC_ACCOUNT_PILL_BG);
+ pillUser->SetStyle(STYLE_BORDER_RADIUS, PC_ACCOUNT_PILL_H / 2);
+ pillUser->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ Add(pillUser);
+ lblUserLine_ = new UILabel();
+ if (lblUserLine_ != nullptr) {
+ lblUserLine_->SetPosition(0, 0, PC_ACCOUNT_PILL_W, PC_ACCOUNT_PILL_H);
+ lblUserLine_->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ lblUserLine_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 28);
+ lblUserLine_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ pillUser->Add(lblUserLine_);
+ }
+ }
+ y += PC_ACCOUNT_PILL_H + 10;
+
+ auto *pillPhone = new UIViewGroup();
+ if (pillPhone != nullptr) {
+ pillPhone->SetPosition(PC_ACCOUNT_PILL_X, y, PC_ACCOUNT_PILL_W, PC_ACCOUNT_PILL_H);
+ pillPhone->SetStyle(STYLE_BACKGROUND_COLOR, PC_ACCOUNT_PILL_BG);
+ pillPhone->SetStyle(STYLE_BORDER_RADIUS, PC_ACCOUNT_PILL_H / 2);
+ pillPhone->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ Add(pillPhone);
+ lblPhoneLine_ = new UILabel();
+ if (lblPhoneLine_ != nullptr) {
+ lblPhoneLine_->SetPosition(0, 0, PC_ACCOUNT_PILL_W, PC_ACCOUNT_PILL_H);
+ lblPhoneLine_->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ lblPhoneLine_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 28);
+ lblPhoneLine_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ pillPhone->Add(lblPhoneLine_);
+ }
+ }
+
+ RefreshFromModel();
+ initViewStatus = true;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterMyAccountView::InitView ok");
+ return true;
+}
+
+void PersonalCenterMyAccountView::RefreshFromModel()
+{
+ PersonalCenterModel *m = PersonalCenterModel::GetInstance();
+ if (m == nullptr) {
+ return;
+ }
+ const std::string name = m->GetAccountDisplayName();
+ const std::string phone = m->GetAccountPhone();
+ const std::string userLine = std::string("用户名:") + (name.empty() ? "--" : name);
+ const std::string phoneLine = std::string("手机号:") + (phone.empty() ? "--" : phone);
+ if (lblUserLine_ != nullptr) {
+ lblUserLine_->SetText(userLine.c_str());
+ lblUserLine_->Invalidate();
+ }
+ if (lblPhoneLine_ != nullptr) {
+ lblPhoneLine_->SetText(phoneLine.c_str());
+ lblPhoneLine_->Invalidate();
+ }
+}
+
+} // namespace OHOS
--- /dev/null
+/*
+ * @file PersonalCenterPresenter.cpp
+ * @brief 个人中心业务 Presenter。单例指针 `g_pPersonalCenterPresenter`:构造 `= this`,析构 `= nullptr`(与 phone 一致)。
+ */
+#include "personal_center/include/PersonalCenterPresenter.h"
+#include "personal_center/include/PersonalCenterModel.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "personal_center/include/PersonalCenterCarHubView.h"
+#include "personal_center/include/PersonalCenterCarControlView.h"
+#include "personal_center/include/PersonalCenterRemoteControlView.h"
+#include "AppViewIDs.h"
+#include "NativeAbility.h"
+#include "NativeRegisterManager.h"
+#include "TransitionType.h"
+#include "UiConfig.h"
+#include "common/key_code.h"
+#include "components/root_view.h"
+#include "custom_utils.h"
+#include "drag_event.h"
+#include "gfx_utils/graphic_math.h"
+#include "ohos_types.h"
+#include "ui_resource_string.h"
+#include "wearable_log.h"
+#include <cstdio>
+#include <cstring>
+
+namespace OHOS
+{
+
+REGIST_MENU_PRO(VIEW_PERSONAL_CENTER, PersonalCenterView, PersonalCenterPresenter,
+ PNG_APPLIST_BLUETOOTH_IMAGE_BIG, PNG_APPLIST_BLUETOOTH_IMAGE, PNG_APPLIST_BLUETOOTH_IMAGE, "蓝牙",
+ STR_BLUETOOTH);
+
+namespace
+{
+PersonalCenterPresenter *g_pPersonalCenterPresenter{nullptr};
+
+/** 离开个人中心 Slice,回到应用列表 */
+void ExitPersonalCenterToAppList()
+{
+ NativeAbility::GetInstance().ChangeSlice(VIEW_APPLIST, TransitionType::TRANSITION_INVALID);
+}
+
+/** OnDragEnd 时排除以竖向为主的手势,避免列表上下滑被当成侧滑从而误跳「关于」等纵向页 */
+bool IsPrimarilyHorizontalDrag(const DragEvent &event)
+{
+ constexpr int kMin = 50;
+ constexpr double kRatio = 2.0;
+ const Point &s = event.GetStartPoint();
+ const Point &cur = event.GetCurrentPos();
+ const int tx = MATH_ABS(cur.x - s.x);
+ const int ty = MATH_ABS(cur.y - s.y);
+ return tx > kMin && tx > static_cast<int>(kRatio * ty);
+}
+} // namespace
+
+PersonalCenterPresenter::PersonalCenterPresenter()
+{
+ g_pPersonalCenterPresenter = this;
+}
+
+PersonalCenterPresenter::~PersonalCenterPresenter()
+{
+ g_pPersonalCenterPresenter = nullptr;
+}
+
+PersonalCenterPresenter *PersonalCenterPresenter::GetInstance(void)
+{
+ return g_pPersonalCenterPresenter;
+}
+
+void PersonalCenterPresenter::ResetSwipeExitSuppression()
+{
+ suppressNextMainMenuSwipeExit_ = false;
+ dragFlag_ = false;
+ dragRtlFlag_ = false;
+}
+
+void PersonalCenterPresenter::OnStart()
+{
+ Presenter<PersonalCenterView>::OnStart();
+}
+
+void PersonalCenterPresenter::OnPause()
+{
+ Presenter<PersonalCenterView>::OnPause();
+}
+
+void PersonalCenterPresenter::OnResume()
+{
+ Presenter<PersonalCenterView>::OnResume();
+ if (view_ != nullptr) {
+ view_->ApplyPendingMainMenuIfAny();
+ }
+ RootView::GetInstance()->SetOnKeyActListener(this);
+}
+
+void PersonalCenterPresenter::OnStop()
+{
+ Presenter<PersonalCenterView>::OnStop();
+}
+
+bool PersonalCenterPresenter::OnKeyAct(UIView &view, const KeyEvent &event)
+{
+ UNUSED(view);
+ uint16_t keyID = event.GetKeyId();
+ uint16_t keyState = event.GetState();
+ if (keyID == static_cast<uint16_t>(ZliteKeyCode::ZLITE_KEY_POWER) && keyState == 1 && uapi_get_screen_state() == 0) {
+ NativeAbility::GetInstance().Back();
+ }
+ return true;
+}
+
+/**
+ * 统一处理个人中心内所有按钮 ViewId:声明/登录/选车/Hub 菜单/关于等。
+ * Hub 内车控按键先按当前横向 tab 交给「蓝牙六键」或「远程四键」视图尝试吞噬,再兜底走菜单 ID。
+ */
+bool PersonalCenterPresenter::OnClick(UIView &view, const ClickEvent &event)
+{
+ UNUSED(event);
+ if (view_ == nullptr) {
+ return true;
+ }
+ const char *vid = view.GetViewId();
+ if (vid == nullptr) {
+ return true;
+ }
+ PersonalCenterCarHubView *hub = view_->GetCarHubPage();
+ if (view_->GetSwipeIndex() == PC_PAGE_CAR_HUB && hub != nullptr) {
+ const uint16_t hi = hub->GetHorizontalIndex();
+ if (hi == 0) {
+ PersonalCenterCarControlView *bt = hub->GetBluetoothTab();
+ if (bt != nullptr && bt->TryHandleCarButtonClick(vid)) {
+ return true;
+ }
+ } else if (hi == 2) {
+ PersonalCenterRemoteControlView *rm = hub->GetRemoteTab();
+ if (rm != nullptr && rm->TryHandleCarButtonClick(vid)) {
+ return true;
+ }
+ }
+ }
+ if (strcmp(vid, "PcdCancel") == 0) {
+ ExitPersonalCenterToAppList();
+ return true;
+ }
+ if (strcmp(vid, "PcdConfirm") == 0) {
+ view_->GoLoginPage(false);
+ return true;
+ }
+ if (strncmp(vid, "PcCar", 5) == 0) {
+ unsigned idx = 0;
+ if (sscanf(vid + 5, "%u", &idx) == 1) {
+ PersonalCenterModel *model = PersonalCenterModel::GetInstance();
+ model->SetSelectedCarIndex(static_cast<size_t>(idx));
+ /* 把车款名写入车况模型(后续可在此扩展为按车型拉 TSP 详情) */
+ model->RefreshVehicleStatusSnapshot();
+ /* 进入车联 Hub「车况」页并刷新文案 = 当前选中车型的信息 */
+ view_->GoCarDashboardPage(false);
+ view_->RefreshVehicleDashboardUi();
+ return true;
+ }
+ }
+ if (strcmp(vid, "PcMyVehicle") == 0) {
+ view_->GoLoginFlowPage(false, false);
+ return true;
+ }
+ if (strcmp(vid, "PcGoSelectCar") == 0) {
+ if (view_->GetSwipeIndex() == PC_PAGE_LOGIN) {
+ PersonalCenterModel::GetInstance()->MarkOnboardingCompleted();
+ }
+ view_->GoSelectCarPage(false);
+ return true;
+ }
+ if (strcmp(vid, "PcKeySettings") == 0) {
+ view_->GoKeyModePage(false);
+ return true;
+ }
+ if (strcmp(vid, "PcAbout") == 0) {
+ view_->GoAboutPage(false);
+ return true;
+ }
+ if (strcmp(vid, "PcMyAccount") == 0) {
+ view_->GoMyAccountPage(false);
+ return true;
+ }
+ if (strcmp(vid, "PcLogout") == 0) {
+ PersonalCenterModel::GetInstance()->LogoutClearSession();
+ view_->GoLoginPage(false);
+ return true;
+ }
+ if (strcmp(vid, "PcClearCache") == 0) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenter: click PcClearCache (stub)");
+ }
+ if (strcmp(vid, "PcCarDashboardRefresh") == 0) {
+ view_->RefreshVehicleDashboardUi();
+ return true;
+ }
+ return true;
+}
+
+/**
+ * 横滑手势预处理:记录是否偏「左→右」或「右→左」,供 OnDragEnd 判断是否触发返回/退出。
+ * 在 PC_PAGE_CAR_HUB 固定返回 false,避免阻断子层横向 UISwipeView 接收拖拽。
+ */
+bool PersonalCenterPresenter::OnDrag(UIView &view, const DragEvent &event)
+{
+ UNUSED(view);
+ if (view_ == nullptr) {
+ return true;
+ }
+ if (view_->GetSwipeIndex() == PC_PAGE_CAR_HUB) {
+ /* 车联 Hub 内不按纵向栈侧滑语义累计,避免与列表竖滑串台 */
+ dragFlag_ = false;
+ dragRtlFlag_ = false;
+ return false;
+ }
+ if ((event.GetDeltaX() > kDragOffset) && (event.GetDeltaX() > (kDragRatio * MATH_ABS(event.GetDeltaY())))) {
+ dragFlag_ = true;
+ }
+ if ((event.GetDeltaX() < -kDragOffset) &&
+ (-event.GetDeltaX() > (kDragRatio * MATH_ABS(event.GetDeltaY())))) {
+ dragRtlFlag_ = true;
+ }
+ return true;
+}
+
+/**
+ * 侧滑结束:Hub 页只做清标记并返回 false(横向切 tab 由 Hub 内 UISwipeView 处理)。
+ * 非 Hub:LTR 在关于/钥匙页回主菜单(Hub tab3),其余页在非农表入口时退出到应用列表;
+ * RTL 在来自秒表时 Back,或与 suppress 标记组合跳转车况(预留)。
+ */
+bool PersonalCenterPresenter::OnDragEnd(UIView &view, const DragEvent &event)
+{
+ UNUSED(view);
+ if (view_ == nullptr) {
+ return true;
+ }
+ const uint16_t idx = view_->GetSwipeIndex();
+ if (idx == PC_PAGE_CAR_HUB) {
+ dragFlag_ = false;
+ dragRtlFlag_ = false;
+ return false;
+ }
+
+ if (event.GetDragDirection() == DragEvent::DIRECTION_LEFT_TO_RIGHT && dragFlag_) {
+ if (!IsPrimarilyHorizontalDrag(event)) {
+ dragFlag_ = false;
+ dragRtlFlag_ = false;
+ return true;
+ }
+ dragFlag_ = false;
+ dragRtlFlag_ = false;
+ const uint16_t pageIdx = view_->GetSwipeIndex();
+ if (pageIdx == PC_PAGE_KEY_MODE) {
+ view_->GoMainPage(false);
+ } else if (pageIdx == PC_PAGE_ABOUT || pageIdx == PC_PAGE_MY_ACCOUNT) {
+ view_->GoMainPage(false);
+ } else {
+ const uint16_t pre = NativeAbility::GetInstance().GetPreSliceId();
+ if (pre != VIEW_MAIN_STOPWATCH && !suppressNextMainMenuSwipeExit_) {
+ ExitPersonalCenterToAppList();
+ }
+ }
+ } else if (event.GetDragDirection() == DragEvent::DIRECTION_RIGHT_TO_LEFT && dragRtlFlag_) {
+ if (!IsPrimarilyHorizontalDrag(event)) {
+ dragFlag_ = false;
+ dragRtlFlag_ = false;
+ return true;
+ }
+ dragFlag_ = false;
+ dragRtlFlag_ = false;
+ if (suppressNextMainMenuSwipeExit_) {
+ suppressNextMainMenuSwipeExit_ = false;
+ view_->GoCarDashboardPage(false);
+ } else if (NativeAbility::GetInstance().GetPreSliceId() == VIEW_MAIN_STOPWATCH) {
+ NativeAbility::GetInstance().Back(TransitionType::TRANSITION_INVALID);
+ }
+ } else {
+ dragFlag_ = false;
+ dragRtlFlag_ = false;
+ }
+ return true;
+}
+
+} // namespace OHOS
--- /dev/null
+#include "personal_center/include/PersonalCenterRemoteControlView.h"
+#include "personal_center/include/PersonalCenterCarUiConstants.h"
+#include "personal_center/include/PersonalCenterUiConfig.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "UiConfig.h"
+#include "common/image_cache_manager.h"
+#include "wearable_log.h"
+#include <cstring>
+
+namespace OHOS
+{
+
+/* 远程页用刷新图标表示已连接状态区(与效果图一致可换资源) */
+static const char *REMOTE_REFRESH_IMG = CAR_CTRL_BT_ICON_IMG;
+
+PersonalCenterRemoteControlView::PersonalCenterRemoteControlView()
+{
+ SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+}
+
+UILabelButtonExt *PersonalCenterRemoteControlView::MakeBtn(int x, int y, int index,
+ UIView::OnClickListener *clickListener)
+{
+ UILabelButtonExt *button = new UILabelButtonExt();
+ if (button == nullptr) {
+ return nullptr;
+ }
+ button->SetPosition(x, y, CAR_CTRL_BTN_SIZE, CAR_CTRL_BTN_SIZE);
+ button->SetViewId(CAR_CTRL_BTN_VIEWID[index]);
+ button->SetStyle(STYLE_BACKGROUND_COLOR, CAR_CTRL_BTN_BG_COLOR);
+ button->SetStyle(STYLE_BORDER_RADIUS, 25);
+ button->SetImagePosition(26, 8);
+ ImageInfo *img = ImageCacheManager::GetInstance().LoadSingleRes(g_carCtrlBtnStates[index].imgOff);
+ button->SetImageSrc(img, img);
+ button->SetLabelPosition(0, 107);
+ button->SetText(g_carCtrlBtnStates[index].textOff);
+ button->SetAlign(TEXT_ALIGNMENT_CENTER);
+ button->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 27);
+ button->SetStyle(STYLE_LINE_HEIGHT, CAR_CTRL_TEXT_H);
+ button->SetStyleForState(STYLE_BACKGROUND_OPA, 0x00, UIButton::PRESSED);
+ button->SetStyleForState(STYLE_BORDER_RADIUS, CAR_CTRL_BTN_SIZE / 2, UIButton::PRESSED);
+ if (clickListener != nullptr) {
+ button->SetOnClickListener(clickListener);
+ }
+ return button;
+}
+
+bool PersonalCenterRemoteControlView::TryHandleCarButtonClick(const char *viewId)
+{
+ if (viewId == nullptr) {
+ return false;
+ }
+ for (int i = 0; i < 4; i++) {
+ if (strcmp(viewId, CAR_CTRL_BTN_VIEWID[i]) == 0) {
+ btnState_[i] = !btnState_[i];
+ const CarCtrlButtonState &s = g_carCtrlBtnStates[i];
+ UILabelButtonExt *b = btn_[i];
+ if (b != nullptr) {
+ ImageInfo *img = ImageCacheManager::GetInstance().LoadSingleRes(
+ btnState_[i] ? s.imgOn : s.imgOff);
+ b->SetImageSrc(img, img);
+ b->SetText(btnState_[i] ? s.textOn : s.textOff);
+ b->Invalidate();
+ }
+ return true;
+ }
+ }
+ return false;
+}
+
+bool PersonalCenterRemoteControlView::InitView(void *caller)
+{
+ auto *pc = static_cast<PersonalCenterView *>(caller);
+ if (pc == nullptr) {
+ return false;
+ }
+
+ SetStyle(STYLE_BACKGROUND_COLOR, CAR_CTRL_BG_COLOR);
+ SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ SetTouchable(true);
+ SetDraggable(true);
+ SetOnDragListener(pc->GetUiDragListener());
+
+ titleLabel_ = new UILabel();
+ if (titleLabel_ != nullptr) {
+ titleLabel_->SetPosition(0, 21, 466, 48);
+ titleLabel_->SetText("远程控车");
+ titleLabel_->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ titleLabel_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 35);
+ titleLabel_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ Add(titleLabel_);
+ }
+
+ statusLabel_ = new UILabel();
+ if (statusLabel_ != nullptr) {
+ statusLabel_->SetPosition(172, 70, 81, 27);
+ statusLabel_->SetText("已连接");
+ statusLabel_->SetStyle(STYLE_TEXT_COLOR, 0xff4fc3f7);
+ statusLabel_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 27);
+ statusLabel_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ Add(statusLabel_);
+ }
+
+ refreshIcon_ = new UIImageView();
+ if (refreshIcon_ != nullptr) {
+ refreshIcon_->SetPosition(263, 65, 34, 34);
+ refreshIcon_->SetSrc(REMOTE_REFRESH_IMG);
+ Add(refreshIcon_);
+ }
+
+ int gap = 20;
+ int gapY = 9;
+ int startX = 79;
+ int startY = 104;
+ for (int i = 0; i < 4; i++) {
+ int col = i % 2;
+ int row = i / 2;
+ int x = startX + col * (CAR_CTRL_BTN_SIZE + gap);
+ int y = startY + row * (CAR_CTRL_BTN_SIZE + gapY);
+ btn_[i] = MakeBtn(x, y, i, pc->GetUiClickListener());
+ if (btn_[i] != nullptr) {
+ Add(btn_[i]);
+ }
+ }
+
+ SetPosition(0, 0, 466, 466);
+ initViewStatus = true;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterRemoteControlView::InitView ok");
+ return true;
+}
+
+} // namespace OHOS
--- /dev/null
+#include "personal_center/include/PersonalCenterSelectCarView.h"
+#include "personal_center/include/PersonalCenterModel.h"
+#include "personal_center/include/PersonalCenterView.h"
+#include "personal_center/include/PersonalCenterUiConfig.h"
+#include "personal_center/include/PersonalCenterUiScroll.h"
+#include "components/ui_label.h"
+#include "components/ui_label_button.h"
+#include "components/ui_view_group.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+#include <cstdio>
+
+namespace OHOS
+{
+
+namespace
+{
+constexpr int kCarListTop = 140;
+}
+
+PersonalCenterSelectCarView::PersonalCenterSelectCarView()
+{
+ SetViewIndex(static_cast<uint16_t>(PC_PAGE_SELECT_CAR));
+ SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+}
+
+PersonalCenterSelectCarView::~PersonalCenterSelectCarView()
+{
+ carButtons_.clear();
+}
+
+void PersonalCenterSelectCarView::RebuildCarList(PersonalCenterView *pc)
+{
+ if (carListHost_ == nullptr || scroll_ == nullptr || pc == nullptr) {
+ return;
+ }
+ for (auto *b : carButtons_) {
+ if (b != nullptr) {
+ carListHost_->Remove(b);
+ delete b;
+ }
+ }
+ carButtons_.clear();
+
+ UIView::OnClickListener *onClick = pc->GetUiClickListener();
+ PersonalCenterModel *model = PersonalCenterModel::GetInstance();
+ const std::vector<std::string> &opts =
+ (model != nullptr) ? model->GetCarOptions() : std::vector<std::string>();
+
+ int y = 0;
+ for (size_t i = 0; i < opts.size(); ++i) {
+ auto *b = new UILabelButton();
+ if (b == nullptr) {
+ continue;
+ }
+ char vid[24];
+ (void)snprintf(vid, sizeof(vid), "PcCar%zu", i);
+ b->SetPosition(18, y, PC_BTN_W, PC_BTN_H);
+ b->SetViewId(vid);
+ b->SetStyle(STYLE_BACKGROUND_COLOR, PC_BTN_BG_COLOR);
+ b->SetStyle(STYLE_BORDER_RADIUS, 100);
+ b->SetText(opts[i].c_str());
+ b->SetFont(DEFAULT_VECTOR_FONT_FILENAME, PC_BTN_FONT);
+ b->SetAlign(TEXT_ALIGNMENT_CENTER);
+ b->SetOnClickListener(onClick);
+ carListHost_->Add(b);
+ carButtons_.push_back(b);
+ y += PC_BTN_H + PC_BTN_GAP;
+ }
+
+ const int hostH = (y > 0) ? (y - PC_BTN_GAP) : PC_BTN_H;
+ carListHost_->SetPosition(0, kCarListTop, 466, hostH);
+ if (spacer_ != nullptr) {
+ spacer_->SetPosition(0, kCarListTop + hostH + 40, 1, 200);
+ }
+ scroll_->Invalidate();
+}
+
+bool PersonalCenterSelectCarView::InitView(void *caller)
+{
+ auto *pc = static_cast<PersonalCenterView *>(caller);
+ if (pc == nullptr) {
+ return false;
+ }
+
+ SetPosition(0, 0, 466, 466);
+ SetStyle(STYLE_BACKGROUND_COLOR, PC_BG_COLOR);
+ SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ SetTouchable(true);
+ SetDraggable(true);
+ SetOnDragListener(pc->GetUiDragListener());
+
+ scroll_ = new UIScrollView();
+ if (scroll_ == nullptr) {
+ return false;
+ }
+ scroll_->SetPosition(0, 0, 466, 466);
+ scroll_->SetStyle(STYLE_BACKGROUND_COLOR, PC_BG_COLOR);
+ scroll_->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ scroll_->SetTouchable(true);
+ scroll_->SetDraggable(true);
+ scroll_->SetOnDragListener(pc->GetUiDragListener());
+ PcApplyVerticalScrollBehavior(scroll_, 2000);
+ scroll_->RequestFocus();
+
+ auto *lblCarTitle = new UILabel();
+ if (lblCarTitle != nullptr) {
+ lblCarTitle->SetPosition(0, 29, 466, 44);
+ lblCarTitle->SetText("选车");
+ lblCarTitle->SetStyle(STYLE_TEXT_COLOR, 0xffffffff);
+ lblCarTitle->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 34);
+ lblCarTitle->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ scroll_->Add(lblCarTitle);
+ }
+
+ auto *lblSub = new UILabel();
+ if (lblSub != nullptr) {
+ lblSub->SetPosition(0, 86, 466, 36);
+ lblSub->SetText("我的汽车");
+ lblSub->SetStyle(STYLE_TEXT_COLOR, 0xff888888);
+ lblSub->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 24);
+ lblSub->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ scroll_->Add(lblSub);
+ }
+
+ carListHost_ = new UIViewGroup();
+ if (carListHost_ == nullptr) {
+ return false;
+ }
+ carListHost_->SetStyle(STYLE_BACKGROUND_OPA, 0);
+ scroll_->Add(carListHost_);
+
+ spacer_ = new UIViewGroup();
+ if (spacer_ != nullptr) {
+ spacer_->SetPosition(0, 608, 1, 200);
+ spacer_->SetStyle(STYLE_BACKGROUND_OPA, 0);
+ scroll_->Add(spacer_);
+ }
+
+ Add(scroll_);
+ RebuildCarList(pc);
+
+ initViewStatus = true;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterSelectCarView::InitView ok");
+ return true;
+}
+
+} // namespace OHOS
--- /dev/null
+/*
+ * @file PersonalCenterView.cpp
+ * @brief 个人中心根视图:单例与 UI 树创建方式对齐 phone/DialingMethodView。
+ *
+ * 纵向导航仅用普通 UIViewGroup 叠放全屏子页 + SetVisible 切换(无纵向 UISwipeView),避免误触换页。
+ * Hub 内横向 UISwipeView 仍在 PersonalCenterCarHubView。
+ */
+#include "personal_center/include/PersonalCenterView.h"
+#include "personal_center/include/PersonalCenterLoginView.h"
+#include "personal_center/include/PersonalCenterSelectCarView.h"
+#include "personal_center/include/PersonalCenterCarHubView.h"
+#include "personal_center/include/PersonalCenterMyAccountView.h"
+#include "personal_center/include/PersonalCenterCarDashboardView.h"
+#include "personal_center/include/PersonalCenterModel.h"
+#include "personal_center/include/PersonalCenterUiConfig.h"
+#include "wearable_log.h"
+
+
+namespace OHOS
+{
+
+namespace
+{
+PersonalCenterView *g_pPersonalCenterView{nullptr};
+} // namespace
+
+bool PersonalCenterView::showMainMenuPending_{false};
+
+PersonalCenterView::PersonalCenterView()
+{
+ g_pPersonalCenterView = this;
+}
+
+PersonalCenterView::~PersonalCenterView()
+{
+ ClearAll();
+ g_pPersonalCenterView = nullptr;
+}
+
+PersonalCenterView *PersonalCenterView::GetInstance(void)
+{
+ return g_pPersonalCenterView;
+}
+
+UIView::OnClickListener *PersonalCenterView::GetUiClickListener()
+{
+ return static_cast<UIView::OnClickListener *>(presenter_);
+}
+
+UIView::OnDragListener *PersonalCenterView::GetUiDragListener()
+{
+ return static_cast<UIView::OnDragListener *>(presenter_);
+}
+
+PersonalCenterCarHubView *PersonalCenterView::GetCarHubPage()
+{
+ return static_cast<PersonalCenterCarHubView *>(pages_[PC_PAGE_CAR_HUB]);
+}
+
+void PersonalCenterView::RequestShowMainMenuOnNextActivate()
+{
+ showMainMenuPending_ = true;
+}
+
+void PersonalCenterView::ApplyPendingMainMenuIfAny()
+{
+ if (!showMainMenuPending_) {
+ return;
+ }
+ showMainMenuPending_ = false;
+ if (pages_[PC_PAGE_CAR_HUB] != nullptr) {
+ GoCarHubPage(false, 0);
+ }
+}
+
+void PersonalCenterView::ClearAll(void)
+{
+ for (int32_t i = 0; i < PC_MAX_PAGE; i++) {
+ AppGroupView *pageGroup = pages_[i];
+ if (pageGroup != nullptr) {
+ if (group_ != nullptr) {
+ group_->Remove(pageGroup);
+ }
+ /* UICardPage/AppGroupView 继承 UIViewGroup;API 要求 UIViewGroup*& */
+ UIViewGroup *pageRoot = pageGroup;
+ UIViewGroup::RemoveAndDeleteAllRecursively(pageRoot);
+ pages_[i] = nullptr;
+ }
+ }
+ currentPageIndex_ = 0;
+ if (group_ != nullptr) {
+ /* 删除前必须先 Remove,否则 ~UIView 在 parent_!=nullptr 时会报错(StopSlice 时刷屏) */
+ UIView *parentOfGroup = group_->GetParent();
+ if (parentOfGroup != nullptr && parentOfGroup->IsViewGroup()) {
+ static_cast<UIViewGroup *>(parentOfGroup)->Remove(group_);
+ }
+ delete group_;
+ group_ = nullptr;
+ }
+}
+
+AppGroupView *PersonalCenterView::PageDisclaimerInit()
+{
+ return new PersonalCenterDisclaimerView();
+}
+
+AppGroupView *PersonalCenterView::PageLoginInit()
+{
+ return new PersonalCenterLoginView();
+}
+
+AppGroupView *PersonalCenterView::PageSelectCarInit()
+{
+ return new PersonalCenterSelectCarView();
+}
+
+AppGroupView *PersonalCenterView::PageCarHubInit()
+{
+ return new PersonalCenterCarHubView();
+}
+
+AppGroupView *PersonalCenterView::PageAboutInit()
+{
+ return new PersonalCenterAboutView();
+}
+
+AppGroupView *PersonalCenterView::PageKeyModeInit()
+{
+ return new PersonalCenterKeyModeView();
+}
+
+AppGroupView *PersonalCenterView::PageMyAccountInit()
+{
+ return new PersonalCenterMyAccountView();
+}
+
+AppGroupView *PersonalCenterView::CreatePage(uint8_t pageId)
+{
+ switch (static_cast<PersonalCenterPageIndex>(pageId)) {
+ case PC_PAGE_DISCLAIMER:
+ return PageDisclaimerInit();
+ case PC_PAGE_LOGIN:
+ return PageLoginInit();
+ case PC_PAGE_SELECT_CAR:
+ return PageSelectCarInit();
+ case PC_PAGE_CAR_HUB:
+ return PageCarHubInit();
+ case PC_PAGE_ABOUT:
+ return PageAboutInit();
+ case PC_PAGE_KEY_MODE:
+ return PageKeyModeInit();
+ case PC_PAGE_MY_ACCOUNT:
+ return PageMyAccountInit();
+ default:
+ return nullptr;
+ }
+}
+
+void PersonalCenterView::SetVerticalPage(uint16_t index, bool needAnimator)
+{
+ (void)needAnimator;
+ if (index >= PC_MAX_PAGE || pages_[index] == nullptr) {
+ return;
+ }
+ const uint16_t prev = currentPageIndex_;
+ for (uint16_t i = 0; i < PC_MAX_PAGE; i++) {
+ if (pages_[i] != nullptr) {
+ pages_[i]->SetVisible(i == index);
+ }
+ }
+ currentPageIndex_ = index;
+
+ if (prev == PC_PAGE_LOGIN && index != PC_PAGE_LOGIN) {
+ auto *login = static_cast<PersonalCenterLoginView *>(pages_[PC_PAGE_LOGIN]);
+ if (login != nullptr) {
+ login->OnLoginPageBecameHidden();
+ }
+ } else if (index == PC_PAGE_LOGIN && prev != PC_PAGE_LOGIN) {
+ auto *login = static_cast<PersonalCenterLoginView *>(pages_[PC_PAGE_LOGIN]);
+ if (login != nullptr) {
+ login->OnLoginPageBecameVisible();
+ }
+ }
+}
+
+bool PersonalCenterView::BuildPageStack(void)
+{
+ if (group_ == nullptr) {
+ return false;
+ }
+ if (pages_[PC_PAGE_DISCLAIMER] != nullptr) {
+ return true;
+ }
+
+ PersonalCenterModel::GetInstance()->LoadPersistedState();
+
+ for (uint16_t i = 0; i < PC_MAX_PAGE; i++) {
+ pages_[i] = CreatePage(static_cast<uint8_t>(i));
+ if (pages_[i] == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "personal center page[%u] null", i);
+ return false;
+ }
+ if (!pages_[i]->InitView(this)) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "personal center InitView fail page %u", i);
+ return false;
+ }
+ pages_[i]->SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+ pages_[i]->SetVisible(false);
+ group_->Add(pages_[i]);
+ }
+
+ const bool pendingMenu = showMainMenuPending_;
+ const bool onboarded = PersonalCenterModel::GetInstance()->IsOnboardingCompleted();
+ const uint16_t initialPage =
+ pendingMenu ? PC_PAGE_CAR_HUB : (onboarded ? PC_PAGE_CAR_HUB : PC_PAGE_DISCLAIMER);
+ SetVerticalPage(initialPage, false);
+ if (pendingMenu) {
+ showMainMenuPending_ = false;
+ auto *hub = static_cast<PersonalCenterCarHubView *>(pages_[PC_PAGE_CAR_HUB]);
+ if (hub != nullptr) {
+ hub->SetHorizontalIndex(3, false);
+ }
+ } else if (onboarded) {
+ /* 非首次进入:落在车联 Hub 的「蓝牙钥匙」Tab,而非关于页 */
+ auto *hub = static_cast<PersonalCenterCarHubView *>(pages_[PC_PAGE_CAR_HUB]);
+ if (hub != nullptr) {
+ hub->SetHorizontalIndex(0, false);
+ }
+ }
+ return true;
+}
+
+void PersonalCenterView::PersonalCenterViewInit(void)
+{
+ UIView::OnDragListener *dragListener = GetUiDragListener();
+
+ if (group_ == nullptr) {
+ group_ = new UIViewGroup();
+ if (group_ == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenter group new fail");
+ return;
+ }
+ group_->SetPosition(0, 0, PC_SCREEN_W, PC_SCREEN_H);
+ group_->SetStyle(STYLE_BACKGROUND_COLOR, PC_BG_COLOR);
+ group_->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ group_->SetTouchable(true);
+ group_->SetDraggable(true);
+ group_->SetOnDragListener(dragListener);
+ }
+
+ AddViewToRootContainer(group_);
+
+ if (!BuildPageStack()) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PersonalCenter BuildPageStack fail");
+ return;
+ }
+
+ ApplyPendingMainMenuIfAny();
+}
+
+void PersonalCenterView::GoLoginPage(bool needAnimator)
+{
+ if (presenter_ != nullptr) {
+ presenter_->ResetSwipeExitSuppression();
+ }
+ SetVerticalPage(PC_PAGE_LOGIN, needAnimator);
+}
+
+void PersonalCenterView::GoSelectCarPage(bool needAnimator)
+{
+ if (presenter_ != nullptr) {
+ presenter_->ResetSwipeExitSuppression();
+ }
+ SetVerticalPage(PC_PAGE_SELECT_CAR, needAnimator);
+}
+
+void PersonalCenterView::GoLoginFlowPage(bool needAnimator, bool startAtLogin)
+{
+ if (startAtLogin) {
+ GoLoginPage(needAnimator);
+ } else {
+ GoSelectCarPage(needAnimator);
+ }
+}
+
+void PersonalCenterView::GoCarHubPage(bool needAnimator, uint16_t tab)
+{
+ if (presenter_ != nullptr) {
+ presenter_->ResetSwipeExitSuppression();
+ }
+ SetVerticalPage(PC_PAGE_CAR_HUB, needAnimator);
+ auto *hub = static_cast<PersonalCenterCarHubView *>(pages_[PC_PAGE_CAR_HUB]);
+ if (hub != nullptr) {
+ hub->SetHorizontalIndex(tab, needAnimator);
+ }
+}
+
+void PersonalCenterView::GoMainPage(bool needAnimator)
+{
+ GoCarHubPage(needAnimator, 3);
+}
+
+void PersonalCenterView::GoAboutPage(bool needAnimator)
+{
+ if (presenter_ != nullptr) {
+ presenter_->ResetSwipeExitSuppression();
+ }
+ SetVerticalPage(PC_PAGE_ABOUT, needAnimator);
+}
+
+void PersonalCenterView::GoKeyModePage(bool needAnimator)
+{
+ if (presenter_ != nullptr) {
+ presenter_->ResetSwipeExitSuppression();
+ }
+ SetVerticalPage(PC_PAGE_KEY_MODE, needAnimator);
+ if (pages_[PC_PAGE_KEY_MODE] != nullptr) {
+ auto *km = static_cast<PersonalCenterKeyModeView *>(pages_[PC_PAGE_KEY_MODE]);
+ km->RefreshToggles();
+ }
+}
+
+void PersonalCenterView::GoMyAccountPage(bool needAnimator)
+{
+ if (presenter_ != nullptr) {
+ presenter_->ResetSwipeExitSuppression();
+ }
+ SetVerticalPage(PC_PAGE_MY_ACCOUNT, needAnimator);
+ if (pages_[PC_PAGE_MY_ACCOUNT] != nullptr) {
+ auto *acc = static_cast<PersonalCenterMyAccountView *>(pages_[PC_PAGE_MY_ACCOUNT]);
+ if (acc != nullptr) {
+ acc->RefreshFromModel();
+ }
+ }
+}
+
+void PersonalCenterView::GoDisclaimerPage(bool needAnimator)
+{
+ if (presenter_ != nullptr) {
+ presenter_->ResetSwipeExitSuppression();
+ }
+ SetVerticalPage(PC_PAGE_DISCLAIMER, needAnimator);
+}
+
+void PersonalCenterView::GoCarControlPage(bool needAnimator)
+{
+ GoCarHubPage(needAnimator, 0);
+}
+
+void PersonalCenterView::GoCarDashboardPage(bool needAnimator)
+{
+ GoCarHubPage(needAnimator, 1);
+}
+
+uint16_t PersonalCenterView::GetSwipeIndex() const
+{
+ return currentPageIndex_;
+}
+
+//刷新选车列表
+void PersonalCenterView::RefreshSelectCarListUi()
+{
+ if (pages_[PC_PAGE_SELECT_CAR] == nullptr) {
+ return;
+ }
+ auto *sel = static_cast<PersonalCenterSelectCarView *>(pages_[PC_PAGE_SELECT_CAR]);
+ if (sel != nullptr) {
+ sel->RebuildCarList(this);
+ }
+}
+
+//刷新车辆仪表盘
+void PersonalCenterView::RefreshVehicleDashboardUi()
+{
+ PersonalCenterCarHubView *hub = GetCarHubPage();
+ if (hub == nullptr) {
+ return;
+ }
+ auto *dash = hub->GetDashboardTab();
+ if (dash != nullptr) {
+ dash->ApplyVehicleLabelsFromModel();
+ }
+}
+
+//刷新我的账户
+void PersonalCenterView::RefreshMyAccountUi()
+{
+ if (pages_[PC_PAGE_MY_ACCOUNT] == nullptr) {
+ return;
+ }
+ auto *acc = static_cast<PersonalCenterMyAccountView *>(pages_[PC_PAGE_MY_ACCOUNT]);
+ if (acc != nullptr) {
+ acc->RefreshFromModel();
+ }
+}
+
+void PersonalCenterView::OnStart()
+{
+ PersonalCenterViewInit();
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "PersonalCenterView::OnStart ok");
+}
+
+} // namespace OHOS
"cywee_dml",
"gnss",
"pgnss_sample",
+ "ChangAan",
# "gnss_sample",
"cyweeBleService",
"gyro",
+ "opus_frame_to_pcm",
+ "CT_AI",
],
'image_analysis': False,
'fs_image_path':'n9',
# 'ROTARYENCODER_HX3507',
# 'NANDFLASH_F35UQA',
'NANDFLASH_GD5F2G',
- # 'NANDFLASH_XT26Q02D',
+ # 'NANDFLASH_XT26Q02D',
'BLE_INSTRUCT',
'-:SUPPORT_ALIPAY_SEC',
# 'AILPAY_SUPPORT',
'AUDIO_SMARTPA_AW88082',
'LCD_JD9885',
'SUPPORT_LEINIAO',
+ # 'SUPPORT_UART_TEST_SERVICE',
],
#添加自定义应用
'ram_component': [
#cat1 相关配置
#有方需要开启 PPP
# "ppp",
+ #mqtt 相关配置
# "mqtt_service",
#EG810 需要开启 cat1Service 和 cat1Test
# "factorytest_service",
# "hid_service",
# "producttest",
+ "uarttest",
+ # "ChangAan",
# "ppg_hal",
# "mag_service",
# "cywee_dml",
# "factorytest_service",
# "hid_service",
# "producttest",
+ "ChangAan",
+ "opus_frame_to_pcm",
# "ppg_hal",
# "mag_service",
# "cywee_dml",
'efuse_v130': ['efuse', 'hal_efuse_v130', 'efuse_port'],
'ohos_set' : ['bootstrap', 'samgr', 'ams', 'bms', 'bms_sign_mode', 'ace', 'ace_adapt', 'permission', 'appverify', 'jerryscript','js_player', 'js_audio_capturer', 'baidumapcomponent', 'brightness', 'ace_http', 'ace_websocket', 'i18n', 'netstack_http', 'websocket',
'resmgr', 'syspara', 'utils_kv_store', 'native_file', 'storage_jsapi', 'svr_dynload', 'location_common', 'location_utils', 'locator_sdk', 'location_locator', 'location_gnss', 'location_gnss_hdi',
- 'location_gnss_utils', 'location_gnss_emulator', 'location_sample', 'sensor_client', 'sensor_service', 'sensor_hdi', 'sensor_sample'],
+ 'location_gnss_utils', 'location_gnss_emulator', 'location_sample', 'sensor_client', 'sensor_service', 'sensor_hdi', 'sensor_sample','ace_http','ace_websocket'],
'wearable_set' : ['nativeabilityfwk', 'nativelauncher', 'ai_voice_service', 'ai_voice_engine_hal', 'ai_voice_audio_stream_wrapper', 'ohos_deps',
'broadcast', 'msg_center', 'msg_center_adapt', 'ohos_startup', 'uikit_fwk'],
'xts_set' : ["xts_adapt", "ohos_drv_v3.2",
${ROOT_DIR}/include/middleware/services/bts/ble
${ROOT_DIR}/include/middleware/services/bts/br
${ROOT_DIR}/include/middleware/services/bts/common
+ ${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include/lwip
)
set(PRIVATE_DEFINES
* @brief 协议规定的BLE MTU最大值。
* @endif
*/
-#define SDK_BLE_MTU_MAX 517
+#define SDK_BLE_MTU_MAX 248
/**
* @if Eng
* @brief 用户可配置的BLE MTU最小值。
* @endif
*/
-#define SDK_BLE_MTU_MIN 23
+#define SDK_BLE_MTU_MIN 24
#ifdef __cplusplus
}
${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/modules/network
${ROOT_DIR}/open_source/openharmony/base/sensors/location/interfaces/kits/include
${ROOT_DIR}/open_source/openharmony/base/sensors/interfaces/kits/native/include
+ ${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_adapter/lwip_driver_adapter
)
if("JS_ENABLE" IN_LIST DEFINES)
${CMAKE_CURRENT_SOURCE_DIR}/modules/netstack/http/src/http_api.c
${CMAKE_CURRENT_SOURCE_DIR}/modules/netstack/http/src/http_client.c
${CMAKE_CURRENT_SOURCE_DIR}/modules/netstack/http/src/http_wrapper.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/modules/netstack/http/src/http_form_data.c
)
set(COMPONENT_PUBLIC_CCFLAGS
)
set(PRIVATE_DEFINES
+ CONFIG_HTTP_FORM_DATA
+ CONFIG_HTTP_FILE_OPERATE
)
install_sdk_by_sh("${CMAKE_CURRENT_SOURCE_DIR}/interfaces" "*")
set(PRIVATE_HEADER
${CMAKE_CURRENT_SOURCE_DIR}/interfaces/base
- ${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/modules/net
+ ${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/modules/http
${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/modules/netstack/http/include
${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/include
${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include
${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_adapter/lwip_driver_adapter
+ ${ROOT_DIR}/open_source/openharmony/utils/native/lite/js/builtin/filekit/include
+ ${ROOT_DIR}/open_source/openharmony/utils/native/lite/js/builtin/common/include
)
set(SOURCES
- ${CMAKE_CURRENT_SOURCE_DIR}/modules/net/http_module.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/modules/http/http_module.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/modules/http/http_module_client.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/modules/http/http_module_callback.cpp
)
set(COMPONENT_PUBLIC_CCFLAGS
set(PRIVATE_HEADER
${CMAKE_CURRENT_SOURCE_DIR}/interfaces/base
- ${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/modules/net
+ ${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/modules/http
${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/modules/netstack/websocket/include
${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/include
${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include
set(SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/modules/websocket/websocket_module.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/modules/websocket/websocket_module_client.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/modules/websocket/websocket_module_callback.cpp
)
set(COMPONENT_PUBLIC_CCFLAGS
set(PRIVATE_HEADER
${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/modules/netstack/websocket/include
+ ${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/modules/netstack/websocket/internal
${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/include
${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include
${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_adapter/lwip_driver_adapter
--- /dev/null
+/*
+ * Copyright (c) CompanyNameMagicTag. 2025-2025. All rights reserved.
+ * Description: http callback interfaces
+ * Author: Software Group
+ * Create: 2025-09-1
+ */
+
+#ifndef HTTP_CALLBACK_H
+#define HTTP_CALLBACK_H
+
+#include "jsi.h"
+#include "httpclient.h"
+#include "http_errcode.h"
+#include "ace_mem_base.h"
+
+namespace OHOS {
+namespace ACELite {
+
+typedef HTTP_REQUEST_TYPE HttpRequestType;
+typedef HTTP_ERRCODE HttpErrcode;
+typedef HTTPC_RESULT HttpcResult;
+
+enum HttpDataType {
+ DATA_TYPE_STRING = 0,
+ DATA_TYPE_OBJECT = 1,
+ DATA_TYPE_ARRAY_BUFFER = 2
+};
+
+enum HttpEventId {
+ HTTP_EVENT_RECEIVE = 0,
+ HTTP_EVENT_PROGRESS = 1,
+ HTTP_EVENT_END = 2,
+ HTTP_EVENT_MAX = 3
+};
+
+struct HttpResult {
+ HttpErrcode resCode;
+ int responseCode;
+ const char *errMsg;
+ uint8_t *data;
+ int dataLen;
+ int receiveSize;
+ int totalSize;
+ bool isMore;
+ bool isFinish;
+ bool isOnce;
+ HttpDataType datatype;
+ HttpEventId eventId;
+ JSIValue context;
+ JSIValue callback;
+ void *client;
+};
+
+class HttpCallback : public MemoryHeap {
+public:
+ virtual ~HttpCallback() {}
+ virtual void CreateCallback(HttpResult* result) {}
+ virtual void CreateSubscription(HttpResult* result){}
+};
+
+} // namespace ACELite
+} // namespace OHOS
+
+#endif
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) CompanyNameMagicTag. 2024-2025. All rights reserved.
+ * Description: http control interfaces
+ * Author: Software Group
+ * Create: 2025-03-28
+ */
+
+#ifndef HTTP_MODULE_H
+#define HTTP_MODULE_H
+
+#include <stdint.h>
+#include <map>
+#include <cstring>
+#include "cmsis_os2.h"
+#include "jsi.h"
+#include "httpclient.h"
+
+namespace OHOS {
+namespace ACELite {
+
+class HttpModule final : public MemoryHeap {
+public:
+ HttpModule() = default;
+ ~HttpModule() = default;
+
+ static JSIValue CreateHttp(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);
+ static JSIValue Request(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);
+ static JSIValue RequestInStream(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);
+ static JSIValue Download(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);
+ static JSIValue Upload(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);
+ static JSIValue On(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);
+ static JSIValue Once(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);
+ static JSIValue Off(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);
+ static JSIValue Destroy(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);
+ static void OnTerminate();
+
+private:
+ static HttpRequestType GetRequestType(const char *method);
+ static HttpEventId GetEventId(const char *event);
+ static char *HeaderJsonToString(char* headerJson);
+};
+void InitHttpClientModule(JSIValue exports);
+
+} // namespace ACELite
+} // namespace OHOS
+
+#endif // HTTP_MODULE_H
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) CompanyNameMagicTag. 2025-2025. All rights reserved.
+ * Description: http module callback interfaces
+ * Author: Software Group
+ * Create: 2025-09-1
+ */
+
+#ifndef HTTP_MODULE_CALLBACK_H
+#define HTTP_MODULE_CALLBACK_H
+
+#include "jsi.h"
+#include "http_errcode.h"
+#include "http_callback.h"
+
+namespace OHOS {
+namespace ACELite {
+
+class HttpModuleCallback final : public HttpCallback {
+public:
+
+ static HttpModuleCallback* GetInstance()
+ {
+ static HttpModuleCallback instance;
+ return &instance;
+ }
+
+ void CreateCallback(HttpResult* result) override;
+ void CreateSubscription(HttpResult* result) override;
+
+ static void ExecuteCallFunc(void *params);
+ static void ExecuteSubscription(void *params);
+private:
+ HttpModuleCallback() = default;
+ ~HttpModuleCallback() = default;
+
+ static void SendData(HttpResult* result);
+ static void SendStateInfo(HttpResult* result);
+};
+
+} // namespace ACELite
+} // namespace OHOS
+
+#endif // HTTP_MODULE_CALLBACK_H
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) CompanyNameMagicTag. 2025-2025. All rights reserved.
+ * Description: http client interfaces
+ * Author: Software Group
+ * Create: 2025-10-20
+ */
+
+#ifndef HTTP_MODULE_CLIENT_H
+#define HTTP_MODULE_CLIENT_H
+
+#include <mutex>
+#include "cmsis_os2.h"
+#include "http_errcode.h"
+#include "httpclient.h"
+#include "http_module_callback.h"
+
+namespace OHOS {
+namespace ACELite {
+
+enum HttpRequestId {
+ HTTP_REQUEST,
+ HTTP_REQUESTINSTREAM,
+ HTTP_DOWNLOAD,
+ HTTP_DOWNLOAD_IMAGE,
+ HTTP_UPLOAD,
+ HTTP_FINISH,
+};
+
+struct HttpParam {
+ const char *url;
+ const char *header;
+ const char *filePath;
+ const char *clientCert;
+ char *postBuf;
+};
+
+struct HttpMessage {
+ HttpRequestId requestId;
+ HttpRequestType requestType;
+ HttpParam param;
+ int dataType;
+ JSIValue context;
+ JSIValue callback;
+};
+
+struct HttpRequest {
+ JSIValue request;
+ JSIValue requestInStream;
+ JSIValue download;
+ JSIValue upload;
+ JSIValue on;
+ JSIValue once;
+ JSIValue off;
+ JSIValue destroy;
+};
+
+struct HttpEvent {
+ JSIValue callback;
+ bool isOnce;
+};
+
+typedef std::function<void(HttpResult*)> DownloadCallback;
+class HttpModuleClient final : public MemoryHeap {
+public:
+ HttpModuleClient();
+ ~HttpModuleClient();
+
+ bool IsRunning(void) const
+ {
+ return isRunning_ ;
+ }
+
+ void InitCallback(HttpCallback* cbkInstance)
+ {
+ cbkInstance_ = cbkInstance;
+ }
+
+ void SetCustomCallback(DownloadCallback callback) {
+ downloadCallback_ = callback;
+ }
+
+ void Request(HttpParam ¶m, HttpRequestType requestType, int expectDataType, JSIValue context, JSIValue callback);
+ void RequestInStream(HttpParam ¶m, HttpRequestType requestType, int expectDataType, JSIValue context, JSIValue callback);
+ void Download(HttpParam ¶m, JSIValue context, JSIValue callback);
+ void DownloadImage(HttpParam ¶m);
+ void Upload(HttpParam ¶m, JSIValue context, JSIValue callback);
+
+ bool InitClient(void);
+ bool CreateHttpThread(void);
+ void StopThread(void);
+ osStatus_t HttpMessagePut(HttpMessage *message);
+ osStatus_t HttpMessageGet(HttpMessage *message);
+ HttpErrcode GetErrorCode(int errorCode);
+
+ void SetEventCallback(JSIValue callback, bool isOnce, HttpEventId id);
+ JSIValue GetEventCallback(HttpEventId id, bool &isOnce);
+
+ HttpClient client_{};
+ HttpClientData clientData_{};
+ osMessageQueueId_t httpQueueId_ = nullptr;
+ HttpRequest request_;
+ HttpEvent httpEvents_[HTTP_EVENT_MAX];
+ void ReleaseThread(void);
+ void DestroyClient(void);
+ void CloseClient(void);
+private:
+ void ReleaseJSIValue(JSIValue value)
+ {
+ if (!JSI::ValueIsUndefined(value)) {
+ JSI::ReleaseValue(value);
+ }
+ }
+
+ HttpDataType GetContentType(int expectDataType);
+ void CheckSubscription(HttpResult result);
+
+ void ResetClient(void);
+
+ static const uint32_t REQ_BUF_SIZE = 2048;
+ static const uint32_t RSP_BUF_SIZE = 2048;
+ bool isRunning_ = false;
+ void *stackMem_ = nullptr;
+ osThreadId_t streamId_ = nullptr;
+ HttpCallback* cbkInstance_;
+ std::mutex clientMutex_;
+ DownloadCallback downloadCallback_;
+};
+
+} // namespace ACELite
+} // namespace OHOS
+
+#endif // HTTP_MODULE_CLIENT_H
\ No newline at end of file
/** @brief http requst type */
typedef enum {
- NET_SUCCESS = 200,
+ NET_SUCCESS = 0,
NET_PARAMETER_ERROR = 401,
NET_PERMISSION_DENIED = 201,
NET_UNSUPPORTED_PROTOCOL = 2300001,
NET_UNKNOWN_ERROR = 2300999,
} HTTP_ERRCODE;
+typedef enum {
+ WEBSOCKET_SUCCESS = 0,
+ WEBSOCKET_CONNECT_FAILED = 200,
+ WEBSOCKET_URL_ERROR = 2302001,
+ WEBSOCKET_CERT_MISSING = 2302002,
+ WEBSOCKET_CONN_EXISTS = 2302003,
+ WEBSOCKET_NIC_ERROR = 2302004,
+ WEBSOCKET_PORT_ERROR = 2302005,
+ WEBSOCKET_DOMAIN_DENIED = 2302998,
+ WEBSOCKET_INTERNAL_ERROR = 2302999,
+ WEBSOCKET_AUTH_FAILED = 201,
+ WEBSOCKET_API_AUTH_FAILED = 202,
+ WEBSOCKET_FUNC_DENIED = 203,
+ WEBSOCKET_PARAM_ERROR = 401,
+ WEBSOCKET_API_UNSUPPORTED = 801
+} WEBSOCKET_ERRCODE;
#endif /* HTTPCLIENT_H */
\ No newline at end of file
#include <stdbool.h>
#include <stdint.h>
+#include <unistd.h>
#ifdef __cplusplus
extern "C" {
HTTP_ETIMEOUT = -12, /**< timeout */
} HTTPC_RESULT;
+typedef struct HttpClient HttpClient;
+
+/** @brief http SSE callback */
+typedef void (*HttpSseCallback)(HttpClient *client, const char* event, const char* data, const char* id);
+
/** @brief This structure defines the HttpClient structure */
-typedef struct {
+struct HttpClient {
int socket; /**< socket ID */
int remotePort; /**< hTTP or HTTPS port */
int responseCode; /**< response code */
char *authUser; /**< username for basic authentication */
char *authPassword; /**< password for basic authentication */
bool isHttp; /**< http connection? if 1, http; if 0, https */
+ HttpSseCallback sseCallback; /**< http sse callback */
+ int timeoutMs; /**< http timeout in millseconds */
#if CONFIG_HTTP_SECURE
const char *serverCert; /**< server certification */
const char *clientCert; /**< client certification */
int clientPkLen; /**< client private key lenght, client_pk buffer size */
void *ssl; /**< ssl content */
#endif
-} HttpClient;
+};
/** @brief This structure defines the HTTP data structure. */
typedef struct {
bool isMore; /**< indicates if more data needs to be retrieved. */
bool isChunked; /**< response data is encoded in portions/chunks.*/
+ bool isSSE; /**< indicates if response in SSE mode. */
int method; /**< http method. */
int retrieveLen; /**< content length to be retrieved. */
int responseContentLen; /**< response content total length. */
char *headerBuf; /**< buffer to store the response head data. */
bool isRedirected; /**< redirected URL? if 1, has redirect url; if 0, no redirect url */
char *redirectUrl; /**< redirect url when got http 3** response code. */
+ char *leftBuffer; /**< buffer to store last recv not report to user */
+ int leftBufferLen; /**< last recv buffer length, not report to user */
} HttpClientData;
/**
*/
void HttpClientClse(HttpClient *client);
+/**
+ * This function sends HTTP request.
+ * @param[in] client a pointer to the #HttpClient.
+ * @param[in] data post data buffer
+ * @param[in] length buffer length
+ * @return length of data be uploaded to server; value < 0, if errors occurred.
+ */
+int HttpClientSendData(HttpClient *client, const char *postData, size_t length);
+
+/**
+ * This function receives SSE response from remote.
+ * @param[in] client a pointer to #HttpClient.
+ * @param[in] clientData a pointer to #HttpClientData.
+ * @return Please refer to #HTTPC_RESULT.
+ */
+int HttpClientSseRecv(HttpClient *client, HttpClientData *clientData);
+
/**
* This function sets a custom header.
* @param[in] client client is a pointer to the #HttpClient.
*/
int HttpClientGetResponseHeaderValue(char *headerBuf, char *name, int *valPos, int *valLen);
+/**
+ * This function add text formdata information.
+ * @param[in] clientData clientData is a pointer to the #HttpClientData.
+ * @param[in] contentType contentType is a pointer to the content type string.
+ * @param[in] name name is a pointer to the name string.
+ * @param[in] data data is a pointer to the data.
+ * @param[in] dataLen dataLen is the data length.
+ * @return The HTTP response code of the last request.
+ */
+int HttpClientFormdataAddText(HttpClientData *clientData, char *contentType, char *name, char *data, int dataLen);
+
+/**
+ * This function add file formdata information.
+ * @param[in] clientData clientData is a pointer to the #HttpClientData.
+ * @param[in] name name is a pointer to the name string.
+ * @param[in] contentType contentType is a pointer to the content type string.
+ * @param[in] filePath filePath is a pointer to the file path.
+ * @return The HTTP response code of the last request.
+ */
+int HttpClientFormdataAddfile(HttpClientData *clientData, char *name, char *contentType, char *filePath);
+
+/**
+ * This function clear file formdata information.
+ * @param[in] clientData clientData is a pointer to the #HttpClientData.
+ * @return None.
+ */
+void HttpClientClearFormData(HttpClientData *clientData);
#ifdef __cplusplus
}
#endif
--- /dev/null
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025-2025. All rights reserved.
+ */
+#ifndef HTTP_FORM_DATA
+#define HTTP_FORM_DATA
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define FORM_DATA_PATH_MAXLEN 256
+#define CLIENT_FORM_DATA_NUM 1
+
+#define FORM_DATA_BOUNDARY "----WebKitFormBoundarypXEfCkZnHjoOSnPc0"
+#define FORM_DATA_BOUNDARY_START "\r\n--" FORM_DATA_BOUNDARY
+#define FORM_DATA_BOUNDARY_END FORM_DATA_BOUNDARY_START "--\r\n"
+
+typedef struct HttpFormDataNode HttpFormDataNode;
+struct HttpFormDataNode {
+ HttpFormDataNode *next;
+ int isFile;
+ char filePath[FORM_DATA_PATH_MAXLEN];
+ char *formatContent;
+ int formatLen;
+};
+
+typedef struct {
+ int isUsed;
+ HttpFormDataNode *formDataNode;
+ HttpClientData *clientData;
+} FormDataInfo;
+
+void HttpClientClearFormData(HttpClientData *clientData);
+int HttpClientFormdataLen(HttpClientData *clientData);
+int HttpClientSendFormdata(HttpClient *client, HttpClientData *clientData);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file
#define HTTPCLIENT_MAX_URL_LEN 1024 // 512
#endif
+#ifndef HTTPCLIENT_MAX_FILE_DATA_LEN
+#define HTTPCLIENT_MAX_FILE_DATA_LEN 2048
+#endif
+
#ifndef HTTPCLIENT_MAX_RECV_WAIT_MS
#define HTTPCLIENT_MAX_RECV_WAIT_MS 5000
#endif
#define http_debug
#ifndef HTTP_MIN
-#define HTTP_MIN(x,y) (((x)<(y))?(x):(y))
+#define HTTP_MIN(x, y) (((x) < (y)) ? (x) : (y))
#endif
#ifndef HTTP_MAX
-#define HTTP_MAX(x,y) (((x)>(y))?(x):(y))
+#define HTTP_MAX(x, y) (((x) > (y)) ? (x) : (y))
#endif
int HttpTcpConnWrapper(HttpClient *client, const char *host);
int HttpTcpCloseWrapper(HttpClient *client);
int HttpTcpSendWrapper(HttpClient *client, const char *data, int length);
int HttpTcpRecvWrapper(HttpClient *client, char *buf, int buflen, int timeout_ms, int *p_read_len);
+int HttpTcpSseRecv(HttpClient *client, char *buffer, int buflen, int *bytesRead);
#if CONFIG_HTTP_SECURE
int HttpSslConnWrapper(HttpClient *client, const char *host);
int HttpSslCloseWrapper(HttpClient *client);
int HttpSslSendWrapper(HttpClient *client, const char *data, size_t length);
int HttpSslRecvWrapper(HttpClient *client, char *buf, int buflen, int timeout_ms, int *p_read_len);
+int HttpSslSseRecv(HttpClient *client, char *buffer, int buflen, int *bytesRead);
#endif
#ifdef __cplusplus
*/
int WebSocketClientSendBinEnd(int client, const char *data, size_t length);
+/**
+ @brief Send bin to connect socket.
+ @detailed Thread safe method.
+ @param client Socket object.
+ @param data bin string for sending.
+ @param length length of binary data.
+ @return 0 if success; non-0 otherwise. For details about error codes, see {@link WebsocketErrCode}.
+*/
+int WebSocketClientSendBin(int client, const char *data, size_t length);
+
/**
* @brief Closes a WebSocket connection.
* @detailed do not use it under onMessage/onOpen/OnError callback
* @brief Defines the callback function invoked when an <b>open</b> message is received.
*
* @param client WebSocket client fd.
- * @param openResult Content of the <b>open</b> message received by the WebSocket client.
* @since 11
* @version 1.0
*/
#ifndef OHOS_ACELITE_NETWORK_LISTENER_H
#define OHOS_ACELITE_NETWORK_LISTENER_H
+#include "lwip_driver_adapter.h"
+
#ifdef __cplusplus
extern "C" {
#endif
#endif
#ifdef FEATURE_MODULE_WEBSOCKET
-extern void InitWebsocketClientModule(JSIValue exports);
+extern void InitWebSocketClientModule(JSIValue exports);
#endif
#ifdef FEATURE_MODULE_CONFIGURATION
// {"capability", InitCapabilityModule},
// #endif
#ifdef FEATURE_MODULE_WEBSOCKET
- {"net.webSocket", InitWebsocketClientModule},
+ {"net.webSocket", InitWebSocketClientModule},
#endif
#ifdef FEATURE_MODULE_NFC
{"nfc.cardEmulation", NfcHceInitModule},
--- /dev/null
+/*
+ * Copyright (c) CompanyNameMagicTag. 2025-2025. All rights reserved.
+ * Description: websocket common definition
+ * Author: Software Group
+ * Create: 2025-11-19
+ */
+
+#ifndef WEBSOCKET_COMMON_H
+#define WEBSOCKET_COMMON_H
+
+
+namespace OHOS {
+namespace ACELite {
+
+#define net_malloc ace_malloc
+#define net_free ace_free
+
+enum WsEventId {
+ WS_EVENT_OPEN = 0,
+ WS_EVENT_MESSAGE = 1,
+ WS_EVENT_CLOSE = 2,
+ WS_EVENT_ERROR = 3,
+ WS_EVENT_MAX = 4
+};
+
+} // namespace ACELite
+} // namespace OHOS
+
+#endif
\ No newline at end of file
+++ /dev/null
-/*\r
- * Copyright (c) 2025 Huawei Device Co., Ltd.\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- */\r
-\r
-#include <string>\r
-#include "websocket_module.h"\r
-#include "net_websocket.h"\r
-#include <string.h>\r
-#include "ace_log.h"\r
-#include "errcode.h"\r
-#include "cmsis_os2.h"\r
-\r
-namespace OHOS {\r
-namespace ACELite {\r
-\r
-JSIValue ws;\r
-JSIValue close;\r
-JSIValue on;\r
-JSIValue off;\r
-JSIValue send;\r
-JSIValue connect;\r
-\r
-std::map<std::string, EventCallback *> WebsocketModule::eventCallbacks;\r
-\r
-JSIValue WebsocketModule::CreateWebsocket(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize)\r
-{\r
- ws = JSI::CreateObject();\r
- connect = JSI::CreateFunction(WebsocketModule::Connect);\r
- send = JSI::CreateFunction(WebsocketModule::Send);\r
- on = JSI::CreateFunction(WebsocketModule::On);\r
- off = JSI::CreateFunction(WebsocketModule::Off);\r
- close = JSI::CreateFunction(WebsocketModule::Close);\r
- JSI::SetNamedProperty(ws, "send", send);\r
- JSI::SetNamedProperty(ws, "connect", connect);\r
- JSI::SetNamedProperty(ws, "on", on);\r
- JSI::SetNamedProperty(ws, "off", off);\r
- JSI::SetNamedProperty(ws, "close", close);\r
- return ws;\r
-}\r
-\r
-static void OnOpen(int client)\r
-{\r
- auto it = WebsocketModule::eventCallbacks.find(std::string("open"));\r
- if (it == WebsocketModule::eventCallbacks.end()) {\r
- HILOG_ERROR(HILOG_MODULE_ACE, "Can not find OnOpen Callback!");\r
- }\r
- JSIValue value = JSI::CreateObject();\r
- if (value != nullptr) {\r
- JSI::SetNumberProperty(value, "client", client);\r
- }\r
- JSIValue err = JSI::CreateBoolean(false);\r
- JSIValue argv[2] = {err, value};\r
- if (it != WebsocketModule::eventCallbacks.end()) {\r
- JSI::CallFunction(it->second->callback, it->second->context, argv, 2);\r
- }\r
- JSI::ReleaseValueList(value, err);\r
-}\r
-\r
-static void OnMessage(int client, const char *data, size_t length, bool isFinished,bool isBinary)\r
-{\r
- auto it = WebsocketModule::eventCallbacks.find(std::string("message"));\r
- if (it == WebsocketModule::eventCallbacks.end()) {\r
- HILOG_ERROR(HILOG_MODULE_ACE, "Can not find OnMessage Callback!");\r
- }\r
- JSIValue value = JSI::CreateObject();\r
- if (value != nullptr) {\r
- JSI::SetNumberProperty(value, "length", length);\r
- JSI::SetStringProperty(value, "data", data);\r
- JSI::SetNumberProperty(value, "client", client);\r
- }\r
- JSIValue err = JSI::CreateBoolean(false);\r
- JSIValue argv[2] = {err, value};\r
- if (it != WebsocketModule::eventCallbacks.end()) {\r
- JSI::CallFunction(it->second->callback, it->second->context, argv, 2);\r
- }\r
- JSI::ReleaseValueList(value, err);\r
-}\r
-\r
-static void OnError(int client, struct WebSocketErrorResult errorResult)\r
-{\r
- auto it = WebsocketModule::eventCallbacks.find(std::string("error"));\r
- if (it == WebsocketModule::eventCallbacks.end()) {\r
- HILOG_ERROR(HILOG_MODULE_ACE, "Can not find OnError Callback!");\r
- }\r
- JSIValue value = JSI::CreateObject();\r
- if (value != nullptr) {\r
- JSI::SetNumberProperty(value, "client", client);\r
- }\r
- JSIValue err = JSI::CreateBoolean(false);\r
- JSIValue argv[2] = {err, value};\r
- if (it != WebsocketModule::eventCallbacks.end()) {\r
- JSI::CallFunction(it->second->callback, it->second->context, argv, 2);\r
- }\r
- JSI::ReleaseValueList(value, err);\r
-}\r
-\r
-static void OnClose(int client, struct WebSocketErrorResult errorResult)\r
-{\r
- auto it = WebsocketModule::eventCallbacks.find(std::string("open"));\r
- if (it == WebsocketModule::eventCallbacks.end()) {\r
- HILOG_ERROR(HILOG_MODULE_ACE, "Can not find OnError Callback!");\r
- }\r
- JSIValue value = JSI::CreateObject();\r
- if (value != nullptr) {\r
- JSI::SetNumberProperty(value, "client", client);\r
- }\r
- JSIValue err = JSI::CreateBoolean(false);\r
- JSIValue argv[2] = {err, value};\r
- if (it != WebsocketModule::eventCallbacks.end()) {\r
- JSI::CallFunction(it->second->callback, it->second->context, argv, 2);\r
- }\r
- JSI::ReleaseValueList(value, err);\r
-}\r
-\r
-JSIValue WebsocketModule::Send(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize)\r
-{\r
- int client = JSI::ValueToNumber(JSI::AcquireValue(args[1]));\r
- char *message = JSI::ValueToString(JSI::AcquireValue(args[0]));\r
-\r
- size_t length = strlen(message);\r
- int ret = WebSocketClientSendText(client, message, length);\r
-\r
- JSIValue isError;\r
- isError = JSI::CreateBoolean(ret == 0 ? false : true);\r
- JSIValue value = JSI::CreateObject();\r
- if (value != nullptr) {\r
- JSI::SetNumberProperty(value, "client", client);\r
- }\r
-\r
- JSIValue callback = JSI::AcquireValue(args[2]);\r
- JSIValue argv[ARGC_TWO] = {isError, value};\r
- JSI::CallFunction(callback, thisVal, argv, ARGC_TWO);\r
- JSI::ReleaseValueList(value, callback);\r
- JSI::ReleaseString(message);\r
- return JSI::CreateUndefined();\r
-}\r
-\r
-JSIValue WebsocketModule::Connect(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize)\r
-{\r
- char *url = JSI::ValueToString(JSI::AcquireValue(args[0]));\r
- int client = WebSocketClientConstructor(OnOpen, OnMessage, OnError, OnClose);\r
- if (client < 0) {\r
- HILOG_ERROR(HILOG_MODULE_ACE, "WebSocketClientConstructor fail!");\r
- return JSI::CreateUndefined();\r
- }\r
-\r
- int ret = WebSocketClientConnect(client, url,NULL);\r
- if (ret != 0) {\r
- HILOG_ERROR(HILOG_MODULE_ACE, "WebSocketClientConnect fail!");\r
- return JSI::CreateUndefined();\r
- }\r
-\r
- JSIValue isError;\r
- isError = JSI::CreateBoolean(ret == 0 ? false : true);\r
-\r
- JSIValue value = JSI::CreateObject();\r
- if (value != nullptr) {\r
- JSI::SetNumberProperty(value, "client", client);\r
- }\r
-\r
- JSIValue callback = JSI::AcquireValue(args[1]);\r
- JSIValue argv[ARGC_TWO] = {isError, value};\r
- JSI::CallFunction(callback, thisVal, argv, ARGC_TWO);\r
- JSI::ReleaseValueList(value, callback, isError);\r
- JSI::ReleaseString(url);\r
- return JSI::CreateUndefined();\r
-}\r
-\r
-JSIValue WebsocketModule::Close(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize)\r
-{\r
- int client = JSI::ValueToNumber(JSI::AcquireValue(args[0]));\r
- int ret = WebSocketClientClose(client);\r
- if (ret != 0) {\r
- HILOG_ERROR(HILOG_MODULE_ACE, "WebSocketClientConnect fail!");\r
- }\r
- JSIValue isError;\r
- isError = JSI::CreateBoolean(ret == 0 ? false : true);\r
- JSIValue value = JSI::CreateObject();\r
- if (value != nullptr) {\r
- JSI::SetNumberProperty(value, "client", client);\r
- }\r
-\r
- JSIValue callback = JSI::AcquireValue(args[1]);\r
- JSIValue argv[ARGC_TWO] = {isError, value};\r
- JSI::CallFunction(callback, thisVal, argv, ARGC_TWO);\r
- JSI::ReleaseValueList(isError, value, callback);\r
- return JSI::CreateUndefined();\r
-}\r
-\r
-void WebsocketModule::Destroy()\r
-{\r
- for (auto it = eventCallbacks.begin(); it != eventCallbacks.end();) {\r
- auto currentIt = it;\r
- ++it;\r
- EventCallback *ec = currentIt->second;\r
- JSI::ReleaseValue(ec->context);\r
- JSI::ReleaseValue(ec->callback);\r
- delete ec;\r
- eventCallbacks.erase(currentIt);\r
- }\r
- eventCallbacks.clear();\r
-\r
- JSI::ReleaseValue(on);\r
- JSI::ReleaseValue(off);\r
- JSI::ReleaseValue(connect);\r
- JSI::ReleaseValue(close);\r
- JSI::ReleaseValue(send);\r
- JSI::ReleaseValue(ws);\r
-}\r
-\r
-JSIValue WebsocketModule::On(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize)\r
-{\r
- if (argsSize < 2) {\r
- HILOG_ERROR(HILOG_MODULE_ACE, "Function parameters are not enough!");\r
- return JSI::CreateBoolean(false);\r
- }\r
-\r
- char *eventName = JSI::ValueToString(JSI::AcquireValue(args[0]));\r
-\r
- auto it = eventCallbacks.find(eventName);\r
- if (it != eventCallbacks.end()) {\r
- EventCallback *oldEc = it->second;\r
- JSI::ReleaseValue(oldEc->callback);\r
- JSI::ReleaseValue(oldEc->context);\r
- delete oldEc;\r
- eventCallbacks.erase(it);\r
- }\r
-\r
- JSIValue callback = JSI::AcquireValue(args[1]);\r
-\r
- EventCallback *ec = new EventCallback;\r
- if (ec != nullptr) {\r
- ec->callback = JSI::AcquireValue(callback);\r
- ec->context = JSI::AcquireValue(thisVal);\r
- eventCallbacks[eventName] = ec;\r
- JSI::ReleaseString(eventName);\r
- JSI::ReleaseValue(callback);\r
- return JSI::CreateBoolean(true);\r
- } else {\r
- JSI::ReleaseString(eventName);\r
- JSI::ReleaseValue(callback);\r
- }\r
-\r
- return JSI::CreateBoolean(false);\r
-}\r
-\r
-JSIValue WebsocketModule::Off(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize)\r
-{\r
- if (argsSize < 1) {\r
- HILOG_ERROR(HILOG_MODULE_ACE, "Function parameters are not enough!");\r
- return JSI::CreateBoolean(false);\r
- }\r
-\r
- char *eventName = JSI::ValueToString(JSI::AcquireValue(args[0]));\r
-\r
- auto it = eventCallbacks.find(eventName);\r
- if (it != eventCallbacks.end()) {\r
- JSI::ReleaseValue(it->second->callback);\r
- JSI::ReleaseValue(it->second->context);\r
- delete it->second;\r
- eventCallbacks.erase(it);\r
- JSI::ReleaseString(eventName);\r
- return JSI::CreateBoolean(true);\r
- }else {\r
- HILOG_ERROR(HILOG_MODULE_ACE, "Off failed, target not found!");\r
- JSI::ReleaseString(eventName);\r
- }\r
- return JSI::CreateBoolean(false);\r
-}\r
-\r
-void InitWebsocketClientModule(JSIValue exports)\r
-{\r
- JSI::SetModuleAPI(exports, "createWebsocket", WebsocketModule::CreateWebsocket);\r
- JSI::SetOnTerminate(exports, WebsocketModule::OnTerminate);\r
-}\r
-\r
-void WebsocketModule::OnTerminate()\r
-{\r
- WebsocketModule::Destroy();\r
-}\r
-} // namespace ACELite\r
-} // namespace OHOS
\ No newline at end of file
#include "jsi.h"\r
#include <map>\r
#include <cstring>\r
+#include "websocket_common.h"\r
+#include "websocket_module_callback.h"\r
\r
namespace OHOS {\r
namespace ACELite {\r
JSIValue context;\r
};\r
\r
-class WebsocketModule final : public MemoryHeap {\r
+class WebSocketModule final : public MemoryHeap {\r
public:\r
- WebsocketModule() = default;\r
- ~WebsocketModule() = default;\r
- static JSIValue CreateWebsocket(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);\r
+ WebSocketModule() = default;\r
+ ~WebSocketModule() = default;\r
+ static JSIValue CreateWebSocket(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);\r
static JSIValue Connect(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);\r
static JSIValue Send(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);\r
+ static JSIValue SendInit(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);\r
+ static JSIValue SendUpdate(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);\r
+ static JSIValue SendFinish(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);\r
static JSIValue Close(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);\r
+ static JSIValue Destroy(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);\r
static JSIValue On(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);\r
static JSIValue Off(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);\r
static std::map<std::string, EventCallback *> eventCallbacks;\r
- static void Destroy();\r
static void OnTerminate();\r
+private:\r
+ static WsEventId GetEventId(const char *event);\r
+ static char *HeaderJsonToString(char* headerJson);\r
};\r
-void InitWebsocketModule(JSIValue exports);\r
+void InitWebSocketClientModule(JSIValue exports);\r
\r
} // namespace ACELite\r
} // namespace OHOS\r
--- /dev/null
+/*
+ * Copyright (c) CompanyNameMagicTag. 2025-2025. All rights reserved.
+ * Description: websocket callback interfaces
+ * Author: Software Group
+ * Create: 2025-09-1
+ */
+
+#ifndef WEBSOCKET_MODULE_CALLBACK_H
+#define WEBSOCKET_MODULE_CALLBACK_H
+
+#include "jsi.h"
+#include "net_websocket_type.h"
+#include "http_errcode.h"
+#include "websocket_common.h"
+
+namespace OHOS {
+namespace ACELite {
+
+struct WsResult {
+ int resCode;
+ char* reason;
+ char* data;
+ int length;
+ bool isBinary;
+ int clientId;
+ WsEventId eventId;
+};
+
+class WsCallback final : public MemoryHeap {
+public:
+ WsCallback() = default;
+ ~WsCallback() = default;
+
+ static void DispatchStateInfo(int resCode, const char* reason, WsEventId eventId, int clientId);
+ static void DispatchMessage(const char *data, size_t length, bool isBinary, int clientId);
+
+private:
+ static void SendStateInfo(void *param);
+ static void SendMessage(void *param);
+
+private:
+};
+
+} // namespace ACELite
+} // namespace OHOS
+
+#endif
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) CompanyNameMagicTag. 2025-2025. All rights reserved.
+ * Description: websocket client interfaces
+ * Author: Software Group
+ * Create: 2025-10-20
+ */
+
+#ifndef WEBSOCKET_CLIENT_H
+#define WEBSOCKET_CLIENT_H
+
+#include "jsi.h"
+#include "net_websocket.h"
+#include "net_websocket_type.h"
+#include "websocket_common.h"
+
+namespace OHOS {
+namespace ACELite {
+
+enum WsDataType {
+ DATA_TYPE_STRING = 0,
+ DATA_TYPE_OBJECT = 1,
+ DATA_TYPE_ARRAY_BUFFER = 2
+};
+
+struct WsHandler {
+ JSIValue send;
+ JSIValue sendInit;
+ JSIValue sendUpdate;
+ JSIValue sendFinish;
+ JSIValue connect;
+ JSIValue close;
+ JSIValue destroy;
+ JSIValue on;
+ JSIValue off;
+};
+
+class WsModuleClient final : public MemoryHeap {
+public:
+ WsModuleClient();
+ ~WsModuleClient();
+
+ int GetClientId(void) const
+ {
+ return clientId_;
+ }
+
+ int Connect(const char *url, const char *option);
+ int Send(const char *data, size_t length, WsDataType dataType);
+ int SendInit(uint32_t size);
+ int SendUpdate(const char *data, size_t length);
+ int SendFinish(const char *data, size_t length, WsDataType dataType);
+ int Close(void);
+ static int GetErrorCode(int8_t errorCode);
+
+ WsHandler handler_;
+ JSIValue context_;
+ JSIValue WsEvents_[WS_EVENT_MAX];
+private:
+ void ReleaseJSIValue(JSIValue value)
+ {
+ if (!JSI::ValueIsUndefined(value)) {
+ JSI::ReleaseValue(value);
+ }
+ }
+
+ int SendBinary(const char *data, size_t bufferSize);
+
+ static const uint32_t WS_MAX_DATA_LENGTH = 20 * 1024;
+ static const uint32_t WS_MAX_SEND_LENGTH = 100 * 1024;
+ int clientId_ = -1;
+ char *msgBuffer_ = nullptr;
+ uint32_t bufferSize_ = 0;
+ uint32_t dataSize_ = 0;
+
+};
+
+} // namespace ACELite
+} // namespace OHOS
+
+#endif // WEBSOCKET_CLIENT_H
\ No newline at end of file
# @brief cmake file
# Copyright (c) @CompanyNameMagicTag 2022-2022. All rights reserved.
#===============================================================================
+if("BRANDY_PRODUCT_EVB4" IN_LIST DEFINES OR "BRANDY_PRODUCT_EVB" IN_LIST DEFINES)
set(COMPONENT_NAME "lwip")
+else()
+set(COMPONENT_NAME "ohos_lwip")
+endif()
set(CMAKE_LWIP_SOURCE_DIR
${CMAKE_CURRENT_SOURCE_DIR}/lwip_v2.1.3)
set(LWIP_DIR ${CMAKE_CURRENT_SOURCE_DIR}/lwip_v2.1.3)
-if("liteos_207_1_0" IN_LIST TARGET_COMPONENT)
- set(CMAKE_LWIP_ADAPTER_DIR
- ${CMAKE_CURRENT_SOURCE_DIR}/lwip_adapter/liteos)
-elseif("liteos_207_0_0" IN_LIST TARGET_COMPONENT)
+if("__LITEOS__" IN_LIST DEFINES)
set(CMAKE_LWIP_ADAPTER_DIR
${CMAKE_CURRENT_SOURCE_DIR}/lwip_adapter/liteos)
elseif("freertos" IN_LIST TARGET_COMPONENT)
if("__LITEOS__" IN_LIST DEFINES)
list(APPEND SOURCES
${ROOT_DIR}/open_source/mbedtls/mbedtls_v3.6.0/library/net_sockets.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/lwip_adapter/lwip_driver_adapter/lwip_net_manage.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/lwip_adapter/lwip_driver_adapter/lwip_lowpower.c
)
endif()
MBEDTLS_NET_C
)
+if("SUPPORT_BREDR" IN_LIST DEFINES AND "__LITEOS__" IN_LIST DEFINES)
+ list(APPEND SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/lwip_adapter/lwip_driver_adapter/lwip_driver_adapter.c
+ )
+endif()
# use this when you want to add ccflags like -include xxx
set(COMPONENT_PUBLIC_CCFLAGS
)
+if("BRANDY_PRODUCT_EVB4" IN_LIST DEFINES OR "BRANDY_PRODUCT_EVB" IN_LIST DEFINES)
set(COMPONENT_CCFLAGS
)
+else()
+set(COMPONENT_CCFLAGS
+ -Wno-unused-but-set-variable
+)
+endif()
if("__ALIOS__" IN_LIST DEFINES)
list(APPEND PRIVATE_HEADER
#include "lwip/sio.h"
#include "uart.h"
#include "uart_porting.h"
+#include "pinctrl_porting.h"
#include "securec.h"
#include "errcode.h"
#include "hal_uart.h"
static hal_uart_pin_config_t g_sio_uart_pin_config = {
.tx_pin = SIO_UART_TX_PIN, /* SIO UART TX pin */
.rx_pin = SIO_UART_RX_PIN, /* SIO UART RX pin */
- .cts_pin = PIN_NONE, /* SIO UART CTS pin */
- .rts_pin = PIN_NONE /* SIO UART RTS pin */
+ .cts_pin = SIO_UART_CTS_PIN, /* SIO UART CTS pin */
+ .rts_pin = SIO_UART_RTS_PIN /* SIO UART RTS pin */
};
-/* SIO UART attributes */
+
+/* SIO UART attributes(参考 tiot:流控通过第5项传入,此处用 .pad 承载) */
static hal_uart_attr_t g_sio_uart_attr = {
.baud_rate = SIO_UART_BAUDRATE,
.data_bits = UART_DATA_BIT_8,
printf(" %s %d\n", __FUNCTION__, __LINE__);
ret = uapi_uart_set_attr(SIO_UART_BUS, (const void*)&g_sio_uart_attr);
- if (ret != ERRCODE_SUCC) {
- return ret;
+ if (ret != ERRCODE_SUCC) {
+ return ret;
}
// 使能UART_BUS_0 (UART_L) 的唤醒
hal_pmu_lpm_wakeup_action_enable(LPM_INT_ACTION, TURN_ON, PMU_LPM_MCPU_UART_L0_RX_WAKEUP);
// 使用新的中断处理函数
- ret = uapi_uart_register_rx_callback(SIO_UART_BUS,
+ ret = uapi_uart_register_rx_callback(SIO_UART_BUS,
UART_RX_CONDITION_FULL_OR_SUFFICIENT_DATA_OR_IDLE,
8, // 8字节阈值
sio_uart_rx_interrupt_handler);
- printf("uapi_uart_register_rx_callback ret=%x\r\n", ret);
-
- printf(" %s %d\n", __FUNCTION__, __LINE__);
g_sio_uart_initialized = true;
return ERRCODE_SUCC;
}
#define UNUSED(a) ((void)(a))
#endif
+struct sys_arch_thread {
+ void *arg;
+ u8_t *stackMem;
+ u32_t taskId;
+};
+
#define LWIP_SEM_ID(x) (u32_t)(uintptr_t)((x)->sem)
#define MBOX_EXPAND_MULTIPLE_SIZE 2
/* Lwip docs mentioned like wraparound is not a problem in this funtion */
return (u32_t)((LOS_TickCountGet() * 1000) / LOSCFG_BASE_CORE_TICK_PER_SECOND);
}
-u32_t sys_jiffies(void)
+
+void sys_thread_delete(void *param)
{
- /*sys_jiffies is the same as sys_now*/
- return (u32_t)((LOS_TickCountGet() * 1000) / LOSCFG_BASE_CORE_TICK_PER_SECOND);
+ if (param == NULL) {
+ return;
+ }
+ struct sys_arch_thread *threadCtl = (struct sys_arch_thread *)param;
+ LOS_TaskJoin(threadCtl->taskId, NULL);
+
+ if (threadCtl->stackMem != NULL) {
+ free(threadCtl->stackMem);
+ threadCtl->stackMem = NULL;
+ }
+ free(threadCtl);
}
+
sys_thread_t sys_thread_new(const char *name, lwip_thread_fn function, void *arg, int stacksize, int prio)
{
- TSK_INIT_PARAM_S task;
- UINT32 taskid, ret;
- (void)memset_s(&task, sizeof(task), 0, sizeof(task));
-
+ TSK_INIT_PARAM_S task = {0};
+ u32_t taskId, ret;
+#ifdef LOSCFG_TASK_STACK_STATIC_ALLOCATION
+ u8_t *stackMem = NULL;
+#endif
+ if (function == NULL) {
+ return 0;
+ }
+ struct sys_arch_thread *param = calloc(1, sizeof(struct sys_arch_thread));
+ if (param == NULL) {
+ return 0;
+ }
+ param->arg = arg;
/* Create host Task */
task.pfnTaskEntry = (TSK_ENTRY_FUNC)function;
task.uwStackSize = 3072; // 修改为3K=3072
task.pcName = (char *)name;
task.usTaskPrio = prio;
- task.uwResved = LOS_TASK_STATUS_DETACHED;
+ task.uwResved = LOS_TASK_STATUS_JOINABLE;
#ifdef BR_HW_LITEOS_VERSION
LOS_TASK_PARAM_INIT_ARG(task, arg);
#else
task.auwArgs[0] = (UINTPTR)arg;
#endif
- ret = LOS_TaskCreate(&taskid, &task);
+#ifdef LOSCFG_TASK_STACK_STATIC_ALLOCATION
+ stackMem = memalign(LOSCFG_STACK_POINT_ALIGN_SIZE, task.uwStackSize);
+ if (stackMem == NULL) {
+ LWIP_DEBUGF(SYS_DEBUG, ("sys_thread_new: memalign fail\r\n"));
+ free(param);
+ return 0;
+ }
+ param->stackMem = stackMem;
+ ret = LOS_TaskCreateStatic(&taskId, &task, stackMem);
+#else
+ ret = LOS_TaskCreate(&taskId, &task);
+#endif
+ param->taskId = taskId;
if (ret != LOS_OK) {
LWIP_DEBUGF(SYS_DEBUG, ("sys_thread_new: LOS_TaskCreate error %u\n", ret));
- return SYS_ARCH_ERROR;
+ free(stackMem);
+ free(param);
+ return 0;
}
(void)stacksize;
- return taskid;
+ return (uintptr_t)param;
}
#ifdef LWIP_DEBUG
#include <errno.h>
#include "asm/atomic.h"
+#include <sys/time.h>
#ifdef __cplusplus
extern "C" {
typedef struct sys_mbox *sys_mbox_t;
-typedef unsigned int sys_thread_t;
+typedef uintptr_t sys_thread_t;
#define sys_sem_valid(x) (((*x).sem == NULL) ? 0 : 1)
#define sys_sem_set_invalid(x) ((*x).sem = NULL)
#if 0
#define LWIP_DEBUG LWIP_DBG_ON
-#define LWIP_DBG_TYPES_ON LWIP_DBG_ON
-#define SOCKETS_DEBUG LWIP_DBG_ON
-#define TCP_DEBUG LWIP_DBG_ON
-#define TCP_INPUT_DEBUG LWIP_DBG_ON
-#define TCP_OUTPUT_DEBUG LWIP_DBG_ON
-#define TCP_INPKT_DEBUG LWIP_DBG_ON
+// #define LWIP_DBG_TYPES_ON LWIP_DBG_ON
+// #define SOCKETS_DEBUG LWIP_DBG_ON
+// #define TCP_DEBUG LWIP_DBG_ON
+// #define TCP_INPUT_DEBUG LWIP_DBG_ON
+// #define TCP_OUTPUT_DEBUG LWIP_DBG_ON
+// #define TCP_INPKT_DEBUG LWIP_DBG_ON
#endif
#ifndef LWIP_SLIP
#endif
#ifndef SLIP_DEBUG
-#define SLIP_DEBUG LWIP_DBG_ON
+#define SLIP_DEBUG LWIP_DBG_OFF
#endif
#endif
#endif
#ifndef SIO_UART_BAUDRATE
-#define SIO_UART_BAUDRATE 921600
+#define SIO_UART_BAUDRATE (921600)//(1842000)//(921600)
#endif
#ifndef SIO_UART_TX_PIN
#define SIO_UART_RX_PIN S_MGPIO20
#endif
+
+#ifndef SIO_UART_CTS_PIN
+#define SIO_UART_CTS_PIN S_MGPIO22
+#endif
+
+#ifndef SIO_UART_RTS_PIN
+#define SIO_UART_RTS_PIN S_MGPIO21
+#endif
+
+/* 若流控脚一直拉高导致无法发送,可取消下一行注释以关闭 SIO UART 硬件流控(CTS/RTS 不使能,发送不再被 CTS 阻塞) */
+ #define SIO_UART_DISABLE_FLOW_CTRL 1
+
#ifndef SIO_UART_DATA_BIT
#define SIO_UART_DATA_BIT UART_DATA_BIT_8
#endif
#endif
#ifndef SIO_UART_FLOW_CTRL
-#define SIO_UART_FLOW_CTRL UART_FLOW_CTRL_NONE
+#define SIO_UART_FLOW_CTRL UART_FLOW_CTRL_RTS_CTS
#endif
#define CONFIG_NET_LWIP_SACK 0 //Selective Acknowledgment(选择性确认) 重传指定的包
#define LWIP_WND_SCALE 0
#endif
+#ifndef LWIP_SNTP
+#define LWIP_SNTP 0
+#endif
+
#ifndef LWIP_SOCK_FILTER
#define LWIP_SOCK_FILTER 0
#endif
#endif
#ifndef TCP_SND_QUEUELEN
-#define TCP_SND_QUEUELEN (TCP_SND_BUF / TCP_MSS)
+#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1))/(TCP_MSS))
#endif
#ifndef TCP_WND
-#define TCP_WND (TCP_SND_BUF * 2 / 6) //改善810的下载速度
-#endif
-
-#ifndef LWIP_IGMP
-#define LWIP_IGMP 1
+#define TCP_WND (TCP_SND_BUF * 2 / 3)
#endif
#ifndef LWIP_DNS_REVERSE
#endif
#ifndef MEMP_NUM_NETDB
-#define MEMP_NUM_NETDB 1
+#define MEMP_NUM_NETDB 8
#endif
#ifndef DNS_TABLE_SIZE
-#define DNS_TABLE_SIZE 2
+#define DNS_TABLE_SIZE 8
#endif
#ifndef DNS_MAX_IPADDR
#define IP_REASSEMBLY 1
#endif
+#if IP_REASSEMBLY
+/* The IP reassembly timer interval in milliseconds. */
+#ifndef IP_TMR_INTERVAL
+#define IP_TMR_INTERVAL 2000
+#endif
+#endif
+
#ifndef LWIP_RPL
#define LWIP_RPL 0
#endif
#define TCP_OOSEQ_MAX_PBUFS 8
#endif
+/** LWIP_TIMEVAL_PRIVATE: if you want to use the struct timeval provided
+ * by your system, set this to 0 and include <sys/time.h> in cc.h */
+#ifndef LWIP_TIMEVAL_PRIVATE
+#define LWIP_TIMEVAL_PRIVATE 0
+#endif
/**
* NO_SYS==1: Provides very minimal functionality. Otherwise,
/* @ingroup Config_TCP
* Defines the TCP TTL value.
*/
+#if LWIP_TCP
+#ifndef TCP_TMR_INTERVAL
+#define TCP_TMR_INTERVAL 2000 /* The TCP timer interval in milliseconds. */
+#endif /* TCP_TMR_INTERVAL */
+#endif
+
#ifndef TCP_TTL
#define TCP_TTL 255
#endif
#define LWIP_ARP 1
#endif
+#if LWIP_ARP
+#ifndef ARP_TMR_INTERVAL
+#define ARP_TMR_INTERVAL 2000
+#endif
+#endif
+
/**
* Defines the mailbox size for the tcpip thread messages
* The queue size value itself is platform-dependent, but is passed to
/* ---------- IGMP options ---------- */
#ifndef LWIP_IGMP
-#define LWIP_IGMP 1
+#define LWIP_IGMP 0
+#endif
+
+#if LWIP_IPV6
+#ifndef ND6_TMR_INTERVAL
+#define ND6_TMR_INTERVAL 2000
+#endif
+
+#ifndef MLD6_TMR_INTERVAL
+#define MLD6_TMR_INTERVAL 2000 /* Milliseconds */
+#endif
+
+/** The IPv6 reassembly timer interval in milliseconds. */
+#ifndef IP6_REASS_TMR_INTERVAL
+#define IP6_REASS_TMR_INTERVAL 2000
+#endif
+
+#endif
+
+/* IGMP timer */
+#if LWIP_IGMP
+#ifndef IGMP_TMR_INTERVAL
+#define IGMP_TMR_INTERVAL 2000 /* Milliseconds */
+#endif
+
+#ifndef IGMP_V1_DELAYING_MEMBER_TMR
+#define IGMP_V1_DELAYING_MEMBER_TMR 10
+#endif
+
+#ifndef IGMP_JOIN_DELAYING_MEMBER_TMR
+#define IGMP_JOIN_DELAYING_MEMBER_TMR 5
+#endif
#endif
/* ---------- DHCP options ---------- */
#define LWIP_DHCP 1
#endif
+#if LWIP_DHCP
+/** period (in milliseconds) of the application calling dhcp_fine_tmr() */
+#ifndef DHCP_FINE_TIMER_MSECS
+#define DHCP_FINE_TIMER_MSECS 2000
+#endif
+#endif
/* ---------- DNS options ---------- */
/**
* LWIP_DNS==1: Turn on DNS module. UDP must be available for DNS
#ifndef LWIP_DNS_REVERSE
#define LWIP_DNS_REVERSE 1
#endif
+/** DNS timer period */
+#ifndef DNS_TMR_INTERVAL
+#define DNS_TMR_INTERVAL 3000
+#endif
#else
#undef LWIP_DNS_REVERSE
#define LWIP_DNS_REVERSE 0
#if !defined DNS_MAX_RETRIES && LWIP_SMALL_SIZE
#define DNS_MAX_RETRIES 2
+
+/** period (in milliseconds) of the application calling dhcp6_tmr() */
+#if LWIP_IPV6_DHCP6
+#ifndef DHCP6_TIMER_MSECS
+#define DHCP6_TIMER_MSECS 2000
+#endif
+#endif
+
#endif
/* ---------- UDP options ---------- */
/* -----------LOOPIF options -----------*/
#ifndef LWIP_HAVE_LOOPIF
-#define LWIP_HAVE_LOOPIF 1
+#define LWIP_HAVE_LOOPIF 0
#endif
/* -----------LOOPBACK options -----------*/
#ifndef LWIP_NETIF_LOOPBACK
-#define LWIP_NETIF_LOOPBACK 1
+#define LWIP_NETIF_LOOPBACK 0
#endif
/* ---------- Statistics options ---------- */
#if LWIP_LITEOS_COMPAT
#ifndef TCPIP_THREAD_STACKSIZE
-#define TCPIP_THREAD_STACKSIZE 0x6000
+#define TCPIP_THREAD_STACKSIZE 0x1000
#endif
#ifndef TCPIP_THREAD_PRIO
-#define TCPIP_THREAD_PRIO 5
+#define TCPIP_THREAD_PRIO 24
#endif
#ifndef LWIP_SOCKET_START_NUM
* messages are written.
*/
#ifndef LWIP_DBG_MIN_LEVEL
-#define LWIP_DBG_MIN_LEVEL LWIP_DBG_LEVEL_ALL
+#define LWIP_DBG_MIN_LEVEL LWIP_DBG_LEVEL_OFF
#endif
#ifndef LWIP_SOCKET_POLL
#include "lwip_driver_adapter.h"
#include "lwip/tcpip.h"
+#include "lwip/etharp.h"
#include "lwip/netifapi.h"
#include "lwip/arch.h"
-#ifdef SUPPORT_BREDR
#include "bts_pan.h"
#include "bts_br_gap.h"
+#include "arch/task.h"
+#include "cmsis_os2.h"
+
+#define LWIP_ADAPTER_DEBUG
+#ifdef LWIP_ADAPTER_DEBUG
+#define LWIP_DEBUG_LOG(message) LWIP_PLATFORM_DIAG(message)
+#else
+#define LWIP_DEBUG_LOG(message)
#endif
+#define PAN_LOW_POWER
+
+static struct netif *g_bt_pan_netif = NULL;
+static net_connection_callback g_bt_pan_callback = NULL;
+static uint8_t g_pan_net_state = CONNECTION_UNKNOWN;
-#ifdef SUPPORT_BREDR
-static struct netif *bt_pan_netif = NULL;
+#ifndef PAN_LOW_POWER
+typedef struct {
+ uint8_t thread_run;
+ uint8_t end_thread;
+ sys_sem_t pan_sem;
+ void *param;
+} thread_ctl;
+
+static thread_ctl g_pan_thread = {0};
#endif
+
+#define BTPAN_THREAD_NAME "bt_pan_listen"
+#define BTPAN_THREAD_STACKSIZE 0xc00
+#define BTPAN_THREAD_PRIO 30
+#define BTPAN_MAX_PAIRED_DEVICES 5
+#define DEVICE_MAJOR_CLASS_PHONE 0x200 /* 手机设备COD:Major Device Class = phone */
+#define DHCP_THREAD_STACKSIZE 0x400
+
static err_t lwip_driver_output(struct netif *netif, struct pbuf *p, const ip4_addr_t *ipaddr);
static err_t lwip_netif_linkout(struct netif *netif, struct pbuf *p)
{
+ (void)netif;
if (p == NULL || p->payload == NULL) {
return ERR_ARG;
}
payload += SIZEOF_ETH_HDR;
p->len -= SIZEOF_ETH_HDR;
}
-#ifdef SUPPORT_BREDR
pan_service_write_data(payload, p->len, PAN_NETWORK_PROTOCOL_ARP, PAN_PACKET_TYPE_DEST_ONLY_UNICAST);
-#endif
return ERR_OK;
}
static err_t lwip_driver_init_fn(struct netif *netif_p)
{
+ if (netif_p == NULL) {
+ return ERR_ARG;
+ }
netif_p->output = lwip_driver_output;
netif_p->linkoutput = lwip_netif_linkout;
netifapi_netif_set_up(netif_p);
netifapi_netif_set_link_up(netif_p);
+ netifapi_netif_set_default(netif_p);
netif_p->mtu = 1000; /* 1000: mtu */
return ERR_OK;
static struct netif *lwip_driver_init_netif(const char *name, const unsigned char *hw_addr)
{
struct netif *netif = (struct netif *)malloc(sizeof(struct netif));
-#if LWIP_IPV4
- ip4_addr_t ipaddr, netmask, gw;
-
- IP4_ADDR(&gw, 192, 168, 44, 1); /* 192 168 44 1 : default gw addr */
- IP4_ADDR(&ipaddr, 192, 168, 44, 66); /* 192 168 44 66 : default ip addr */
- IP4_ADDR(&netmask, 255, 255, 255, 0); /* 255 0 : default netmask */
-#endif
if (netif == NULL) {
return NULL;
return NULL;
}
netif->hwaddr_len = NETIF_MAX_HWADDR_LEN;
- netifapi_netif_add(netif,
-#if LWIP_IPV4
- &ipaddr,
- &netmask,
- &gw,
-#endif
- NULL,
- lwip_driver_init_fn,
- tcpip_input);
- netif_set_default(netif);
+ netifapi_netif_add(netif, NULL, NULL, NULL, NULL, lwip_driver_init_fn, tcpip_input);
return netif;
}
if (netif == NULL || p == NULL || ipaddr == NULL) {
return ERR_ARG;
}
-#ifdef SUPPORT_BREDR
+
+ uint8_t *payload = NULL;
+ struct pbuf *p_clone = NULL;
+ if (p->tot_len > p->len && p->next != NULL) {
+ p_clone = pbuf_clone(PBUF_RAW, PBUF_RAM, p); /* packet queue copy to one packet */
+ if (p_clone == NULL) {
+ return ERR_MEM;
+ }
+ payload = p_clone->payload;
+ } else {
+ payload = p->payload;
+ }
if (ip4_addr_isbroadcast(ipaddr, netif)) {
- pan_service_write_data(p->payload, p->len, PAN_NETWORK_PROTOCOL_IPV4, PAN_PACKET_TYPE_DEST_ONLY_BORADCAST);
+ pan_service_write_data(payload, p->tot_len, PAN_NETWORK_PROTOCOL_IPV4, PAN_PACKET_TYPE_DEST_ONLY_BORADCAST);
} else {
- pan_service_write_data(p->payload, p->len, PAN_NETWORK_PROTOCOL_IPV4, PAN_PACKET_TYPE_DEST_ONLY_UNICAST);
+ pan_service_write_data(payload, p->tot_len, PAN_NETWORK_PROTOCOL_IPV4, PAN_PACKET_TYPE_DEST_ONLY_UNICAST);
+ }
+ if (p_clone != NULL) {
+ pbuf_free(p_clone);
}
-#endif
return ERR_OK;
}
-#ifdef SUPPORT_BREDR
-static void sample_pan_net_state_callback(uint8_t net_state)
+static void dhcp_server_thread(void *arg)
+{
+ struct netif *netif_p = (struct netif *)arg;
+
+ sleep(1);
+ netifapi_dhcp_start(netif_p);
+}
+
+static void dhcp_server_start(struct netif *netif_p)
+{
+
+ osThreadAttr_t attr;
+ attr.name = "dhcp_server";
+ attr.attr_bits = osThreadDetached;
+ attr.cb_mem = NULL;
+ attr.cb_size = 0U;
+ attr.stack_mem = NULL;
+ attr.stack_size = DHCP_THREAD_STACKSIZE;
+ attr.priority = osPriorityNormal;
+
+ if (!osThreadNew(dhcp_server_thread, (void *)netif_p, &attr)){
+ LWIP_DEBUG_LOG(("dhcp_server start fail\n"));
+ }
+}
+
+static void bt_pan_net_state_callback(uint8_t net_state)
{
- printf("sample pan net_state=%u\n", net_state);
+ struct netif *netif_p = g_bt_pan_netif;
+ if (netif_p == NULL) {
+ return;
+ }
if (net_state == 1) {
+ netifapi_netif_set_link_up(netif_p);
+ netifapi_netif_set_up(netif_p);
#if defined(LWIP_DHCP) && LWIP_DHCP
- netifapi_dhcp_start(bt_pan_netif);
- printf("dhcp start\n");
+ dhcp_server_start(netif_p);
+#endif
+ } else {
+#if defined(LWIP_DHCP) && LWIP_DHCP
+ netifapi_dhcp_release_and_stop(netif_p);
+#endif
+ netifapi_netif_set_link_down(netif_p);
+ netifapi_netif_set_down(netif_p);
+#if LWIP_IPV4
+ ip_addr_set_zero_ip4(&netif_p->ip_addr);
+ ip_addr_set_zero_ip4(&netif_p->netmask);
+ ip_addr_set_zero_ip4(&netif_p->gw);
+#endif
+#ifndef PAN_LOW_POWER
+ sys_sem_signal(&g_pan_thread.pan_sem);
#endif
}
}
}
#endif
-static void sample_pan_rpt_ethernet(uint8_t *packet, uint16_t packet_length, uint16_t network_protocol)
+static void bt_pan_rpt_ethernet(uint8_t *packet, uint16_t packet_length, uint16_t network_protocol)
{
int ret = ERR_OK;
+ struct netif *netif_p = g_bt_pan_netif;
+ if (netif_p == NULL) {
+ return;
+ }
if (network_protocol == PAN_NETWORK_PROTOCOL_ARP) {
#if defined(LWIP_IPV4) && LWIP_IPV4 && defined(LWIP_ARP) && LWIP_ARP
- ret = lwip_input_arp(packet, packet_length, bt_pan_netif);
+ ret = lwip_input_arp(packet, packet_length, netif_p);
#endif
} else if (network_protocol == PAN_NETWORK_PROTOCOL_IPV4) {
- ret = lwip_driver_input(packet, packet_length, bt_pan_netif);
+ ret = lwip_driver_input(packet, packet_length, netif_p);
} else {
return;
}
if (ret != 0) {
- printf("pan receive packet fail, ret=0x%x\n", ret);
+ LWIP_DEBUG_LOG(("pan receive packet fail, ret=0x%x\n", ret));
}
}
-static pan_callbacks_t g_sample_pan_callbacks_t = {sample_pan_net_state_callback, sample_pan_rpt_ethernet};
+static pan_callbacks_t g_bt_pan_callbacks_t = {bt_pan_net_state_callback, bt_pan_rpt_ethernet};
/* mac addr to big-endian */
static void mac_addr_hton(uint8_t *data)
data[3] = temp; /* 3 : byte index */
}
-static void lwip_register_bt_netif(void)
+static void init_register_bt_netif(void)
{
- unsigned char local_addr[6]; /* 6: mac addr length */
+#if defined(BRANDY_PRODUCT_EVB4) || defined(BRANDY_PRODUCT_EVB)
+ unsigned char local_addr[6]; /* 6: mac addr length */
bluetooth_get_local_addr(local_addr, 6); /* 6: mac addr length */
mac_addr_hton(local_addr);
- if (bt_pan_netif != NULL) {
+#else
+ bd_addr_t local_addr = {0};
+ bluetooth_get_local_addr(&local_addr);
+#endif
+ if (g_bt_pan_netif != NULL) {
return;
}
- bt_pan_netif = lwip_driver_init_netif("bt", local_addr);
- if (bt_pan_netif == NULL) {
- printf("sample pan init lwip fail\n");
+#if defined(BRANDY_PRODUCT_EVB4) || defined(BRANDY_PRODUCT_EVB)
+ g_bt_pan_netif = lwip_driver_init_netif("bt", local_addr);
+#else
+ g_bt_pan_netif = lwip_driver_init_netif("bt", local_addr.addr);
+#endif
+ if (g_bt_pan_netif == NULL) {
+ LWIP_DEBUG_LOG(("bt pan init lwip fail\n"));
}
}
-void bt_pan_open(void)
+static int bt_pan_get_paired_device(bd_addr_t *addr)
{
- int result;
- bool ret;
- gap_paired_device_info_t dev_info[1] = {0};
- int number = 1;
- lwip_register_bt_netif();
- ret = gap_get_paired_devices_list(dev_info, &number);
- if (ret) {
- printf("get bt dev info ok\n");
+ int index = 0;
+ int number = BTPAN_MAX_PAIRED_DEVICES;
+#if defined(BRANDY_PRODUCT_EVB4) || defined(BRANDY_PRODUCT_EVB)
+ gap_paired_device_info_t dev_info[BTPAN_MAX_PAIRED_DEVICES] = {0};
+#else
+ gap_remote_device_info_t dev_info[BTPAN_MAX_PAIRED_DEVICES] = {0};
+#endif
+#if defined(BRANDY_PRODUCT_EVB4) || defined(BRANDY_PRODUCT_EVB)
+ if (!gap_get_paired_devices_list(dev_info, &number)) {
+ LWIP_DEBUG_LOG(("get bt dev info fail\n"));
+ return -1;
+ }
+#else
+ if (gap_br_get_paired_devices_list(dev_info, &number) != ERRCODE_BT_SUCCESS) {
+ LWIP_DEBUG_LOG(("get bt dev info fail\n"));
+ return -1;
+ }
+#endif
+ for (index = 0; index < BTPAN_MAX_PAIRED_DEVICES; index++) {
+#if defined(BRANDY_PRODUCT_EVB4) || defined(BRANDY_PRODUCT_EVB)
+ if ((gap_get_device_class(&dev_info[index].addr) & DEVICE_MAJOR_CLASS_PHONE) != 0) {
+ break;
+ }
+#else
+ if((dev_info[index].device_class & DEVICE_MAJOR_CLASS_PHONE) != 0) {
+ break;
+ }
+#endif
+ }
+ if (index >= BTPAN_MAX_PAIRED_DEVICES) {
+ LWIP_DEBUG_LOG(("Not find paired phone\n"));
+ return -1;
+ }
+ if (memcpy_s(addr, sizeof(bd_addr_t), &dev_info[index].addr, sizeof(bd_addr_t)) != 0) {
+ return -1;
+ }
+ return 0;
+}
+
+#if defined(PAN_LOW_POWER)
+static int bt_pan_open_service(void)
+{
+ bd_addr_t addr;
+ int ret;
+ ret = bt_pan_get_paired_device(&addr);
+ if (ret != 0) {
+ LWIP_DEBUG_LOG(("bt_pan_get_paired_device fail\n"));
+ return ret;
+ }
+ ret = pan_service_open(&addr);
+ if (ret == 0) {
+ LWIP_DEBUG_LOG(("pan_service_open ok\n"));
} else {
- printf("get bt dev info fail\n");
+ LWIP_DEBUG_LOG(("pan_service_open fail, ret=0x%x\n", ret));
+ }
+ return ret;
+}
+
+#else
+static void bt_pan_thread(void *arg)
+{
+ bd_addr_t addr;
+ int ret;
+ thread_ctl *thread = (thread_ctl *)arg;
+ if (thread == NULL) {
return;
}
- result = pan_register_callbacks(&g_sample_pan_callbacks_t);
- if (result == 0) {
- printf("pan register callbacks ok\n");
- } else {
- printf("pan register fail\n");
+ thread->thread_run = 1;
+ sys_sem_new(&thread->pan_sem, 0);
+
+ while (thread->end_thread == 0) {
+ ret = bt_pan_get_paired_device(&addr);
+ if (ret != 0) {
+ LWIP_DEBUG_LOG(("bt_pan_get_paired_device fail\n"));
+ break;
+ }
+ if (pan_service_open(&addr) == 0) {
+ sys_arch_sem_wait(&thread->pan_sem, 0);
+ pan_service_close(&addr);
+ } else {
+ break;
+ }
+ if (thread->end_thread) {
+ break;
+ }
+ sleep(30); /* 30 : sleep 30s */
+ }
+ sys_sem_free(&thread->pan_sem);
+ thread->thread_run = 0;
+ thread->end_thread = 0;
+}
+#endif
+
+void bt_pan_close(void)
+{
+ int ret;
+ bd_addr_t addr;
+ struct netif *netif_p = g_bt_pan_netif;
+ if (netif_p == NULL) {
return;
}
+ pan_deregister_callbacks();
+#ifndef PAN_LOW_POWER
+ if (g_pan_thread.thread_run == 1) {
+ g_pan_thread.end_thread = 1;
+ sys_sem_signal(&g_pan_thread.pan_sem);
+ }
- result = pan_service_open(&dev_info[0].addr);
- if (result == 0) {
- printf("pan_service_open ok\n");
- } else {
- printf("pan_service_open fail\n");
+ if (g_pan_thread.param != NULL) {
+ sys_thread_delete(g_pan_thread.param);
+ g_pan_thread.param = NULL;
+ }
+#endif
+ netifapi_netif_set_link_down(netif_p);
+ netifapi_netif_set_down(netif_p);
+ netifapi_netif_remove(netif_p);
+
+ free(netif_p);
+ g_bt_pan_netif = NULL;
+ g_pan_net_state = CONNECTION_DISCONNECTED;
+
+ ret = bt_pan_get_paired_device(&addr);
+ if (ret != 0) {
+ return;
+ }
+ pan_service_close(&addr);
+}
+
+void bt_pan_open(void)
+{
+ init_register_bt_netif();
+
+ pan_register_callbacks(&g_bt_pan_callbacks_t);
+#ifdef PAN_LOW_POWER
+ if (bt_pan_open_service() != 0) {
+ bt_pan_close();
+ }
+#else
+ if (g_pan_thread.thread_run == 0) {
+ g_pan_thread.end_thread = 0;
+ g_pan_thread.param =
+ (void *)sys_thread_new(BTPAN_THREAD_NAME, bt_pan_thread, &g_pan_thread, BTPAN_THREAD_STACKSIZE, BTPAN_THREAD_PRIO);
+ if (g_pan_thread.param == NULL) {
+ LWIP_DEBUG_LOG(("bt pan thread create fail\n"));
+ }
}
+#endif
+}
+
+uint8_t pan_get_net_state(void)
+{
+ return g_pan_net_state;
}
-#endif /* SUPPORT_BREDR */
\ No newline at end of file
+
+#if LWIP_NETIF_EXT_STATUS_CALLBACK
+static netif_ext_callback_t g_netif_ext_callback;
+
+static void pan_net_callback(struct netif *netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t *args)
+{
+ if (netif != g_bt_pan_netif) {
+ return;
+ }
+
+ if ((reason & LWIP_NSC_IPV4_ADDRESS_CHANGED || reason & LWIP_NSC_IPV6_SET) &&
+ g_pan_net_state != CONNECTION_CONNECTED) {
+ g_pan_net_state = CONNECTION_CONNECTED;
+ if (g_bt_pan_callback != NULL) {
+ LWIP_DEBUG_LOG(("pan CONNECTION_CONNECTED\n"));
+ g_bt_pan_callback(LWIP_NETIF_BT_PAN, CONNECTION_CONNECTED);
+ }
+ }
+
+ if (reason & LWIP_NSC_STATUS_CHANGED && args->status_changed.state == 0 &&
+ g_pan_net_state != CONNECTION_DISCONNECTED) {
+ g_pan_net_state = CONNECTION_DISCONNECTED;
+ if (g_bt_pan_callback != NULL) {
+ LWIP_DEBUG_LOG(("pan CONNECTION_DISCONNECTED\n"));
+ g_bt_pan_callback(LWIP_NETIF_BT_PAN, CONNECTION_DISCONNECTED);
+ }
+ }
+}
+
+void bt_pan_register_net_callback(net_connection_callback callback)
+{
+ if (g_bt_pan_callback != NULL) {
+ return;
+ }
+ g_bt_pan_callback = callback;
+ netif_add_ext_callback(&g_netif_ext_callback, pan_net_callback);
+}
+
+void bt_pan_unregister_net_callback(void)
+{
+ g_bt_pan_callback = NULL;
+ netif_remove_ext_callback(&g_netif_ext_callback);
+}
+#else
+void bt_pan_register_net_callback(net_connection_callback callback)
+{
+ (void)callback;
+}
+
+void bt_pan_unregister_net_callback(void)
+{}
+#endif
\ No newline at end of file
/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2025-2025. All rights reserved.
+ * Copyright (c) CompanyNameMagicTag 2023-2023. All rights reserved.
+ * Description: extend functions
*/
-#ifndef LWIP_DRIVER_ADAPTER_H
-#define LWIP_DRIVER_ADAPTER_H
+#ifndef INCLUDE_LWIP_PUBLIC_H
+#define INCLUDE_LWIP_PUBLIC_H
+
+#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
-#ifdef SUPPORT_BREDR
-void bt_pan_open(void);
-#endif
+typedef enum {
+ /* 4g Cat1 netif */
+ LWIP_NETIF_VOLTE = 0,
+ /* bluetooth BT PAN netif */
+ LWIP_NETIF_BT_PAN = 1,
+ /* NULL netif */
+ LWIP_NETIF_NONE
+} lwip_netif_type;
+
+typedef enum {
+ CONNECTION_CONNECTING = 0,
+ CONNECTION_CONNECTED = 1,
+
+ CONNECTION_DISCONNECTING = 2,
+ CONNECTION_DISCONNECTED = 3,
+
+ CONNECTION_UNKNOWN = 100
+} lwip_net_connection_state;
+
+/**
+ * @brief Defines the callback function net connection status change.
+ *
+ * @param netif_type net if type, refer to #lwip_netif_type.
+ * @param net_connect_state net connection status, refer to #lwip_net_connection_state.
+ */
+typedef void (*net_connection_callback)(const uint8_t netif_type, const uint8_t net_connect_state);
+
+/**
+ * @brief This function register network connection status listener.
+ * @param[in] conn_listener net_connection_callback.
+ * @return 0 if success; non-0 otherwise.
+ */
+int lwip_register_connect_listener(net_connection_callback conn_listener);
+
+/**
+ * @brief Defines the callback unregister function for listening net connection status change.
+ */
+void lwip_unregister_connect_listener(net_connection_callback conn_listener);
+
+/**
+ * @brief This function get current network connection status.
+ * @param[in] netif_type netif type, refer to #lwip_netif_type.
+ * @param[in, out] net_connect_state network connection statue, refer to #lwip_net_connection_state.
+ * @return 0 if success; non-0 otherwise.
+ */
+int lwip_get_connect_status(uint8_t netif_type, uint8_t *net_connect_state);
+
+/**
+ * @brief init and open bt pan net interface.
+ */
+void lwip_open_bt_pan(void);
+
+/**
+ * @brief close bt pan net interface.
+ */
+void lwip_close_bt_pan(void);
#ifdef __cplusplus
}
--- /dev/null
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025-2025. All rights reserved.
+ */
+
+#include "lwip/tcpip.h"
+#include "lwip/netifapi.h"
+
+#if LWIP_LOWPOWER
+#include "lwip/lowpower.h"
+
+static int g_low_power_vote[LOW_MAX_MODULE] = {0};
+
+void lwip_lowpower_inc(lowpower_module mod)
+{
+#if LWIP_TCPIP_CORE_LOCKING
+ if (mod >= LOW_MAX_MODULE || mod < 0) {
+ return;
+ }
+
+ LOCK_TCPIP_CORE();
+ g_low_power_vote[mod]++;
+ for (uint8_t index = 0; index < LOW_MAX_MODULE; index++) {
+ if (g_low_power_vote[index] < 0) { /* some module prevent entering low power mode */
+ UNLOCK_TCPIP_CORE();
+ return;
+ }
+ }
+ set_lowpower_mod(LOW_TMR_LOWPOWER_MOD);
+ UNLOCK_TCPIP_CORE();
+#else
+ netifapi_enable_lowpower();
+#endif
+}
+
+void lwip_lowpower_dec(lowpower_module mod)
+{
+#if LWIP_TCPIP_CORE_LOCKING
+ if (mod >= LOW_MAX_MODULE || mod < 0) {
+ return;
+ }
+
+ LOCK_TCPIP_CORE();
+ if (g_low_power_vote[mod] > 0) {
+ g_low_power_vote[mod]--;
+ }
+
+ if (g_low_power_vote[mod] > 0) {
+ UNLOCK_TCPIP_CORE();
+ return;
+ }
+ set_lowpower_mod(LOW_TMR_NORMAL_MOD);
+ UNLOCK_TCPIP_CORE();
+#else
+ netifapi_disable_lowpower();
+#endif
+}
+
+#endif
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025-2025. All rights reserved.
+ */
+
+#include <stddef.h>
+
+#include "lwip_driver_adapter.h"
+
+#if defined(SUPPORT_VOLTE)
+static lwip_netif_type g_netif_state = LWIP_NETIF_VOLTE;
+#elif defined(SUPPORT_BREDR)
+static lwip_netif_type g_netif_state = LWIP_NETIF_BT_PAN;
+#else
+static lwip_netif_type g_netif_state = LWIP_NETIF_NONE;
+#endif
+
+typedef struct net_status_callback_t {
+ net_connection_callback callback_fn;
+ struct net_status_callback_t *next;
+} net_status_callback_t;
+
+static net_status_callback_t g_head_callback = {0};
+static uint8_t g_net_is_register = 0;
+
+static void net_status_litener(const uint8_t netif_type, const uint8_t net_connect_state)
+{}
+
+void lwip_netif_switch_volte(void)
+{
+#if defined(SUPPORT_VOLTE) && defined(SUPPORT_BREDR)
+ if (g_netif_state == LWIP_NETIF_VOLTE) {
+ return;
+ }
+ if (g_net_is_register == 0) {
+ lwip_register_connect_listener(net_status_litener);
+ g_net_is_register = 1;
+ }
+ bt_pan_close();
+ cat1_open_inner();
+ g_netif_state = LWIP_NETIF_VOLTE;
+#endif
+}
+
+void lwip_netif_switch_bt_pan(void)
+{
+#if defined(SUPPORT_VOLTE) && defined(SUPPORT_BREDR)
+ if (g_netif_state == LWIP_NETIF_BT_PAN) {
+ return;
+ }
+ if (g_net_is_register == 0) {
+ lwip_register_connect_listener(net_status_litener);
+ g_net_is_register = 1;
+ }
+ cat1_close_inner();
+ bt_pan_open();
+ g_netif_state = LWIP_NETIF_BT_PAN;
+#endif
+}
+
+void lwip_open_bt_pan(void)
+{
+#if defined(SUPPORT_BREDR)
+ if (g_netif_state != LWIP_NETIF_BT_PAN) {
+ return;
+ }
+ if (g_net_is_register == 0) {
+ lwip_register_connect_listener(net_status_litener);
+ g_net_is_register = 1;
+ }
+ bt_pan_open();
+#endif
+}
+
+void lwip_close_bt_pan(void)
+{
+#if defined(SUPPORT_BREDR)
+ if (g_netif_state != LWIP_NETIF_BT_PAN) {
+ return;
+ }
+ if (g_net_is_register) {
+ lwip_unregister_connect_listener(net_status_litener);
+ g_net_is_register = 0;
+ }
+ bt_pan_close();
+#endif
+}
+
+void lwip_cat1_open(void)
+{
+#if defined(SUPPORT_VOLTE)
+ if (g_netif_state != LWIP_NETIF_VOLTE) {
+ return;
+ }
+ if (g_net_is_register == 0) {
+ lwip_register_connect_listener(net_status_litener);
+ g_net_is_register = 1;
+ }
+ cat1_open_inner();
+#endif
+}
+
+void lwip_cat1_close(void)
+{
+#if defined(SUPPORT_VOLTE)
+ if (g_netif_state != LWIP_NETIF_VOLTE) {
+ return;
+ }
+ if (g_net_is_register) {
+ lwip_unregister_connect_listener(net_status_litener);
+ g_net_is_register = 0;
+ }
+ cat1_close_inner();
+#endif
+}
+
+int lwip_get_connect_status(uint8_t netif_type, uint8_t *net_connect_state)
+{
+ if (g_netif_state != netif_type) {
+ *net_connect_state = CONNECTION_DISCONNECTED;
+ return 0;
+ }
+#if defined(SUPPORT_VOLTE)
+ if (netif_type == LWIP_NETIF_VOLTE) {
+ *net_connect_state = cat1_get_net_state();
+ return 0;
+ }
+#endif
+#if defined(SUPPORT_BREDR)
+ if (netif_type == LWIP_NETIF_BT_PAN) {
+ *net_connect_state = pan_get_net_state();
+ return 0;
+ }
+#endif
+ return -1;
+}
+
+static void lwip_net_conn_callback(const uint8_t netif_type, const uint8_t net_connect_state)
+{
+ net_status_callback_t *iter_node = &g_head_callback;
+ while (iter_node != NULL) {
+ if (iter_node->callback_fn != NULL) {
+ iter_node->callback_fn(netif_type, net_connect_state);
+ }
+ iter_node = iter_node->next;
+ }
+}
+
+int lwip_register_connect_listener(net_connection_callback callback)
+{
+ net_status_callback_t *iter_node = &g_head_callback;
+ if (callback == NULL) {
+ return -1;
+ }
+#if defined(SUPPORT_VOLTE)
+ cat1_register_net_callback(lwip_net_conn_callback);
+#endif
+#if defined(SUPPORT_BREDR)
+ bt_pan_register_net_callback(lwip_net_conn_callback);
+#endif
+ if (g_head_callback.callback_fn == NULL) {
+ g_head_callback.callback_fn = callback;
+ return 0;
+ }
+ net_status_callback_t *ext_call_node = (net_status_callback_t *)malloc(sizeof(net_status_callback_t));
+ if (ext_call_node == NULL) {
+ return -1;
+ }
+ (void)memset_s(ext_call_node, sizeof(net_status_callback_t), 0, sizeof(net_status_callback_t));
+ ext_call_node->callback_fn = callback;
+
+ while (iter_node != NULL) {
+ if (iter_node->callback_fn == callback) {
+ free(ext_call_node);
+ return 0;
+ }
+ if (iter_node->next == NULL) {
+ iter_node->next = ext_call_node;
+ return 0;
+ }
+ iter_node = iter_node->next;
+ }
+ return 0;
+}
+
+void lwip_unregister_connect_listener(net_connection_callback callback)
+{
+ net_status_callback_t *iter_node = &g_head_callback;
+ net_status_callback_t *last = iter_node;
+ if (callback == NULL) {
+ return;
+ }
+
+ if (iter_node->callback_fn == callback) {
+ if (iter_node->next != NULL) {
+ g_head_callback.callback_fn = iter_node->next->callback_fn;
+ g_head_callback.next = iter_node->next->next;
+ free(iter_node->next);
+ return;
+ } else {
+ iter_node->callback_fn = NULL;
+ goto END;
+ }
+ }
+ while (iter_node != NULL) {
+ if (iter_node->callback_fn == callback) {
+ last->next = iter_node->next;
+ free(iter_node);
+ return;
+ }
+ last = iter_node;
+ iter_node = iter_node->next;
+ }
+ return;
+END:
+#if defined(SUPPORT_VOLTE)
+ cat1_unregister_net_callback();
+#endif
+#if defined(SUPPORT_BREDR)
+ bt_pan_unregister_net_callback();
+#endif
+}
\ No newline at end of file
sys_mbox_trypost(&conn->acceptmbox, mbox_msg);
}
- /* Wake up the waiting task outside of lock to avoid potential deadlock */
- if (need_signal && op_completed_sem != NULL) {
- sys_sem_signal(op_completed_sem);
+ if ((old_state == NETCONN_WRITE) || (old_state == NETCONN_CLOSE) ||
+ (old_state == NETCONN_CONNECT)) {
+ /* calling lwip_netconn_do_writemore/lwip_netconn_do_close_internal is not necessary
+ since the pcb has already been deleted! */
+ int was_nonblocking_connect = IN_NONBLOCKING_CONNECT(conn);
+ SET_NONBLOCKING_CONNECT(conn, 0);
+
+ if (!was_nonblocking_connect) {
+ sys_sem_t *op_completed_sem;
+ /* set error return code */
+ LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
+ if (old_state == NETCONN_CLOSE) {
+ /* let close succeed: the connection is closed after all... */
+ conn->current_msg->err = ERR_OK;
+ } else {
+ /* Write and connect fail */
+ conn->current_msg->err = err;
+ }
+ op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
+ LWIP_ASSERT("inavlid op_completed_sem", sys_sem_valid(op_completed_sem));
+ conn->current_msg = NULL;
+ /* wake up the waiting task */
+ sys_sem_signal(op_completed_sem);
+ } else {
+ /* @todo: test what happens for error on nonblocking connect */
+ }
+ } else {
+ LWIP_ASSERT("conn->current_msg == NULL", conn->current_msg == NULL);
}
}
}
return res;
out_disconnect:
+ printf("mqtt_message_received: out_disconnect\n");
return MQTT_CONNECT_DISCONNECTED;
}
if (p == NULL) {
LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_tcp_recv_cb: Recv pbuf=NULL, remote has closed connection\n"));
+ printf("mqtt_tcp_recv_cb: Recv pbuf=NULL, remote has closed connection\n");
mqtt_close(client, MQTT_CONNECT_DISCONNECTED);
} else {
mqtt_connection_status_t res;
LWIP_ASSERT("mqtt_tcp_err_cb: client != NULL", client != NULL);
/* Set conn to null before calling close as pcb is already deallocated*/
client->conn = 0;
+ printf("mqtt_tcp_err_cb: TCP error callback: error %d, arg: %p\n", err, arg);
+ printf("mqtt_tcp_err_cb: client->conn_state: %d\n", client->conn_state);
mqtt_close(client, MQTT_CONNECT_DISCONNECTED);
}
const ip_addr_t dns_mquery_v6group = DNS_MQUERY_IPV6_GROUP_INIT;
#endif /* LWIP_IPV6 */
-// #ifndef DNS_SERVER_ADDRESS
-// #define DNS_SERVER_ADDRESS(ipaddr) (ip4_addr_set_u32(ip_2_ip4(ipaddr), ipaddr_addr("208.67.222.222"))) /* resolver1.opendns.com */
-// #endif
-#if LWIP_IPV6
-#define DNS_SERVER_ADDRESS(ipaddr) ip_addr_set_ip4_u32(ipaddr,ipaddr_addr("8.8.8.8"))
-#define DNS_SERVER_ADDRESS_SECONDARY(ipaddr) ip_addr_set_ip4_u32(ipaddr,ipaddr_addr("114.114.114.114"))
-#else
-#define DNS_SERVER_ADDRESS(ipaddr) ip4_addr_set_u32(ipaddr,ipaddr_addr("8.8.8.8"))
-#define DNS_SERVER_ADDRESS_SECONDARY(ipaddr) ip4_addr_set_u32(ipaddr,ipaddr_addr("114.114.114.114"))
+#ifndef DNS_SERVER_ADDRESS
+#define DNS_SERVER_ADDRESS(ipaddr) (ip4_addr_set_u32(ip_2_ip4(ipaddr), ipaddr_addr("208.67.222.222"))) /* resolver1.opendns.com */
#endif
+
/**
* Initialize the resolver: set up the UDP pcb and configure the default server
* (if DNS_SERVER_ADDRESS is set).
void
dns_init(void)
{
-
- #ifdef DNS_SERVER_ADDRESS
+#ifdef DNS_SERVER_ADDRESS
/* initialize default DNS server address */
ip_addr_t dnsserver = {0};
+ u8_t n;
DNS_SERVER_ADDRESS(&dnsserver);
- dns_setserver(0, &dnsserver);
-#ifdef DNS_SERVER_ADDRESS_SECONDARY
- DNS_SERVER_ADDRESS_SECONDARY(&dnsserver);
- dns_setserver(1, &dnsserver);
-#endif
+ /* DNS servers */
+ for (n = 0; (n < LWIP_DHCP_MAX_DNS_SERVERS); n++) {
+ dns_setserver(n, &dnsserver);
+ }
#endif /* DNS_SERVER_ADDRESS */
LWIP_ASSERT("sanity check SIZEOF_DNS_QUERY",
if (dhcp->tries < 255) {
dhcp->tries++;
}
- msecs = (u16_t)((dhcp->tries < 6 ? 1 << dhcp->tries : 60) * 1000);
+ msecs = (u16_t)((dhcp->tries < 6 ? 2 : 60) * 1000); /* 6, 2, 60, 1000 : retry interval */
dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_select(): set request timeout %"U16_F" msecs\n", msecs));
return result;
return ERR_OK;
}
+#if LWIP_LOWPOWER
+ lwip_lowpower_dec(LOW_DHCP_MODULE);
+#endif
/* (re)start the DHCP negotiation */
result = dhcp_discover(netif);
if (result != ERR_OK) {
autoip_start(netif);
}
#endif /* LWIP_DHCP_AUTOIP_COOP */
- msecs = (u16_t)((dhcp->tries < 6 ? 1 << dhcp->tries : 60) * 1000);
+ msecs = (u16_t)((dhcp->tries < 6 ? 2 : 60) * 1000); /* 6, 2, 60, 1000 : retry interval */
dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_discover(): set request timeout %"U16_F" msecs\n", msecs));
return result;
netif_set_addr(netif, &dhcp->offered_ip_addr, &sn_mask, &gw_addr);
/* interface is used by routing now that an address is set */
+#if LWIP_LOWPOWER
+ lwip_lowpower_inc(LOW_DHCP_MODULE);
+#endif
}
/**
} else {
dhcp_set_state(dhcp, DHCP_STATE_OFF);
}
-
+#if LWIP_LOWPOWER
+ lwip_lowpower_inc(LOW_DHCP_MODULE);
+#endif
#if LWIP_DHCP_AUTOIP_COOP
if (dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) {
autoip_stop(netif);
pbuf_realloc(p, iphdr_len);
}
+ /* p->tot_len 大小追逐日志:便于排查 IP 包因 pbuf 长度不足被丢弃 */
+ LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE,
+ ("ip4_input: pbuf size trace: p->len=%"U16_F" p->tot_len=%"U16_F" iphdr_hlen=%"U16_F" iphdr_len=%"U16_F"\n",
+ p->len, p->tot_len, iphdr_hlen, iphdr_len));
+
/* header length exceeds first pbuf length, or ip length exceeds total pbuf length? */
if ((iphdr_hlen > p->len) || (iphdr_len > p->tot_len) || (iphdr_hlen < IP_HLEN)) {
if (iphdr_hlen < IP_HLEN) {
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
("IP (len %"U16_F") is longer than pbuf (len %"U16_F"), IP packet dropped.\n",
iphdr_len, p->tot_len));
+ /* 追踪整条 pbuf 链,定位 tot_len 不足来源 */
+ {
+ struct pbuf *dbg = p;
+ u16_t idx = 0;
+ while (dbg != NULL) {
+ LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
+ ("ip4_input: pbuf[%"U16_F"] p=%p len=%"U16_F" tot_len=%"U16_F" next=%p\n",
+ idx, (void *)dbg, dbg->len, dbg->tot_len, (void *)dbg->next));
+ dbg = dbg->next;
+ idx++;
+ }
+ }
}
/* free (drop) packet pbufs */
pbuf_free(p);
netif_ext_callback_t *callback = ext_callback;
LWIP_ASSERT("netif must be != NULL", netif != NULL);
-
- while (callback != NULL) {
+ while (callback != NULL && callback->callback_fn != NULL) {
callback->callback_fn(netif, reason, args);
callback = callback->next;
}
p->flags = flags;
p->ref = 1;
p->if_idx = NETIF_NO_INDEX;
+ /* p->tot_len 大小追逐日志:初始化时记录,便于与 ip4_input 丢包排查联动 */
+ LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE,
+ ("pbuf_init_alloced_pbuf: tot_len=%"U16_F" len=%"U16_F" type=%d p=%p\n",
+ tot_len, len, (int)type, (void *)p));
}
/**
/* useg should point to last segment on unacked queue */
useg = pcb->unacked;
if (useg != NULL) {
- for (; useg->next != NULL; useg = useg->next);
+ for (; useg != NULL && useg->next != NULL; useg = useg->next);
}
/* data available and window allows it to be sent? */
while (seg != NULL &&
/* In the case of fast retransmit, the packet should not go to the tail
* of the unacked queue, but rather somewhere before it. We need to check for
* this case. -STJ Jul 27, 2004 */
+ if (useg != NULL) {
if (TCP_SEQ_LT(lwip_ntohl(seg->tcphdr->seqno), lwip_ntohl(useg->tcphdr->seqno))) {
/* add segment to before tail of unacked list, keeping the list sorted */
struct tcp_seg **cur_seg = &(pcb->unacked);
useg->next = seg;
useg = useg->next;
}
+ }
}
/* do not queue empty segments on the unacked list */
} else {
#define DHCP_COARSE_TIMER_SECS 60
/** period (in milliseconds) of the application calling dhcp_coarse_tmr() */
#define DHCP_COARSE_TIMER_MSECS (DHCP_COARSE_TIMER_SECS * 1000UL)
+
/** period (in milliseconds) of the application calling dhcp_fine_tmr() */
+#ifndef DHCP_FINE_TIMER_MSECS
#define DHCP_FINE_TIMER_MSECS 500
+#endif
#define DHCP_BOOT_FILE_LEN 128U
#endif
/** period (in milliseconds) of the application calling dhcp6_tmr() */
+#ifndef DHCP6_TIMER_MSECS
#define DHCP6_TIMER_MSECS 500
+#endif
struct dhcp6
{
#endif
/** DNS timer period */
+#ifndef DNS_TMR_INTERVAL
#define DNS_TMR_INTERVAL 1000
+#endif
/* DNS resolve types: */
#define LWIP_DNS_ADDRTYPE_IPV4 0
#endif
/** 1 seconds period */
+#ifndef ARP_TMR_INTERVAL
#define ARP_TMR_INTERVAL 1000
+#endif
#if ARP_QUEUEING
/** struct for queueing outgoing packets for unknown address
#endif
/* IGMP timer */
+#ifndef IGMP_TMR_INTERVAL
#define IGMP_TMR_INTERVAL 100 /* Milliseconds */
-#define IGMP_V1_DELAYING_MEMBER_TMR (1000/IGMP_TMR_INTERVAL)
-#define IGMP_JOIN_DELAYING_MEMBER_TMR (500 /IGMP_TMR_INTERVAL)
+#endif
+
+#ifndef IGMP_V1_DELAYING_MEMBER_TMR
+#define IGMP_V1_DELAYING_MEMBER_TMR 10
+#endif
+
+#ifndef IGMP_JOIN_DELAYING_MEMBER_TMR
+#define IGMP_JOIN_DELAYING_MEMBER_TMR 5
+#endif
/* Compatibility defines (don't use for new code) */
#define IGMP_DEL_MAC_FILTER NETIF_DEL_MAC_FILTER
#if IP_REASSEMBLY
/* The IP reassembly timer interval in milliseconds. */
+#ifndef IP_TMR_INTERVAL
#define IP_TMR_INTERVAL 1000
+#endif
/** IP reassembly helper struct.
* This is exported because memp needs to know the size.
#if LWIP_IPV6 && LWIP_IPV6_REASS /* don't build if not configured for use in lwipopts.h */
/** The IPv6 reassembly timer interval in milliseconds. */
+#ifndef IP6_REASS_TMR_INTERVAL
#define IP6_REASS_TMR_INTERVAL 1000
+#endif
/** IP6_FRAG_COPYHEADER==1: for platforms where sizeof(void*) > 4, "struct
* ip6_reass_helper" is too large to be stored in the IPv6 fragment header, and
void set_lowpower_mod(enum lowpower_mod sw);
enum lowpower_mod get_lowpowper_mod(void);
+typedef enum {
+ LOW_DHCP_MODULE = 0,
+ LOW_DNS_MODULE = 1,
+ LOW_MAX_MODULE,
+} lowpower_module;
+
+void lwip_lowpower_inc(lowpower_module lm);
+void lwip_lowpower_dec(lowpower_module lm);
+
#endif /* LOWEPOWER */
#endif /* LWIP_HDR_LOWPOWER_H */
u8_t use;
};
+#ifndef MLD6_TMR_INTERVAL
#define MLD6_TMR_INTERVAL 100 /* Milliseconds */
+#endif
err_t mld6_stop(struct netif *netif);
void mld6_report_groups(struct netif *netif);
#endif
/** 1 second period */
+#ifndef ND6_TMR_INTERVAL
#define ND6_TMR_INTERVAL 1000
+#endif
/** Router solicitations are sent in 4 second intervals (see RFC 4861, ch. 6.3.7) */
#ifndef ND6_RTR_SOLICITATION_INTERVAL
u8_t c;
u16_t total_bytes = 0;
u16_t escaped_bytes = 0;
-
+ #ifdef LWIP_DEBUGF_OUT
LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output: starting transmission, netif=%p, pbuf=%p, tot_len=%d\n",
netif, p, p ? p->tot_len : 0));
+ #endif
LWIP_ASSERT("netif != NULL", (netif != NULL));
LWIP_ASSERT("netif->state != NULL", (netif->state != NULL));
LWIP_ASSERT("p != NULL", (p != NULL));
priv = (struct slipif_priv *)netif->state;
+ #ifdef LWIP_DEBUGF_OUT
LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output: priv=%p, sd=%p\n", priv, priv->sd));
+ #endif
/* Send pbuf out on the serial I/O device. */
cat1_api_wakeup_cat1(true);
#endif
+ #ifdef LWIP_DEBUGF_OUT
LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output: sending SLIP_END (0xC0) to start packet\n"));
+ #endif
sio_send(SLIP_END, priv->sd);
for (q = p; q != NULL; q = q->next) {
+ #ifdef LWIP_DEBUGF_OUT
LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output: processing pbuf chain, q=%p, len=%d\n", q, q->len));
+ #endif
for (i = 0; i < q->len; i++) {
c = ((u8_t *)q->payload)[i];
total_bytes++;
break;
default:
if (c < 0x20 || c > 0x7E) {
+ #ifdef LWIP_DEBUGF_OUT
LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output: sending control/non-printable byte 0x%02x\n", c));
+ #endif
} else {
+ #ifdef LWIP_DEBUGF_OUT
LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output: sending normal byte 0x%02x ('%c')\n", c, c));
+ #endif
}
sio_send(c, priv->sd);
break;
}
}
+ #ifdef LWIP_DEBUGF_OUT
LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output: sending SLIP_END (0xC0) to end packet\n"));
+ #endif
sio_send(SLIP_END, priv->sd);
/* Flush SIO write buffer to ensure all data is sent before CAT1 sleep */
LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: processing byte 0x%02x\n", c));
struct pbuf *p;
+
+ printf("slipif_rxbyte_input: processing byte 0x%02x\n", c);
+
p = slipif_rxbyte(netif, c);
if (p != NULL) {
- LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: complete packet received, length=%d\n", p->tot_len));
+ LWIP_DEBUGF(TCP_DEBUG, ("slipif_rxbyte_input: complete packet received, length=%d\n", p->tot_len));
+ /* 追踪 pbuf 链,便于与 ip4_input 丢包日志对照 */
+ {
+ struct pbuf *dbg = p;
+ u16_t idx = 0;
+ while (dbg != NULL) {
+ printf("slipif_rxbyte_input: pbuf[%"U16_F"] p=%p len=%"U16_F" tot_len=%"U16_F" next=%p\n",
+ idx, (void *)dbg, dbg->len, dbg->tot_len, (void *)dbg->next);
+ dbg = dbg->next;
+ idx++;
+ }
+ }
if (netif->input(p, netif) != ERR_OK) {
- LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: netif->input failed, freeing pbuf\n"));
+ printf("slipif_rxbyte_input: netif->input failed, freeing pbuf\n");
pbuf_free(p);
} else {
LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: packet sent to IP layer successfully\n"));
p->next = NULL;
// LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: processing pbuf 0x%p, length=%d\n", q, q->tot_len));
+ // printf("slipif_process_rxqueue: processing pbuf 0x%p, length=%d\n", q, q->tot_len);S
/* 释放锁,避免在 netif->input 中长时间持有锁 */
sys_mutex_unlock(&priv->rxqueue_mutex);
public:
NativeapiFs() = default;
~NativeapiFs() = default;
-
+ static int GetFullPath(const char* uri, char* fullPath, int len);
static JSIValue MoveFile(const JSIValue thisVal, const JSIValue* args, uint8_t argsNum);
static JSIValue CopyFile(const JSIValue thisVal, const JSIValue* args, uint8_t argsNum);
static JSIValue DeleteFile(const JSIValue thisVal, const JSIValue* args, uint8_t argsNum);
return true;\r
}\r
\r
-int GetFullPath(const char* uri, char* fullPath, int len)\r
-{\r
- if (!IsValidPath(uri) || (fullPath == nullptr)) {\r
- return ERROR_CODE_PARAM;\r
- }\r
- const char* dataPath = GetDataPath();\r
- int size = PREFIX_LEN;\r
- bool isTrustPath = (strncmp(uri, trustPath, strlen(trustPath)) == 0);\r
- if (isTrustPath) {\r
- size = 0;\r
- }\r
-\r
- if (dataPath == nullptr) {\r
- return ERROR_CODE_PARAM;\r
- }\r
-\r
- if (memset_s(fullPath, len, 0x0, len) != EOK) {\r
- return ERROR_CODE_GENERAL;\r
- }\r
-\r
- if (sprintf_s(fullPath, len, "%s%s", (isTrustPath ? "" : dataPath), uri + size) < 0) {\r
- return ERROR_CODE_GENERAL;\r
- }\r
-\r
- return NATIVE_SUCCESS;\r
-}\r
\r
JSIValue ExecuteAsyncWork(const JSIValue thisVal, const JSIValue* args,\r
uint8_t argsNum, AsyncWorkHandler ExecuteFunc, bool flag = false)\r
char* dest = JSI::GetStringProperty(args, FILE_DESTINATION_URI);\r
char* destFullPath = nullptr;\r
JSIValue result = JSI::CreateUndefined();\r
- int ret = GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
+ int ret = NativeapiFs::GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
JSI::ReleaseString(src);\r
if (ret != NATIVE_SUCCESS) {\r
NativeapiCommon::FailCallBack(thisVal, args, ret);\r
NativeapiCommon::FailCallBack(thisVal, args, ERROR_CODE_GENERAL);\r
goto EXIT;\r
}\r
- ret = GetFullPath(dest, destFullPath, FILE_NAME_MAX_LEN + 1);\r
+ ret = NativeapiFs::GetFullPath(dest, destFullPath, FILE_NAME_MAX_LEN + 1);\r
if (ret != NATIVE_SUCCESS) {\r
NativeapiCommon::FailCallBack(thisVal, args, ret);\r
goto EXIT;\r
JSIValue args = params->args;\r
JSIValue thisVal = params->thisVal;\r
char* src = JSI::GetStringProperty(args, FILE_URI);\r
- int ret = GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
+ int ret = NativeapiFs::GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
JSI::ReleaseString(src);\r
if (ret != NATIVE_SUCCESS) {\r
NativeapiCommon::FailCallBack(thisVal, args, ret);\r
JSIValue thisVal = params->thisVal;\r
char* uri = JSI::GetStringProperty(args, FILE_URI);\r
JSIValue result = JSI::CreateObject();\r
- int ret = GetFullPath(uri, g_uriFullPath, sizeof(g_uriFullPath));\r
+ int ret = NativeapiFs::GetFullPath(uri, g_uriFullPath, sizeof(g_uriFullPath));\r
JSI::ReleaseString(uri);\r
if (ret != NATIVE_SUCCESS) {\r
NativeapiCommon::FailCallBack(thisVal, args, ret);\r
bool recursive = JSI::GetBooleanProperty(args, RECURSIVE);\r
struct stat info = {0};\r
JSIValue result = JSI::CreateObject();\r
- int ret = GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
+ int ret = NativeapiFs::GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
if (ret != NATIVE_SUCCESS) {\r
NativeapiCommon::FailCallBack(thisVal, args, ret);\r
goto EXIT;\r
char* src = JSI::GetStringProperty(args, FILE_URI);\r
char* text = JSI::GetStringProperty(args, TEXT);\r
bool append = JSI::GetBooleanProperty(args, FILE_APPEND);\r
- int ret = GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
+ int ret = NativeapiFs::GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
JSI::ReleaseString(src);\r
if ((text == nullptr) || (ret != NATIVE_SUCCESS)) {\r
NativeapiCommon::FailCallBack(thisVal, args, ERROR_CODE_PARAM);\r
if (length == 0) {\r
length = TEXT_MAX_READ_LEN;\r
}\r
- int ret = GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
+ int ret = NativeapiFs::GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
if (ret != NATIVE_SUCCESS) {\r
return ret;\r
}\r
JSIValue args = params->args;\r
JSIValue thisVal = params->thisVal;\r
char* src = JSI::GetStringProperty(args, FILE_URI);\r
- int ret = GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
+ int ret = NativeapiFs::GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
JSI::ReleaseString(src);\r
bool recursive = JSI::GetBooleanProperty(args, RECURSIVE);\r
if (ret != NATIVE_SUCCESS) {\r
NativeapiCommon::FailCallBack(thisVal, args, ret);\r
goto EXIT;\r
}\r
- ret = GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
+ ret = NativeapiFs::GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
JSI::ReleaseString(src);\r
if (ret != NATIVE_SUCCESS) {\r
NativeapiCommon::FailCallBack(thisVal, args, ret);\r
JSIValue args = params->args;\r
JSIValue thisVal = params->thisVal;\r
char* src = JSI::GetStringProperty(args, FILE_URI);\r
- int ret = GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
+ int ret = NativeapiFs::GetFullPath(src, g_uriFullPath, sizeof(g_uriFullPath));\r
JSI::ReleaseString(src);\r
if (ret != NATIVE_SUCCESS) {\r
NativeapiCommon::FailCallBack(thisVal, args, ret);\r
NativeapiCommon::FailCallBack(thisVal, args, ERROR_CODE_PARAM);\r
goto EXIT;\r
}\r
- ret = WriteArrayFile(g_uriFullPath, arrayPtr, length, static_cast<int>(position), append);\r
+ ret = WriteArrayFile(g_uriFullPath, arrayPtr + byteOffset, length, static_cast<int>(position), append);\r
JSI::ReleaseValueList(buffer, arrayBuffer, ARGS_END);\r
if (ret != NATIVE_SUCCESS) {\r
NativeapiCommon::FailCallBack(thisVal, args, ret);\r
#endif\r
}\r
\r
+int NativeapiFs::GetFullPath(const char* uri, char* fullPath, int len)\r
+{\r
+ if (!IsValidPath(uri) || (fullPath == nullptr)) {\r
+ return ERROR_CODE_PARAM;\r
+ }\r
+ const char* dataPath = GetDataPath();\r
+ int size = PREFIX_LEN;\r
+ bool isTrustPath = (strncmp(uri, trustPath, strlen(trustPath)) == 0);\r
+ if (isTrustPath) {\r
+ size = 0;\r
+ }\r
+\r
+ if (dataPath == nullptr) {\r
+ return ERROR_CODE_PARAM;\r
+ }\r
+\r
+ if (memset_s(fullPath, len, 0x0, len) != EOK) {\r
+ return ERROR_CODE_GENERAL;\r
+ }\r
+\r
+ if (sprintf_s(fullPath, len, "%s%s", (isTrustPath ? "" : dataPath), uri + size) < 0) {\r
+ return ERROR_CODE_GENERAL;\r
+ }\r
+\r
+ return NATIVE_SUCCESS;\r
+}\r
+\r
JSIValue NativeapiFs::MoveFile(const JSIValue thisVal, const JSIValue* args, uint8_t argsNum)\r
{\r
return ExecuteAsyncWork(thisVal, args, argsNum, ExecuteCopyFile, true);\r
--- /dev/null
+/*
+ * Copyright (c) @CompanyNameMagicTag 2024. All rights reserved.
+ * Description: BLE ICCE (In-Car Communication Experience) Client for vehicle control.
+ * Reference: ble_ancs_client.
+ */
+
+#ifndef BLE_ICCE_CLIENT_H
+#define BLE_ICCE_CLIENT_H
+
+#include "errcode.h"
+#include "osal_list.h"
+#include "bts_gatt_client.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * ICCE GATT UUID(16-bit 映射到 BLE SIG 128-bit 基 UUID:
+ * 0000xxxx-0000-1000-8000-00805f9b34fb)
+ *
+ * 典型句柄布局(示例):服务 FFF5 → FFFD(写) → FFFE(读+Notify) → 其下 0x2902(CCCD)。
+ * - 对端业务数据经 FFFE 的 Notification 下发;本端回调里 data->handle 一般为 FFFE 的 value_handle。
+ * - 「订阅 FFFE」在协议上 = 对挂在 FFFE 下的 Client Characteristic Configuration(0x2902) 写 0x0001
+ * (使能 Notification),不能向 FFFE 值句柄写「订阅开关」。
+ */
+#define BLE_ICCE_SERVICE_UUID 0xFFF5
+
+#define BLE_ICCE_CHAR_WRITE_UUID 0xFFFD
+#define BLE_ICCE_CHAR_READ_UUID 0xFFFE
+
+/* 兼容旧命名:Control Point=写特征,Status=读/Notify 特征 */
+#define BLE_ICCE_CHAR_CTRL_POINT_UUID BLE_ICCE_CHAR_WRITE_UUID
+#define BLE_ICCE_CHAR_STATUS_UUID BLE_ICCE_CHAR_READ_UUID
+
+/** FFFE 下的 CCCD(UUID 0x2902),写此描述符以开关本特征 Notify/Indication(本实现仅使用 Notify) */
+#define BLE_ICCE_GATT_CCCD_UUID 0x2902
+
+/** CCC 小端 16bit:0=关;bit0=1 表示使能 Notification(与 ble_bas_client 写 CCCD 一致) */
+#define BLE_ICCE_CCC_DEFAULT 0x0000
+#define BLE_ICCE_CCC_NOTIFICATION 0x0001
+
+typedef enum {
+ ICCE_CLIENT_NOTIFY_DISABLE = 0,
+ ICCE_CLIENT_NOTIFY_ENABLE = 1,
+} icce_client_notify_enable_t;
+
+typedef enum {
+ ICCE_CHAR_CTRL_POINT = 0,
+ ICCE_CHAR_STATUS = 1,
+ ICCE_CHAR_INVALID,
+} icce_character_t;
+
+/** ICCE 服务句柄信息(发现完成后缓存,供写 FFFD / 读&订阅 FFFE) */
+typedef struct {
+ struct osal_list_head node;
+ uint8_t client_id;
+ uint16_t conn_id;
+ uint16_t start_handle;
+ uint16_t end_handle;
+ gattc_discovery_character_result_t ctrl_point; /*!< FFFD 写特征 */
+ gattc_discovery_character_result_t status; /*!< FFFE 读+Notify 特征 */
+ uint16_t status_ccc_handle; /*!< FFFE 下属 0x2902 的句柄;ble_icce_client_subscribe_status 写此句柄开 Notify */
+} ble_icce_service_t;
+
+/** 车辆控制命令(写入 Control Point 特征) */
+typedef enum {
+ ICCE_CMD_LOCK_DOORS = 0x01,
+ ICCE_CMD_UNLOCK_DOORS = 0x02,
+ ICCE_CMD_TRUNK_OPEN = 0x03,
+ ICCE_CMD_TRUNK_CLOSE = 0x04,
+ ICCE_CMD_HONK = 0x05,
+ ICCE_CMD_FLASH_LIGHTS = 0x06,
+ ICCE_CMD_CUSTOM = 0xFF,
+} icce_vehicle_cmd_t;
+
+/** 建立完成回调 */
+typedef void (*icce_client_setup_cbk)(uint8_t client_id, uint16_t conn_id, errcode_t status);
+/** 订阅结果回调 */
+typedef void (*icce_client_subscribe_cbk)(uint8_t client_id, uint16_t conn_id, gatt_status_t status);
+/** 车辆状态:仅由 GATT Notification 触发(ble_icce_client_notify_cbk),Read 走 status_read_cb */
+typedef void (*icce_client_notify_cbk)(uint8_t client_id, uint16_t conn_id, uint8_t *data, uint16_t len);
+/** FFFE 特征 Read 响应(ble_icce_client_read_cbk,gattc_read_req_by_handle 成功且 handle 为 status 值句柄) */
+typedef void (*icce_client_status_read_cbk)(uint8_t client_id, uint16_t conn_id,
+ const uint8_t *data, uint16_t len);
+/** 写 Control Point 结果回调 */
+typedef void (*icce_client_write_cbk)(uint8_t client_id, uint16_t conn_id, gatt_status_t status);
+
+typedef struct {
+ icce_client_setup_cbk setup_cb;
+ icce_client_subscribe_cbk subscribe_cb;
+ icce_client_notify_cbk notify_cb;
+ icce_client_status_read_cbk status_read_cb; /*!< 可为 NULL */
+ icce_client_write_cbk write_cb;
+} ble_icce_client_callbacks_t;
+
+/** 发起 ICCE 服务发现 */
+errcode_t ble_icce_client_setup_service(uint8_t client_id, uint16_t conn_id);
+
+void ble_icce_client_discovery_service_cbk(uint8_t client_id, uint16_t conn_id,
+ gattc_discovery_service_result_t *service);
+void ble_icce_client_discovery_character_cbk(uint8_t client_id, uint16_t conn_id,
+ gattc_discovery_character_result_t *character);
+void ble_icce_client_discovery_descriptor_cbk(uint8_t client_id, uint16_t conn_id,
+ gattc_discovery_descriptor_result_t *descriptor);
+
+/**
+ * 对 FFFE 下的 CCCD(0x2902) 写 BLE_ICCE_CCC_*,使能/关闭对端对 FFFE 的 Notification。
+ * 与 ble_bas_client_write_ccc_descriptor 用法一致(gattc_write_req + 2 字节小端 CCC)。
+ */
+errcode_t ble_icce_client_subscribe_status(uint8_t client_id, uint16_t conn_id,
+ icce_client_notify_enable_t enable);
+
+/** 主动 Read FFFE 特征值(调试用;业务首帧以 Notify 为准时可不用) */
+errcode_t ble_icce_client_read_status_value(uint8_t client_id, uint16_t conn_id);
+
+/** 发送车辆控制命令 (cmd_id + optional payload) */
+errcode_t ble_icce_client_send_vehicle_cmd(uint8_t client_id, uint16_t conn_id,
+ uint8_t cmd_id, const uint8_t *payload, uint16_t payload_len);
+
+/** 写入 Control Point:整段为 ICCE 线帧(以 SOF 0x5A 开头),不再前置 cmd_id 字节 */
+errcode_t ble_icce_client_send_icce_frame_raw(uint8_t client_id, uint16_t conn_id,
+ const uint8_t *frame, uint16_t frame_len);
+
+/** 协议栈 notification_cb → 仅此处上送 notify_cb */
+void ble_icce_client_notify_cbk(uint8_t client_id, uint16_t conn_id, gattc_handle_value_t *data);
+/** 协议栈 read_cb → 打日志;若注册了 status_read_cb 则上送 FFFE Read 数据(不上送 notify_cb) */
+void ble_icce_client_read_cbk(uint8_t client_id, uint16_t conn_id, gattc_handle_value_t *read_result,
+ gatt_status_t status);
+void ble_icce_client_write_cbk(uint8_t client_id, uint16_t conn_id, uint16_t handle, gatt_status_t status);
+
+errcode_t ble_icce_client_register_callbacks(ble_icce_client_callbacks_t *cb);
+bool is_ble_icce_service(bt_uuid_t *uuid);
+void ble_icce_client_clear_remote_by_conn(uint8_t client_id, uint16_t conn_id);
+void ble_icce_client_clear_remote_all(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* BLE_ICCE_CLIENT_H */
${CMAKE_CURRENT_SOURCE_DIR}/ble_gatts_callbacks.c
${CMAKE_CURRENT_SOURCE_DIR}/ble_ancs_client.c
${CMAKE_CURRENT_SOURCE_DIR}/ble_ams_client.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/ble_icce_client.c
)
set(BTH_SAMPLE_LIST "${BTH_SAMPLE_LIST}" "${bt_comm_src_list}" CACHE INTERNAL "bt ram obj list" FORCE)
#include "ble_fmp_locator.h"
#include "ble_ancs_client.h"
#include "ble_ams_client.h"
+#include "ble_icce_client.h"
#include "ble_gatts_callbacks.h"
uint32_t g_ble_gatt_mtu_size = 23;
ble_ancs_client_discovery_service_cbk(client_id, conn_id, service);
} else if (is_ble_ams_service(&service->uuid)) {
ble_ams_client_discovery_service_cbk(client_id, conn_id, service);
+ } else if (is_ble_icce_service(&service->uuid)) {
+ ble_icce_client_discovery_service_cbk(client_id, conn_id, service);
}
}
ble_dis_client_discovery_character_cbk(client_id, conn_id, character);
ble_ancs_client_discovery_character_cbk(client_id, conn_id, character);
ble_ams_client_discovery_character_cbk(client_id, conn_id, character);
+ ble_icce_client_discovery_character_cbk(client_id, conn_id, character);
}
}
ble_bas_client_discovery_descriptor_cbk(client_id, conn_id, descriptor);
ble_ancs_client_discovery_descriptor_cbk(client_id, conn_id, descriptor);
ble_ams_client_discovery_descriptor_cbk(client_id, conn_id, descriptor);
+ ble_icce_client_discovery_descriptor_cbk(client_id, conn_id, descriptor);
}
static void ble_client_read_cbk(uint8_t client_id, uint16_t conn_id, gattc_handle_value_t *read_result,
ble_bas_client_read_cbk(client_id, conn_id, read_result, status);
ble_dis_client_read_cbk(client_id, conn_id, read_result, status);
ble_ams_client_read_cbk(client_id, conn_id, read_result, status);
+ ble_icce_client_read_cbk(client_id, conn_id, read_result, status);
}
static void ble_client_write_cbk(uint8_t client_id, uint16_t conn_id, uint16_t handle, gatt_status_t status)
ble_ancs_client_write_cbk(client_id, conn_id, handle, status);
ble_ams_client_write_cbk(client_id, conn_id, handle, status);
+ ble_icce_client_write_cbk(client_id, conn_id, handle, status);
}
static void ble_client_notification_cbk(uint8_t client_id, uint16_t conn_id, gattc_handle_value_t *data,
{
bts_sample_info_log("[BLE]client notification cbk client_id: %u conn_id: %hu status: %u handle: %hu \n",
client_id, conn_id, status, data->handle);
+ printf("ble_client_notification_cbk ok \r\n");
if (status != ERRCODE_BT_SUCCESS) {
return;
}
ble_bas_client_notify_characteristic_cbk(client_id, conn_id, data);
ble_ancs_client_notify_cbk(client_id, conn_id, data);
ble_ams_client_notify_cbk(client_id, conn_id, data);
+ ble_icce_client_notify_cbk(client_id, conn_id, data);
}
static void ble_client_mtu_exchange_result_cbk(uint8_t client_id, uint16_t conn_id, uint16_t mtu_size, errcode_t status)
bts_sample_info_log("[BLE]client MTU changed cbk: status: %u client_id: %u conn_id: %u mtu:%u.\r\n",
status, client_id, conn_id, mtu_size);
g_ble_gatt_mtu_size = mtu_size;
+ printf("ble_client_mtu_exchange_result_cbk ok mtu_size: %u\r\n", mtu_size);
}
errcode_t ble_client_register_gatt_callbacks(void)
--- /dev/null
+/*
+ * Copyright (c) @CompanyNameMagicTag 2024. All rights reserved.
+ * Description: BLE ICCE Client for vehicle control. Reference: ble_ancs_client.c
+ *
+ * GATT 客户端侧约定:
+ * - 发现服务 FFF5 → 特征 FFFD(写)、FFFE(读+Notify)。
+ * - 仅对 FFFE 的「特征声明句柄」发起 gattc_discovery_descriptor,在其子描述符中查找 UUID=0x2902(CCCD),
+ * 句柄须大于 FFFE 的 value_handle,记入 status_ccc_handle。
+ * - ble_icce_client_subscribe_status:对 status_ccc_handle 写 0x0001 = 使能对端经 FFFE 下发的 Notification;
+ * 与 ble_bas_client_write_ccc_descriptor 同属「写 CCCD 开 Notify」,并非向 FFFE 值句柄写订阅。
+ */
+
+#include <string.h>
+#include "errcode.h"
+#include "osal_addr.h"
+#include "sample_common.h"
+#include "bts_le_gap.h"
+#include "ble_icce_client.h"
+
+/* 日志文件 ID:若芯片日志未定义 BLE_ICCE_CLIENT_C,则别名为 BLE_ANCS_CLIENT_C 以避免编译错误。 */
+#ifndef BLE_ICCE_CLIENT_C
+#define BLE_ICCE_CLIENT_C BLE_ANCS_CLIENT_C
+#endif
+
+/* 与 bleICCE.c 的 ICCE_LOG 一致:不依赖 g_bth_log_type_level,便于联调 GATT 发现/通知。 */
+#define ICCE_CLI_LOG(fmt, ...) printf("[ICCE_CLI]" fmt "\r\n", ##__VA_ARGS__)
+
+static void icce_cli_log_hex_prefix(const char *tag, const uint8_t *buf, uint16_t len, uint16_t max_dump)
+{
+ static const char hexch[] = "0123456789ABCDEF";
+ char line[96];
+ uint16_t n = (len < max_dump) ? len : max_dump;
+ uint16_t i, p = 0;
+
+ for (i = 0; i < n && p + 2 < sizeof(line); i++) {
+ line[p++] = hexch[(buf[i] >> 4) & 0x0F];
+ line[p++] = hexch[buf[i] & 0x0F];
+ }
+ line[p] = '\0';
+ ICCE_CLI_LOG("%s len=%u hex[%u]=%s%s", tag, (unsigned)len, (unsigned)n, line, (len > n) ? "..." : "");
+}
+
+/* CCC 16bit 拆成 GATT 小端两字节(低字节在前),同 ble_bas_client 中 bas_16_low_byte/high_byte */
+#define u16_low_byte(data) ((uint8_t)((data) & 0x00FF))
+#define u16_high_byte(data) ((uint8_t)(((data) & 0xFF00) >> 8))
+
+/* ICCE 服务及特征 128-bit UUID(与 SIG 基 UUID 下 16-bit:FFF5 / FFFD / FFFE 一致,小端存前两字节) */
+uint8_t icce_service_uuid[BT_UUID_MAX_LEN] = {
+ 0xF5, 0xFF, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00,
+ 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB, 0x00, 0x00
+};
+
+/* Write:0000fffd-0000-1000-8000-00805f9b34fb */
+uint8_t icce_ctrl_point_uuid[BT_UUID_MAX_LEN] = {
+ 0xFD, 0xFF, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00,
+ 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB, 0x00, 0x00
+};
+
+/* Read + Notify 特征本体:0000fffe-0000-1000-8000-00805f9b34fb;CCC 另见 0x2902 */
+uint8_t icce_status_uuid[BT_UUID_MAX_LEN] = {
+ 0xFE, 0xFF, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00,
+ 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB, 0x00, 0x00
+};
+
+ble_icce_client_callbacks_t g_icce_callbacks = {0};
+
+OSAL_LIST_HEAD(g_ble_icce_service_list);
+
+static ble_icce_service_t *icce_service_by_conn(uint8_t client_id, uint16_t conn_id)
+{
+ struct osal_list_head *list_head = &g_ble_icce_service_list;
+ struct osal_list_head *node = list_head->next;
+ while (node != NULL && node != list_head) {
+ ble_icce_service_t *svc = (ble_icce_service_t *)node;
+ if (svc->client_id == client_id && svc->conn_id == conn_id) {
+ return svc;
+ }
+ node = node->next;
+ }
+ return NULL;
+}
+
+/* CCC 写成功后打印句柄快照:FFFE=业务通知承载;0x0F 等为 CCCD,表示已对该 FFFE 打开 Notify */
+static void icce_cli_log_subscribe_ok_snapshot(const ble_icce_service_t *svc)
+{
+ if (svc == NULL) {
+ return;
+ }
+ ICCE_CLI_LOG("subscribe_ok: svc_hdl [0x%04X,0x%04X]", svc->start_handle, svc->end_handle);
+ ICCE_CLI_LOG("subscribe_ok: ctrl(FFFD) decl=0x%04X val=0x%04X prop=0x%02X",
+ svc->ctrl_point.declare_handle, svc->ctrl_point.value_handle, svc->ctrl_point.properties);
+ ICCE_CLI_LOG("subscribe_ok: status(FFFE) decl=0x%04X val=0x%04X prop=0x%02X",
+ svc->status.declare_handle, svc->status.value_handle, svc->status.properties);
+ ICCE_CLI_LOG("subscribe_ok: FFFE-CCCD(2902) hdl=0x%04X (Notify 已使能,数据仍经 FFFE val 上报)",
+ svc->status_ccc_handle);
+}
+
+static icce_character_t icce_char_match(bt_uuid_t *uuid)
+{
+ /* 先匹配 128bit UUID(参考 ANCS 模式),再兼容 16bit UUID 宏。 */
+ if (uuid->uuid_len == BT_UUID_MAX_LEN) {
+ bt_uuid_t tmp = {0};
+ tmp.uuid_len = BT_UUID_MAX_LEN;
+ if (memcpy_s(tmp.uuid, BT_UUID_MAX_LEN, icce_ctrl_point_uuid, BT_UUID_MAX_LEN) == EOK &&
+ memcmp(&tmp, uuid, sizeof(bt_uuid_t)) == 0) {
+ printf("icce_char_match: ICCE_CHAR_CTRL_POINT\n");
+ printf("icce_char_match: uuid=0x%02X%02X\n", uuid->uuid[0], uuid->uuid[1]);
+ printf("icce_char_match: tmp=0x%02X%02X\n", tmp.uuid[0], tmp.uuid[1]);
+ printf("icce_char_match: memcmp=%u\n", memcmp(&tmp, uuid, sizeof(bt_uuid_t)));
+ return ICCE_CHAR_CTRL_POINT;
+ }
+ if (memcpy_s(tmp.uuid, BT_UUID_MAX_LEN, icce_status_uuid, BT_UUID_MAX_LEN) == EOK &&
+ memcmp(&tmp, uuid, sizeof(bt_uuid_t)) == 0) {
+ printf("icce_char_match: ICCE_CHAR_STATUS\n");
+ printf("icce_char_match: uuid=0x%02X%02X\n", uuid->uuid[0], uuid->uuid[1]);
+ printf("icce_char_match: tmp=0x%02X%02X\n", tmp.uuid[0], tmp.uuid[1]);
+ printf("icce_char_match: memcmp=%u\n", memcmp(&tmp, uuid, sizeof(bt_uuid_t)));
+ return ICCE_CHAR_STATUS;
+ }
+ return ICCE_CHAR_INVALID;
+ }
+
+ /* 兼容 16bit UUID 情况 */
+ bt_uuid_t u = {0};
+ bts_sample_data_to_uuid_len2(BLE_ICCE_CHAR_CTRL_POINT_UUID, &u);
+ if (bts_sample_bt_gatts_cmp_uuid(uuid, &u)) {
+ return ICCE_CHAR_CTRL_POINT;
+ }
+ bts_sample_data_to_uuid_len2(BLE_ICCE_CHAR_STATUS_UUID, &u);
+ if (bts_sample_bt_gatts_cmp_uuid(uuid, &u)) {
+ printf("icce_char_match: ICCE_CHAR_STATUS\n");
+ printf("icce_char_match: uuid=0x%02X%02X\n", uuid->uuid[0], uuid->uuid[1]);
+ printf("icce_char_match: u=0x%02X%02X\n", u.uuid[0], u.uuid[1]);
+ printf("icce_char_match: memcmp=%u\n", bts_sample_bt_gatts_cmp_uuid(uuid, &u));
+ return ICCE_CHAR_STATUS;
+ }
+ return ICCE_CHAR_INVALID;
+}
+
+errcode_t ble_icce_client_setup_service(uint8_t client_id, uint16_t conn_id)
+{
+ ICCE_CLI_LOG("setup_service enter client_id=%u conn_id=%u", client_id, conn_id);
+ if (icce_service_by_conn(client_id, conn_id) != NULL) {
+ bts_sample_error_log("[ICCE] service already exist client_id:%u conn_id:%u\r\n", client_id, conn_id);
+ ICCE_CLI_LOG("setup_service skip: cache already has service");
+ return ERRCODE_BT_DONE;
+ }
+ bt_uuid_t service_uuid = {0};
+ bts_sample_data_to_uuid_len2(BLE_ICCE_SERVICE_UUID, &service_uuid);
+ errcode_t ret = gattc_discovery_service(client_id, conn_id, &service_uuid);
+ ICCE_CLI_LOG("setup_service gattc_discovery_service ret=0x%X", ret);
+ bts_sample_info_log("[ICCE_CLI] discovery_service req ret=%u client=%u conn=%u\r\n",
+ (unsigned int)ret, client_id, conn_id);
+ return ret;
+}
+
+void ble_icce_client_discovery_service_cbk(uint8_t client_id, uint16_t conn_id,
+ gattc_discovery_service_result_t *service)
+{
+ ICCE_CLI_LOG("discovery_service_cbk client_id=%u conn_id=%u start=0x%04X end=0x%04X",
+ client_id, conn_id, service->start_hdl, service->end_hdl);
+ if (icce_service_by_conn(client_id, conn_id) != NULL) {
+ ICCE_CLI_LOG("discovery_service_cbk: ignore duplicate (svc already cached)");
+ return;
+ }
+ ble_icce_service_t *svc = (ble_icce_service_t *)bts_sample_mem_new(sizeof(ble_icce_service_t));
+ if (svc == NULL) {
+ bts_sample_error_log("[ICCE] alloc service fail\r\n");
+ return;
+ }
+ svc->client_id = client_id;
+ svc->conn_id = conn_id;
+ svc->start_handle = service->start_hdl;
+ svc->end_handle = service->end_hdl;
+ svc->status_ccc_handle = 0;
+ osal_list_add_tail((struct osal_list_head *)svc, &g_ble_icce_service_list);
+
+ gattc_discovery_character_param_t param = {0};
+ param.service_handle = svc->start_handle;
+ errcode_t dret = gattc_discovery_character(client_id, conn_id, ¶m);
+ ICCE_CLI_LOG("discovery_character req ret=0x%X service_handle=0x%04X", dret, svc->start_handle);
+}
+
+void ble_icce_client_discovery_character_cbk(uint8_t client_id, uint16_t conn_id,
+ gattc_discovery_character_result_t *character)
+{
+ ble_icce_service_t *svc = icce_service_by_conn(client_id, conn_id);
+ if (svc == NULL) {
+ ICCE_CLI_LOG("discovery_character_cbk: no svc for client_id=%u conn_id=%u (drop)",
+ client_id, conn_id);
+ return;
+ }
+ if (character->declare_handle < svc->start_handle || character->declare_handle > svc->end_handle) {
+ ICCE_CLI_LOG("discovery_character_cbk: decl=0x%04X out of svc [0x%04X,0x%04X] (ignore)",
+ character->declare_handle, svc->start_handle, svc->end_handle);
+ return;
+ }
+
+ icce_character_t ch = icce_char_match(&character->uuid);
+ ICCE_CLI_LOG("discovery_character_cbk decl=0x%04X val=0x%04X prop=0x%02X match=%d uuid_len=%u",
+ character->declare_handle, character->value_handle, character->properties, (int)ch,
+ character->uuid.uuid_len);
+
+ switch (ch) {
+ case ICCE_CHAR_CTRL_POINT:
+ svc->ctrl_point.declare_handle = character->declare_handle;
+ svc->ctrl_point.value_handle = character->value_handle;
+ svc->ctrl_point.properties = character->properties;
+
+ break;
+ case ICCE_CHAR_STATUS:
+ svc->status.declare_handle = character->declare_handle;
+ svc->status.value_handle = character->value_handle;
+ svc->status.properties = character->properties;
+ /* 在 FFFE 特征下发现 0x2902(CCCD),供后续写 0x0001 打开 Notify */
+ {
+ errcode_t deret = gattc_discovery_descriptor(client_id, conn_id, character->declare_handle);
+ ICCE_CLI_LOG("discovery_descriptor req ret=0x%X for status decl=0x%04X", deret,
+ character->declare_handle);
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+/* 只采纳「FFFE 上发现的、UUID=0x2902、且句柄在 FFFE 值句柄之后」的 CCCD,避免误绑其他特征 */
+void ble_icce_client_discovery_descriptor_cbk(uint8_t client_id, uint16_t conn_id,
+ gattc_discovery_descriptor_result_t *descriptor)
+{
+ ble_icce_service_t *svc = icce_service_by_conn(client_id, conn_id);
+ if (svc == NULL) {
+ ICCE_CLI_LOG("discovery_descriptor_cbk: no svc client_id=%u conn_id=%u (drop)", client_id, conn_id);
+ return;
+ }
+ if (descriptor->descriptor_hdl < svc->start_handle || descriptor->descriptor_hdl > svc->end_handle) {
+ ICCE_CLI_LOG("discovery_descriptor_cbk: desc=0x%04X out of range [0x%04X,0x%04X]",
+ descriptor->descriptor_hdl, svc->start_handle, svc->end_handle);
+ return;
+ }
+ bt_uuid_t ccc_uuid = {0};
+ bts_sample_data_to_uuid_len2(BLE_ICCE_GATT_CCCD_UUID, &ccc_uuid);
+ ICCE_CLI_LOG("discovery_descriptor_cbk hdl=0x%04X status_val=0x%04X ccc_match=%u",
+ descriptor->descriptor_hdl, svc->status.value_handle,
+ (unsigned int)bts_sample_bt_gatts_cmp_uuid(&ccc_uuid, &descriptor->uuid));
+ if (!bts_sample_bt_gatts_cmp_uuid(&ccc_uuid, &descriptor->uuid)) {
+ ICCE_CLI_LOG("discovery_descriptor_cbk: not CCCD, skip");
+ return;
+ }
+ else
+ {
+ printf("discovery_descriptor_cbk: CCCD found\n");
+ printf("discovery_descriptor_cbk: descriptor_hdl=0x%04X\n", descriptor->descriptor_hdl);
+ printf("discovery_descriptor_cbk: status_val=0x%04X\n", svc->status.value_handle);
+ printf("discovery_descriptor_cbk: ccc_uuid=0x%02X%02X\n", ccc_uuid.uuid[0], ccc_uuid.uuid[1]);
+ printf("discovery_descriptor_cbk: descriptor_uuid=0x%02X%02X\n", descriptor->uuid.uuid[0], descriptor->uuid.uuid[1]);
+ }
+ if (svc->status.value_handle != 0 && descriptor->descriptor_hdl > svc->status.value_handle) {
+ svc->status_ccc_handle = descriptor->descriptor_hdl;
+ ICCE_CLI_LOG("discovery_descriptor_cbk: status_ccc_handle=0x%04X", svc->status_ccc_handle);
+ } else {
+ ICCE_CLI_LOG("discovery_descriptor_cbk: CCCD not applied (status_val=0x%04X desc=0x%04X)",
+ svc->status.value_handle, descriptor->descriptor_hdl);
+ }
+ if (svc->status_ccc_handle != 0 && g_icce_callbacks.setup_cb != NULL) {
+ ICCE_CLI_LOG("discovery_descriptor_cbk: invoke setup_cb");
+ g_icce_callbacks.setup_cb(client_id, conn_id, ERRCODE_BT_SUCCESS);
+ } else if (svc->status_ccc_handle == 0) {
+ ICCE_CLI_LOG("discovery_descriptor_cbk: setup_cb not fired (status_ccc_handle still 0)");
+ }
+}
+
+/*
+ * 对 FFFE 的 CCCD(status_ccc_handle) 写 2 字节 CCC,使能/关闭对端 Notification。
+ * 与 ble_bas_client_write_ccc_descriptor 一致:gattc_write_req,写句柄为 0x2902,非 FFFE 值句柄。
+ */
+errcode_t ble_icce_client_subscribe_status(uint8_t client_id, uint16_t conn_id,
+ icce_client_notify_enable_t enable)
+{
+ ble_icce_service_t *svc = icce_service_by_conn(client_id, conn_id);
+ if (svc == NULL || svc->status_ccc_handle == 0) {
+ ICCE_CLI_LOG("subscribe_status NOT_READY svc=%p status_ccc=0x%04X",
+ (void *)svc, svc ? svc->status_ccc_handle : 0);
+ return ERRCODE_BT_NOT_READY;
+ }
+ uint16_t ccc = (enable == ICCE_CLIENT_NOTIFY_ENABLE) ? BLE_ICCE_CCC_NOTIFICATION : BLE_ICCE_CCC_DEFAULT;
+ uint8_t val[] = { u16_low_byte(ccc), u16_high_byte(ccc) };
+ gattc_handle_value_t value = {0};
+ value.handle = svc->status_ccc_handle;
+ value.data_len = 2;
+ value.data = val;
+ ICCE_CLI_LOG("subscribe_status write CCC handle=0x%04X val=0x%04X enable=%u",
+ svc->status_ccc_handle, ccc, (unsigned int)enable);
+ errcode_t ret = gattc_write_req(client_id, conn_id, &value);
+ ICCE_CLI_LOG("subscribe_status gattc_write_req ret=0x%X", ret);
+ bts_sample_info_log("[ICCE_CLI] subscribe CCC write ret=%u h=0x%04X\r\n",
+ (unsigned int)ret, svc->status_ccc_handle);
+ return ret;
+}
+
+errcode_t ble_icce_client_send_vehicle_cmd(uint8_t client_id, uint16_t conn_id,
+ uint8_t cmd_id, const uint8_t *payload, uint16_t payload_len)
+{
+ ble_icce_service_t *svc = icce_service_by_conn(client_id, conn_id);
+ if (svc == NULL || svc->ctrl_point.value_handle == 0) {
+ ICCE_CLI_LOG("send_vehicle_cmd NOT_READY svc=%p ctrl_val=0x%04X",
+ (void *)svc, svc ? svc->ctrl_point.value_handle : 0);
+ return ERRCODE_BT_NOT_READY;
+ }
+ if (payload_len > 0 && payload == NULL) {
+ return ERRCODE_BT_PARAM_ERR;
+ }
+ uint16_t total = 1 + payload_len;
+ uint8_t *data = (uint8_t *)bts_sample_mem_new(total);
+ if (data == NULL) {
+ return ERRCODE_BT_FAIL;
+ }
+ data[0] = cmd_id;
+ if (payload_len > 0 && memcpy_s(data + 1, payload_len, payload, payload_len) != EOK) {
+ bts_sample_mem_free(data);
+ return ERRCODE_BT_FAIL;
+ }
+ gattc_handle_value_t value = {0};
+ value.handle = svc->ctrl_point.value_handle;
+ value.data_len = total;
+ value.data = data;
+ errcode_t ret = gattc_write_req(client_id, conn_id, &value);
+ ICCE_CLI_LOG("send_vehicle_cmd h=0x%04X total_len=%u cmd=0x%02X ret=0x%X",
+ svc->ctrl_point.value_handle, (unsigned)total, cmd_id, ret);
+ icce_cli_log_hex_prefix("send_vehicle_cmd payload", data, total, 32);
+ bts_sample_mem_free(data);
+ return ret;
+}
+
+errcode_t ble_icce_client_send_icce_frame_raw(uint8_t client_id, uint16_t conn_id,
+ const uint8_t *frame, uint16_t frame_len)
+{
+ ble_icce_service_t *svc = icce_service_by_conn(client_id, conn_id);
+ if (svc == NULL || svc->ctrl_point.value_handle == 0) {
+ ICCE_CLI_LOG("send_icce_frame_raw NOT_READY svc=%p ctrl_val=0x%04X",
+ (void *)svc, svc ? svc->ctrl_point.value_handle : 0);
+ return ERRCODE_BT_NOT_READY;
+ }
+ if (frame_len == 0 || frame == NULL) {
+ return ERRCODE_BT_PARAM_ERR;
+ }
+ uint8_t *data = (uint8_t *)bts_sample_mem_new(frame_len);
+ if (data == NULL) {
+ return ERRCODE_BT_FAIL;
+ }
+ if (memcpy_s(data, frame_len, frame, frame_len) != EOK) {
+ bts_sample_mem_free(data);
+ return ERRCODE_BT_FAIL;
+ }
+ gattc_handle_value_t value = {0};
+ value.handle = svc->ctrl_point.value_handle;
+ value.data_len = frame_len;
+ value.data = data;
+ errcode_t ret = gattc_write_req(client_id, conn_id, &value);
+ bts_sample_mem_free(data);
+ return ret;
+}
+
+/*
+ * 协议栈 GATT Notification 入口(ble_gatts_callbacks → ble_client_notification_cbk)。
+ * 仅此处调用 notify_cb;Read 响应在 ble_icce_client_read_cbk 中处理,不得再冒充 Notify。
+ */
+void ble_icce_client_notify_cbk(uint8_t client_id, uint16_t conn_id, gattc_handle_value_t *data)
+{
+ if (data == NULL) {
+ ICCE_CLI_LOG("notify_cbk drop: data=NULL");
+ return;
+ }
+ ble_icce_service_t *svc = icce_service_by_conn(client_id, conn_id);
+ if (svc == NULL || data->handle != svc->status.value_handle) {
+ ICCE_CLI_LOG("notify_cbk drop: svc=%p h=0x%04X expect FFFE val=0x%04X",
+ (void *)svc, data->handle, svc ? svc->status.value_handle : 0);
+ return;
+ }
+ ICCE_CLI_LOG("notify_cbk: GATT Notification h=0x%04X len=%u → notify_cb",
+ data->handle, (unsigned)data->data_len);
+ if (g_icce_callbacks.notify_cb != NULL) {
+ g_icce_callbacks.notify_cb(client_id, conn_id, data->data, data->data_len);
+ }
+}
+
+errcode_t ble_icce_client_read_status_value(uint8_t client_id, uint16_t conn_id)
+{
+ ble_icce_service_t *svc = icce_service_by_conn(client_id, conn_id);
+ if (svc == NULL || svc->status.value_handle == 0) {
+ ICCE_CLI_LOG("read_status_value NOT_READY svc=%p status_val_h=0x%04X",
+ (void *)svc, svc ? svc->status.value_handle : 0);
+ return ERRCODE_BT_NOT_READY;
+ }
+ ICCE_CLI_LOG("read_status_value gattc_read_req_by_handle h=0x%04X", svc->status.value_handle);
+ return gattc_read_req_by_handle(client_id, conn_id, svc->status.value_handle);
+}
+
+/* GATT Read 响应:打日志/hex;若注册 status_read_cb 则上送 FFFE 数据(不调用 notify_cb) */
+void ble_icce_client_read_cbk(uint8_t client_id, uint16_t conn_id, gattc_handle_value_t *read_result,
+ gatt_status_t status)
+{
+ if (read_result == NULL) {
+ ICCE_CLI_LOG("read_cbk read_result=NULL");
+ return;
+ }
+ ble_icce_service_t *svc = icce_service_by_conn(client_id, conn_id);
+ ICCE_CLI_LOG("read_cbk client_id=%u conn_id=%u h=0x%04X len=%u status=0x%X expect_status_h=0x%04X",
+ client_id, conn_id, read_result->handle, read_result->data_len, (unsigned int)status,
+ svc ? svc->status.value_handle : 0);
+ if (status != GATT_STATUS_SUCCESS) {
+ ICCE_CLI_LOG("read_cbk: non-success status, drop");
+ return;
+ }
+ if (svc == NULL || read_result->handle != svc->status.value_handle) {
+ ICCE_CLI_LOG("read_cbk: wrong handle or no svc, drop");
+ return;
+ }
+ if (read_result->data == NULL || read_result->data_len == 0) {
+ ICCE_CLI_LOG("read_cbk: empty data");
+ return;
+ }
+ icce_cli_log_hex_prefix("read_cbk payload", read_result->data, read_result->data_len, 48);
+ if (g_icce_callbacks.status_read_cb != NULL) {
+ g_icce_callbacks.status_read_cb(client_id, conn_id, read_result->data, read_result->data_len);
+ }
+}
+
+void ble_icce_client_write_cbk(uint8_t client_id, uint16_t conn_id, uint16_t handle, gatt_status_t status)
+{
+ ble_icce_service_t *svc = icce_service_by_conn(client_id, conn_id);
+ ICCE_CLI_LOG("write_cbk client_id=%u conn_id=%u h=0x%04X status=0x%X svc=%p ccc=0x%04X ctrl=0x%04X",
+ client_id, conn_id, handle, (unsigned int)status, (void *)svc,
+ svc ? svc->status_ccc_handle : 0, svc ? svc->ctrl_point.value_handle : 0);
+ if (svc == NULL) {
+ return;
+ }
+ if (handle == svc->status_ccc_handle && g_icce_callbacks.subscribe_cb != NULL) {
+ if (status == GATT_STATUS_SUCCESS) {
+ icce_cli_log_subscribe_ok_snapshot(svc);
+ printf("subscribe_cbk: subscribe_ok\n");
+ gattc_read_req_by_handle(client_id, conn_id,handle);
+ } else {
+ ICCE_CLI_LOG("subscribe_fail: CCC write status=0x%X", (unsigned int)status);
+ }
+ ICCE_CLI_LOG("write_cbk -> subscribe_cb");
+ g_icce_callbacks.subscribe_cb(client_id, conn_id, status);
+ } else if (handle == svc->ctrl_point.value_handle && g_icce_callbacks.write_cb != NULL) {
+ ICCE_CLI_LOG("write_cbk -> write_cb (ctrl point)");
+ g_icce_callbacks.write_cb(client_id, conn_id, status);
+ } else {
+ ICCE_CLI_LOG("write_cbk: no route (unexpected handle or cb NULL)");
+ }
+}
+
+errcode_t ble_icce_client_register_callbacks(ble_icce_client_callbacks_t *cb)
+{
+ if (cb == NULL) {
+ return ERRCODE_BT_PARAM_ERR;
+ }
+ if (memcpy_s(&g_icce_callbacks, sizeof(g_icce_callbacks), cb, sizeof(ble_icce_client_callbacks_t)) != EOK) {
+ return ERRCODE_BT_FAIL;
+ }
+ return ERRCODE_BT_SUCCESS;
+}
+
+bool is_ble_icce_service(bt_uuid_t *uuid)
+{
+ /* 优先按 128bit UUID 判断 */
+ if (uuid->uuid_len == BT_UUID_MAX_LEN) {
+ bt_uuid_t tmp = {0};
+ tmp.uuid_len = BT_UUID_MAX_LEN;
+ if (memcpy_s(tmp.uuid, BT_UUID_MAX_LEN, icce_service_uuid, BT_UUID_MAX_LEN) != EOK) {
+ return false;
+ }
+ return (memcmp(&tmp, uuid, sizeof(bt_uuid_t)) == 0);
+ }
+
+ /* 兼容 16bit 短 UUID 判断 */
+ bt_uuid_t icce_uuid = {0};
+ bts_sample_data_to_uuid_len2(BLE_ICCE_SERVICE_UUID, &icce_uuid);
+ return bts_sample_bt_gatts_cmp_uuid(uuid, &icce_uuid);
+}
+
+void ble_icce_client_clear_remote_by_conn(uint8_t client_id, uint16_t conn_id)
+{
+ ble_icce_service_t *svc = icce_service_by_conn(client_id, conn_id);
+ if (svc != NULL) {
+ osal_list_del((struct osal_list_head *)svc);
+ bts_sample_mem_free(svc);
+ }
+}
+
+void ble_icce_client_clear_remote_all(void)
+{
+ while (osal_list_empty(&g_ble_icce_service_list) == false) {
+ struct osal_list_head *node = g_ble_icce_service_list.next;
+ osal_list_del(node);
+ bts_sample_mem_free(node);
+ }
+}
#include "lwip/inet.h"
#include "cat1_tcpServer.h"
+// #define BOARD_LEINIAO
+
/* Define htons function if not available */
#ifndef htons
static inline u16_t htons(u16_t n)
// #include <string.h>
// #include <sys/param.h>
#include <string.h>
+#include <stdbool.h>
#define __DEFINED_struct_timeval
#include "tcxo.h"
#include "cat1_utils.h"
#include "cmsis_os.h"
+#include "cmsis_os2.h"
#include "ConfigModelC.h"
#ifdef BOARD_LEINIAO
void udp_send_msg_toCat1(uint8_t cmd,char *content);
/** 0: old format 1字节cmd, 1: new format 2字节cmd */
-static uint8_t g_msg_format_type = 0;
+static uint8_t g_msg_format_type = 1;
// void watch_replay_cat1_ANSWER(void);
void cat1_get_DEV_ID(void);
+static bool cat1_is_bridge_reply_msg(const char *msg);
+
+/** 模组 lnudp 桥启动后 Python 通过 1C 应答时释放,供 ln_tcp 等阻塞等待 */
+static osSemaphoreId_t g_cat1_bridge_ready_sem = NULL;
+/** TCP 客户端已被 lnudp accept 后 Python 应答(内容含 tcp)时释放,开始收发前再等待 */
+static osSemaphoreId_t g_cat1_bridge_tcp_ready_sem = NULL;
+
+static void cat1_bridge_ready_sem_ensure(void)
+{
+ if (g_cat1_bridge_ready_sem == NULL) {
+ g_cat1_bridge_ready_sem = osSemaphoreNew(1, 0, NULL);
+ }
+}
+
+static void cat1_bridge_tcp_ready_sem_ensure(void)
+{
+ if (g_cat1_bridge_tcp_ready_sem == NULL) {
+ g_cat1_bridge_tcp_ready_sem = osSemaphoreNew(1, 0, NULL);
+ }
+}
+
+errcode_t cat1_udp_bridge_wait_ready(uint32_t timeout_ms)
+{
+ cat1_bridge_ready_sem_ensure();
+ if (g_cat1_bridge_ready_sem == NULL) {
+ return ERRCODE_FAIL;
+ }
+ if (osSemaphoreAcquire(g_cat1_bridge_ready_sem, timeout_ms) != osOK) {
+ return ERRCODE_FAIL;
+ }
+ return ERRCODE_SUCC;
+}
+
+errcode_t cat1_udp_bridge_wait_tcp_ready(uint32_t timeout_ms)
+{
+ cat1_bridge_tcp_ready_sem_ensure();
+ if (g_cat1_bridge_tcp_ready_sem == NULL) {
+ return ERRCODE_FAIL;
+ }
+ if (osSemaphoreAcquire(g_cat1_bridge_tcp_ready_sem, timeout_ms) != osOK) {
+ return ERRCODE_FAIL;
+ }
+ return ERRCODE_SUCC;
+}
uint8_t g_py_ver_new = 0;
if (strncmp(ptmp,"PY_SRV_V",8)==0 && strlen(ptmp)>8)
{
int pyver = atoi(ptmp+8);
- if ( pyver > 0 ) g_py_ver = pyver;
+ if ( pyver > 0 ) g_py_ver = 0;//pyver;
}
}else if ((strncmp(s,"modemVer",8) == 0) && (strlen(s)> 8))
void cat1_gettime(void)
{
cat1_print_dbg("UDP_CMD_GET_TIME\n");
+ printf("UDP_CMD_GET_TIME\n");
+
udp_send_msg_toCat1(UDP_CMD_GET_TIME,"0");
}
}
cat1_gettime();
#endif
+
static uint8_t g_signal_already_updated = 0;
static uint8_t g_ws_idle = 0; //ToDo:此处应该从系统中获取业务是否执行,只有空闲状态才可以更新。
static uint8_t need_update_signal = 0;
udp_send_msg_toCat1(UDP_MSG_SEND_AI_ID,"0");
}
+static bool cat1_is_bridge_reply_msg(const char *msg)
+{
+ if (msg == NULL) {
+ printf("cat1_is_bridge_reply_msg msg is NULL\n");
+ return false;
+ }
+ if (strstr(msg, "bridge ") != NULL ||
+ strstr(msg, "start failed") != NULL ||
+ strstr(msg, "unknown action") != NULL ||
+ strstr(msg, "bridge error") != NULL) {
+ printf("cat1_is_bridge_reply_msg msg is bridge reply msg\n");
+ return true;
+ }
+ printf("cat1_is_bridge_reply_msg msg is not bridge reply msg\n");
+ return false;
+}
+
+errcode_t cat1_udp_bridge_start(const char *udp_host, uint16_t udp_port)
+{
+ printf("cat1_udp_bridge_start udp_host %s, udp_port %u\n", udp_host, udp_port);
+
+ if (udp_host == NULL || udp_host[0] == '\0' || udp_port == 0) {
+ printf("cat1_udp_bridge_start udp_host %s, udp_port %u is invalid\n", udp_host, udp_port);
+ return ERRCODE_INVALID_PARAM;
+ }
+
+ char ctrl_buf[192] = {0};
+ int ret = snprintf_s(ctrl_buf, sizeof(ctrl_buf), sizeof(ctrl_buf) - 1,
+ "start,%s,%u",
+ udp_host, (unsigned)udp_port);
+ if (ret <= 0) {
+ return ERRCODE_FAIL;
+ }
+
+ udp_send_msg_toCat1(UDP_MSG_SEND_AI_ID, ctrl_buf);
+ printf("cat1_udp_bridge_start ctrl_buf %s\n", ctrl_buf);
+ return ERRCODE_SUCC;
+}
+
+errcode_t cat1_udp_bridge_stop(void)
+{
+ udp_send_msg_toCat1(UDP_MSG_SEND_AI_ID, "stop");
+ return ERRCODE_SUCC;
+}
+
+errcode_t cat1_udp_bridge_status(void)
+{
+ udp_send_msg_toCat1(UDP_MSG_SEND_AI_ID, "status");
+ return ERRCODE_SUCC;
+}
+
void cat1_start_tcp_ota_init(void)
{
cat1_print_dbg("UDP_MSG_TCP_OTA_INIT\n");
// uapi_save_runtime_log(RUNTIME_LOG_CAT1_UDP_MSG_SMS);
break;
case UDP_MSG_SEND_AI_ID:
- set_cmai_dev_id(msg_buffer);
+ if (cat1_is_bridge_reply_msg(msg_buffer)) {
+ printf("cat1 bridge reply: %s\n", msg_buffer);
+ /* 含 tcp:表示模组侧 TCP 已接入桥,仅释放 TCP 就绪信号量;否则为 lnudp 桥进程已启动 */
+ if (strstr(msg_buffer, "tcp") != NULL) {
+ if (g_cat1_bridge_tcp_ready_sem != NULL) {
+ (void)osSemaphoreRelease(g_cat1_bridge_tcp_ready_sem);
+ }
+ } else {
+ if (g_cat1_bridge_ready_sem != NULL) {
+ (void)osSemaphoreRelease(g_cat1_bridge_ready_sem);
+ }
+ }
+ if (g_msg_callback_func != NULL) {
+ g_msg_callback_func(MESSAGE_4G_AT_RECEIVED, msg_buffer, strlen(msg_buffer));
+ }
+ } else {
+ set_cmai_dev_id(msg_buffer);
+ }
break;
default:
cat1_print_err("error message: %s\n", rx_buffer);
return listen_sock;
}
-#include "cmsis_os2.h"
extern osStatus_t osDelay(uint32_t ticks);
#define cat1_msleep(ms) osDelay(ms) /* osDelay(1) : 1ms */
void cat1_server_task(void *pvParameters)
void cat_sync_timer_control(int cmd);
+/**
+ * @brief 控制模组侧 UDP 桥接服务(对应 cat1Service.py 的 1C 指令)
+ * @param udp_host 云端 UDP 服务器地址
+ * @param udp_port 云端 UDP 端口
+ * @return ERRCODE_SUCC 成功,其他失败
+ */
+errcode_t cat1_udp_bridge_start(const char *udp_host, uint16_t udp_port);
+
+/**
+ * @brief 停止模组侧 UDP 桥接服务
+ */
+errcode_t cat1_udp_bridge_stop(void);
+
+/**
+ * @brief 查询模组侧 UDP 桥接服务状态
+ */
+errcode_t cat1_udp_bridge_status(void);
+
+/**
+ * @brief 阻塞等待模组侧 UDP 桥(lnudp)就绪应答(对应 Python reply_cmd 1C 且内容含 bridge)
+ * @param timeout_ms 超时毫秒,0 表示使用内核默认
+ * @return ERRCODE_SUCC 收到应答,超时或失败返回其它 errcode
+ */
+errcode_t cat1_udp_bridge_wait_ready(uint32_t timeout_ms);
+
+/**
+ * @brief 阻塞等待模组侧 TCP 已接入 lnudp 桥(Python 应答内容含 tcp,如 bridge tcp client ready)
+ */
+errcode_t cat1_udp_bridge_wait_tcp_ready(uint32_t timeout_ms);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
break;
}
return ERRCODE_SUCC;
-}
+}
errcode_t cat1_api_porting_init(void)
{
set(SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/AI_mian.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/ai_api_at.c
+
)
set(PUBLIC_HEADER
)
set(PUBLIC_DEFINES
+ ENABLE_CTAI_SERVER=1
+ SUPPORT_AT_AI_API
)
# use this when you want to add ccflags like -include xxx
--- /dev/null
+#include "at_cmd_api.h"
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include "errcode.h"
+#include "zj_aiagent.h"
+#include "agent.h"
+#include "main_include.h"
+
+#define ARRAY_COUNT(array) (sizeof(array) / sizeof(array[0]))
+#define AI_MAX_ARGC 8
+#define AI_MAX_ARGV_LEN 512
+#define AI_FAILED (-1)
+#define AI_SUCCESS (0)
+
+/* Indicate that a local variable is not used */
+#define AI_UNUSED(a) ((void)(a))
+
+/* 回调函数声明 */
+static int create_new_session_rsp_cb(int iReqId, unsigned char* pucSessionID, int iRspCode);
+static int agent_interrupt_session_rsp_cb(int iReqId, int iRspCode);
+static int agent_upload_pic_cb(int iReqId, int iCode, unsigned char *pucFileID);
+static int agent_get_retrieve_chat_history_cb(int iReqId, ST_ZJ_HistoryChat* pstHistoryChatList, int iRspCode);
+static int agent_delete_session_round_cb(unsigned int uiReqID, int iRsp);
+static int agent_get_suggest_ques_list_cb(unsigned int uiReqID, ST_ZJ_QUES_ITEM* pstList);
+static int agent_rename_session_round_cb(unsigned int uiReqID, int iRsp);
+static int agent_get_session_meta_cb(unsigned int uiReqID, int iRsp, unsigned char* pucDalle2, unsigned char* pucBackGround, unsigned char* pucContent);
+
+static int ConvertCmdToParam(uint8_t *para, uint32_t paraLen, uint8_t argv[AI_MAX_ARGC][AI_MAX_ARGV_LEN], uint32_t *argc)
+{
+ uint32_t pos = 0;
+ *argc = 0;
+
+ for (uint32_t i = 0; i < paraLen; i++)
+ {
+ /* 以空格/换行/逗号/等号作为分隔符,兼容 "AT^CMD=arg1,arg2" 或 "AT^CMD arg1 arg2" */
+ if ((para[i] == ' ' || para[i] == '\n' || para[i] == ',' || para[i] == '=') && pos != 0)
+ {
+ argv[*argc][pos] = '\0';
+ *argc += 1;
+ pos = 0;
+ if (*argc >= AI_MAX_ARGC)
+ {
+ return AI_FAILED;
+ }
+ }
+ else
+ {
+ if (para[i] == ' ' || para[i] == '\n' || para[i] == ',' || para[i] == '=') {
+ continue; /* 连续分隔符跳过 */
+ }
+ argv[*argc][pos] = para[i];
+ pos++;
+ if (pos >= AI_MAX_ARGV_LEN)
+ {
+ return AI_FAILED;
+ }
+ }
+ }
+ if (pos != 0)
+ {
+ argv[*argc][pos] = '\0';
+ *argc += 1;
+ }
+
+ return AI_SUCCESS;
+}
+
+/* ==================== 回调函数实现 ==================== */
+
+/* 创建新会话回调 */
+static int create_new_session_rsp_cb(int iReqId, unsigned char* pucSessionID, int iRspCode)
+{
+ if (iRspCode != 0) {
+ printf("[AI][CREATE_SESSION] Failed, code: %d\n", iRspCode);
+ return -1;
+ }
+ memset(agent_getInfo()->agent_session_id, 0, sizeof(agent_getInfo()->agent_session_id));
+ strncpy(agent_getInfo()->agent_session_id, pucSessionID, sizeof(agent_getInfo()->agent_session_id) - 1);
+ memset(agent_getInfo()->turn_id, 0, sizeof(agent_getInfo()->turn_id));
+ printf("[AI][CREATE_SESSION] Success, session_id: %s\n", pucSessionID);
+ return 0;
+}
+
+/* 中断会话回调 */
+static int agent_interrupt_session_rsp_cb(int iReqId, int iRspCode)
+{
+ printf("[AI][INTERRUPT_SESSION] Response code: %d\n", iRspCode);
+ return 0;
+}
+
+/* 上传图片回调 */
+static int agent_upload_pic_cb(int iReqId, int iCode, unsigned char *pucFileID)
+{
+ if (iCode != 0) {
+ printf("[AI][UPLOAD_PICTURE] Failed, code: %d\n", iCode);
+ return -1;
+ }
+ printf("[AI][UPLOAD_PICTURE] Success, file_id: %s\n", pucFileID);
+ strcpy(agent_getInfo()->agent_file_id, pucFileID);
+ return 0;
+}
+
+/* 获取历史会话回调 */
+static int agent_get_retrieve_chat_history_cb(int iReqId, ST_ZJ_HistoryChat* pstHistoryChatList, int iRspCode)
+{
+ if (iRspCode != 0) {
+ printf("[AI][GET_CHAT_HISTORY] Failed, code: %d\n", iRspCode);
+ return -1;
+ }
+
+ ST_ZJ_HistoryChat* pstTmpNode = NULL;
+ while (pstHistoryChatList)
+ {
+ pstTmpNode = pstHistoryChatList;
+ pstHistoryChatList = pstHistoryChatList->pstNext;
+
+ printf("[AI][GET_CHAT_HISTORY] TurnID: %s\n", pstTmpNode->aucTurnID);
+ printf("[AI][GET_CHAT_HISTORY] Prompt: %s\n", pstTmpNode->pucPrompt);
+ printf("[AI][GET_CHAT_HISTORY] ContentUrl: %s\n", pstTmpNode->aucContentUrl);
+ printf("[AI][GET_CHAT_HISTORY] AudioUrl: %s\n", pstTmpNode->aucAudioUrl);
+ printf("[AI][GET_CHAT_HISTORY] PictureUrl: %s\n", pstTmpNode->aucPictureUrl);
+ }
+ return 0;
+}
+
+/* 删除会话轮次回调 */
+static int agent_delete_session_round_cb(unsigned int uiReqID, int iRsp)
+{
+ printf("[AI][DELETE_SESSION_ROUND] reqid %u response code %d\n", uiReqID, iRsp);
+ return 0;
+}
+
+/* 获取建议问题列表回调 */
+static int agent_get_suggest_ques_list_cb(unsigned int uiReqID, ST_ZJ_QUES_ITEM* pstList)
+{
+ ST_ZJ_QUES_ITEM* pstTmpNode = pstList;
+ while (pstTmpNode)
+ {
+ printf("[AI][GET_SUGGEST_QUESTIONS] Question: %s\n", pstTmpNode->pucQuestion);
+ pstTmpNode = pstTmpNode->pstNext;
+ }
+ return 0;
+}
+
+/* 重命名会话轮次回调 */
+static int agent_rename_session_round_cb(unsigned int uiReqID, int iRsp)
+{
+ printf("[AI][RENAME_SESSION_ROUND] reqID %u response code %d\n", uiReqID, iRsp);
+ return 0;
+}
+
+/* 获取会话meta信息回调 */
+static int agent_get_session_meta_cb(unsigned int uiReqID, int iRsp, unsigned char* pucDalle2, unsigned char* pucBackGround, unsigned char* pucContent)
+{
+ if (iRsp != 0) {
+ printf("[AI][GET_SESSION_META] reqID %u response code %d\n", uiReqID, iRsp);
+ } else {
+ printf("[AI][GET_SESSION_META] reqID %u dalle2: %s background: %s content: %s\n",
+ uiReqID, pucDalle2, pucBackGround, pucContent);
+ }
+ return 0;
+}
+
+/* ==================== AT命令实现 ==================== */
+
+/* AT^AI_CREATE_SESSION[=agentID] */
+static uint32_t ai_create_session_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ AI_UNUSED(strCommonCmd);
+
+ unsigned int uiAgentID = 0;
+
+ if (para != NULL && paraLen > 0) {
+ uint8_t argv[AI_MAX_ARGC][AI_MAX_ARGV_LEN] = {0};
+ uint32_t argc = 0;
+
+ if (ConvertCmdToParam(para, paraLen, argv, &argc) == AI_SUCCESS && argc >= 1) {
+ uiAgentID = atoi((char*)argv[0]);
+ } else {
+ printf("ERROR: Failed to parse agentID parameter\n");
+ printf("Usage: AT^AI_CREATE_SESSION=<agentID>\n");
+ return ERRCODE_FAIL;
+ }
+ } else {
+ printf("ERROR: Missing agentID parameter\n");
+ printf("Usage: AT^AI_CREATE_SESSION=<agentID>\n");
+ return ERRCODE_FAIL;
+ }
+
+ printf("[AI][CREATE_SESSION] Creating session with agentID: %u\n", uiAgentID);
+
+ int ret = ZJ_CreateNewSession(ZJ_GetOneReqId(), uiAgentID, create_new_session_rsp_cb);
+ if (ret != 0) {
+ printf("[AI][CREATE_SESSION] Failed: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+/* AT^AI_INTERRUPT_SESSION */
+static uint32_t ai_interrupt_session_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ AI_UNUSED(para);
+ AI_UNUSED(paraLen);
+ AI_UNUSED(strCommonCmd);
+
+ if (agent_getInfo()->agent_session_id[0] == '\0') {
+ printf("ERROR: No active session\n");
+ return ERRCODE_FAIL;
+ }
+
+ printf("[AI][INTERRUPT_SESSION] Interrupting session: %s\n", agent_getInfo()->agent_session_id);
+
+ int ret = ZJ_InterruptSession(ZJ_GetOneReqId(), agent_getInfo()->agent_session_id,
+ agent_getInfo()->turn_id, agent_interrupt_session_rsp_cb);
+ if (ret != 0) {
+ printf("[AI][INTERRUPT_SESSION] Failed: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+/* AT^AI_SEND_TEXT_QUESTION=<question> */
+static uint32_t ai_send_text_question_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ AI_UNUSED(strCommonCmd);
+
+ if (agent_getInfo()->agent_session_id[0] == '\0') {
+ printf("ERROR: No active session, please create session first\n");
+ return ERRCODE_FAIL;
+ }
+
+ const char *question = "";
+
+ if (para != NULL && paraLen > 0) {
+ uint8_t argv[AI_MAX_ARGC][AI_MAX_ARGV_LEN] = {0};
+ uint32_t argc = 0;
+
+ if (ConvertCmdToParam(para, paraLen, argv, &argc) == AI_SUCCESS && argc >= 1) {
+ question = (const char *)argv[0];
+ } else {
+ printf("ERROR: Failed to parse question parameter\n");
+ printf("Usage: AT^AI_SEND_TEXT_QUESTION=<question>\n");
+ return ERRCODE_FAIL;
+ }
+ } else {
+ printf("ERROR: Missing question parameter\n");
+ printf("Usage: AT^AI_SEND_TEXT_QUESTION=<question>\n");
+ return ERRCODE_FAIL;
+ }
+
+ printf("[AI][SEND_TEXT_QUESTION] Sending question: %s\n", question);
+
+ int ret = ZJ_SendQuestionToAIAgent(0, agent_getInfo()->agent_session_id,
+ agent_getInfo()->turn_id, (unsigned char*)question, NULL);
+ if (ret != 0) {
+ printf("[AI][SEND_TEXT_QUESTION] Failed: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+/* AT^AI_UPLOAD_PICTURE=<pic_path> */
+static uint32_t ai_upload_picture_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ AI_UNUSED(strCommonCmd);
+
+ const char *pic_path = "";
+
+ if (para != NULL && paraLen > 0) {
+ uint8_t argv[AI_MAX_ARGC][AI_MAX_ARGV_LEN] = {0};
+ uint32_t argc = 0;
+
+ if (ConvertCmdToParam(para, paraLen, argv, &argc) == AI_SUCCESS && argc >= 1) {
+ pic_path = (const char *)argv[0];
+ } else {
+ printf("ERROR: Failed to parse picture path parameter\n");
+ printf("Usage: AT^AI_UPLOAD_PICTURE=<pic_path>\n");
+ return ERRCODE_FAIL;
+ }
+ } else {
+ printf("ERROR: Missing picture path parameter\n");
+ printf("Usage: AT^AI_UPLOAD_PICTURE=<pic_path>\n");
+ return ERRCODE_FAIL;
+ }
+
+ FILE* fp = fopen(pic_path, "rb");
+ if (fp == NULL) {
+ printf("ERROR: Failed to open file: %s, errno: %d\n", pic_path, errno);
+ return ERRCODE_FAIL;
+ }
+
+ fseek(fp, 0, SEEK_END);
+ size_t uiBuffSize = ftell(fp);
+ unsigned char* pucPicBuff = (unsigned char*)malloc(uiBuffSize);
+ if (pucPicBuff == NULL) {
+ fclose(fp);
+ printf("ERROR: Failed to allocate memory\n");
+ return ERRCODE_FAIL;
+ }
+
+ fseek(fp, 0, SEEK_SET);
+ fread(pucPicBuff, 1, uiBuffSize, fp);
+ fclose(fp);
+
+ /* 从路径中提取文件名 */
+ const char *pic_name = strrchr(pic_path, '/');
+ if (pic_name == NULL) {
+ pic_name = pic_path;
+ } else {
+ pic_name++; /* 跳过 '/' */
+ }
+
+ printf("[AI][UPLOAD_PICTURE] Uploading picture: %s (size: %zu bytes)\n", pic_name, uiBuffSize);
+
+ int ret = ZJ_UploadPicture(ZJ_GetOneReqId(), (unsigned char*)pic_name, pucPicBuff,
+ uiBuffSize, agent_upload_pic_cb);
+ free(pucPicBuff);
+
+ if (ret != 0) {
+ printf("[AI][UPLOAD_PICTURE] Failed: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+/* AT^AI_SEND_VOICE_START */
+static uint32_t ai_send_voice_start_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ AI_UNUSED(para);
+ AI_UNUSED(paraLen);
+ AI_UNUSED(strCommonCmd);
+
+ if (agent_getInfo()->agent_session_id[0] == '\0') {
+ printf("ERROR: No active session, please create session first\n");
+ return ERRCODE_FAIL;
+ }
+
+ printf("[AI][SEND_VOICE_START] Starting voice question\n");
+
+ int ret = ZJ_SendVoiceDataToAIAgent(NULL, 0, 0);
+ if (ret != 0) {
+ printf("[AI][SEND_VOICE_START] Failed: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+/* AT^AI_SEND_VOICE_DATA=<voice_path> */
+static uint32_t ai_send_voice_data_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ AI_UNUSED(strCommonCmd);
+
+ if (agent_getInfo()->agent_session_id[0] == '\0') {
+ printf("ERROR: No active session, please create session first\n");
+ return ERRCODE_FAIL;
+ }
+
+ const char *voice_path = "";
+
+ if (para != NULL && paraLen > 0) {
+ uint8_t argv[AI_MAX_ARGC][AI_MAX_ARGV_LEN] = {0};
+ uint32_t argc = 0;
+
+ if (ConvertCmdToParam(para, paraLen, argv, &argc) == AI_SUCCESS && argc >= 1) {
+ voice_path = (const char *)argv[0];
+ } else {
+ printf("ERROR: Failed to parse voice path parameter\n");
+ printf("Usage: AT^AI_SEND_VOICE_DATA=<voice_path>\n");
+ return ERRCODE_FAIL;
+ }
+ } else {
+ printf("ERROR: Missing voice path parameter\n");
+ printf("Usage: AT^AI_SEND_VOICE_DATA=<voice_path>\n");
+ return ERRCODE_FAIL;
+ }
+
+ FILE* fp = fopen(voice_path, "rb");
+ if (fp == NULL) {
+ printf("ERROR: Failed to open file: %s, errno: %d\n", voice_path, errno);
+ return ERRCODE_FAIL;
+ }
+
+ fseek(fp, 0, SEEK_END);
+ int iSize = ftell(fp);
+ fseek(fp, 0, SEEK_SET);
+
+ unsigned char aucAudioPacket[6400];
+ int num_chunks = iSize / 6400;
+ int remain = iSize % 6400;
+ int bytes_read = 0;
+ int iReadLen = 0;
+
+ printf("[AI][SEND_VOICE_DATA] Sending voice data from: %s (size: %d bytes)\n", voice_path, iSize);
+
+ /* 先发送开始信号 */
+ ZJ_SendVoiceDataToAIAgent(NULL, 0, 0);
+
+ while (bytes_read < iSize)
+ {
+ int read_size = (num_chunks > 0) ? 6400 : remain;
+ iReadLen = fread(aucAudioPacket, 1, read_size, fp);
+ num_chunks--;
+ bytes_read += iReadLen;
+
+ ZJ_SendVoiceDataToAIAgent(aucAudioPacket, iReadLen, 1);
+ /* 模拟单声道 采样率16000 每帧6400字节 = 200ms时长 */
+ usleep(200000);
+ }
+
+ /* 发送结束信号 */
+ ZJ_SendVoiceDataToAIAgent(NULL, 0, 2);
+ fclose(fp);
+
+ printf("[AI][SEND_VOICE_DATA] Voice data sent successfully\n");
+ return ERRCODE_SUCC;
+}
+
+/* AT^AI_SEND_VOICE_END */
+static uint32_t ai_send_voice_end_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ AI_UNUSED(para);
+ AI_UNUSED(paraLen);
+ AI_UNUSED(strCommonCmd);
+
+ printf("[AI][SEND_VOICE_END] Ending voice question\n");
+
+ int ret = ZJ_SendVoiceDataToAIAgent(NULL, 0, 2);
+ if (ret != 0) {
+ printf("[AI][SEND_VOICE_END] Failed: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+/* AT^AI_GET_CHAT_HISTORY */
+static uint32_t ai_get_chat_history_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ AI_UNUSED(para);
+ AI_UNUSED(paraLen);
+ AI_UNUSED(strCommonCmd);
+
+ if (agent_getInfo()->agent_session_id[0] == '\0') {
+ printf("ERROR: No active session, please create session first\n");
+ return ERRCODE_FAIL;
+ }
+
+ printf("[AI][GET_CHAT_HISTORY] Getting chat history for session: %s\n", agent_getInfo()->agent_session_id);
+
+ int ret = ZJ_GetRetrieveChatHistory(ZJ_GetOneReqId(), agent_getInfo()->agent_session_id,
+ agent_get_retrieve_chat_history_cb);
+ if (ret != 0) {
+ printf("[AI][GET_CHAT_HISTORY] Failed: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+/* AT^AI_DELETE_SESSION_ROUND */
+static uint32_t ai_delete_session_round_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ AI_UNUSED(para);
+ AI_UNUSED(paraLen);
+ AI_UNUSED(strCommonCmd);
+
+ if (agent_getInfo()->agent_session_id[0] == '\0') {
+ printf("ERROR: No active session, please create session first\n");
+ return ERRCODE_FAIL;
+ }
+
+ if (agent_getInfo()->turn_id[0] == '\0') {
+ printf("ERROR: No active turn, please send a question first\n");
+ return ERRCODE_FAIL;
+ }
+
+ printf("[AI][DELETE_SESSION_ROUND] Deleting session round: %s, turn: %s\n",
+ agent_getInfo()->agent_session_id, agent_getInfo()->turn_id);
+
+ int ret = ZJ_DeleteSessionRound(ZJ_GetOneReqId(), agent_getInfo()->agent_session_id,
+ agent_getInfo()->turn_id, agent_delete_session_round_cb);
+ if (ret != 0) {
+ printf("[AI][DELETE_SESSION_ROUND] Failed: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+/* AT^AI_GET_SUGGEST_QUESTIONS */
+static uint32_t ai_get_suggest_questions_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ AI_UNUSED(para);
+ AI_UNUSED(paraLen);
+ AI_UNUSED(strCommonCmd);
+
+ if (agent_getInfo()->agent_session_id[0] == '\0') {
+ printf("ERROR: No active session, please create session first\n");
+ return ERRCODE_FAIL;
+ }
+
+ if (agent_getInfo()->turn_id[0] == '\0') {
+ printf("ERROR: No active turn, please send a question first\n");
+ return ERRCODE_FAIL;
+ }
+
+ printf("[AI][GET_SUGGEST_QUESTIONS] Getting suggest questions for session: %s, turn: %s\n",
+ agent_getInfo()->agent_session_id, agent_getInfo()->turn_id);
+
+ int ret = ZJ_GetSuggestQuesList(ZJ_GetOneReqId(), agent_getInfo()->agent_session_id,
+ agent_getInfo()->turn_id, agent_get_suggest_ques_list_cb);
+ if (ret != 0) {
+ printf("[AI][GET_SUGGEST_QUESTIONS] Failed: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+/* AT^AI_RENAME_SESSION_ROUND[=new_name] */
+static uint32_t ai_rename_session_round_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ AI_UNUSED(strCommonCmd);
+
+ if (agent_getInfo()->agent_session_id[0] == '\0') {
+ printf("ERROR: No active session, please create session first\n");
+ return ERRCODE_FAIL;
+ }
+
+ if (agent_getInfo()->turn_id[0] == '\0') {
+ printf("ERROR: No active turn, please send a question first\n");
+ return ERRCODE_FAIL;
+ }
+
+ const char *new_name = "test_name";
+
+ if (para != NULL && paraLen > 0) {
+ uint8_t argv[AI_MAX_ARGC][AI_MAX_ARGV_LEN] = {0};
+ uint32_t argc = 0;
+
+ if (ConvertCmdToParam(para, paraLen, argv, &argc) == AI_SUCCESS && argc >= 1) {
+ new_name = (const char *)argv[0];
+ }
+ }
+
+ printf("[AI][RENAME_SESSION_ROUND] Renaming session round: %s, turn: %s, new_name: %s\n",
+ agent_getInfo()->agent_session_id, agent_getInfo()->turn_id, new_name);
+
+ int ret = ZJ_RenameSessionRound(ZJ_GetOneReqId(), agent_getInfo()->agent_session_id,
+ agent_getInfo()->turn_id, (unsigned char *)new_name,
+ agent_rename_session_round_cb);
+ if (ret != 0) {
+ printf("[AI][RENAME_SESSION_ROUND] Failed: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+/* AT^AI_GET_SESSION_META */
+static uint32_t ai_get_session_meta_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ AI_UNUSED(para);
+ AI_UNUSED(paraLen);
+ AI_UNUSED(strCommonCmd);
+
+ if (agent_getInfo()->agent_session_id[0] == '\0') {
+ printf("ERROR: No active session, please create session first\n");
+ return ERRCODE_FAIL;
+ }
+
+ printf("[AI][GET_SESSION_META] Getting session meta for session: %s\n", agent_getInfo()->agent_session_id);
+
+ int ret = ZJ_GetSessionMetaInfo(ZJ_GetOneReqId(), agent_getInfo()->agent_session_id,
+ agent_get_session_meta_cb);
+ if (ret != 0) {
+ printf("[AI][GET_SESSION_META] Failed: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+/* ==================== AT命令表 ==================== */
+static const at_cmd_table_t g_ai_api_cmd[] = {
+ {(char *)"AT^AI_CREATE_SESSION", ai_create_session_at, (char *)"创建AI会话: AT^AI_CREATE_SESSION=<agentID>"},
+ {(char *)"AT^AI_INTERRUPT_SESSION", ai_interrupt_session_at, (char *)"中断AI会话: AT^AI_INTERRUPT_SESSION"},
+ {(char *)"AT^AI_SEND_TEXT_QUESTION", ai_send_text_question_at, (char *)"发送文本提问: AT^AI_SEND_TEXT_QUESTION=<question>"},
+ {(char *)"AT^AI_UPLOAD_PICTURE", ai_upload_picture_at, (char *)"上传图片: AT^AI_UPLOAD_PICTURE=<pic_path>"},
+ {(char *)"AT^AI_SEND_VOICE_START", ai_send_voice_start_at, (char *)"开始语音提问: AT^AI_SEND_VOICE_START"},
+ {(char *)"AT^AI_SEND_VOICE_DATA", ai_send_voice_data_at, (char *)"发送语音数据: AT^AI_SEND_VOICE_DATA=<voice_path>"},
+ {(char *)"AT^AI_SEND_VOICE_END", ai_send_voice_end_at, (char *)"结束语音提问: AT^AI_SEND_VOICE_END"},
+ {(char *)"AT^AI_GET_CHAT_HISTORY", ai_get_chat_history_at, (char *)"获取历史会话: AT^AI_GET_CHAT_HISTORY"},
+ {(char *)"AT^AI_DELETE_SESSION_ROUND", ai_delete_session_round_at, (char *)"删除会话轮次: AT^AI_DELETE_SESSION_ROUND"},
+ {(char *)"AT^AI_GET_SUGGEST_QUESTIONS", ai_get_suggest_questions_at, (char *)"获取建议问题列表: AT^AI_GET_SUGGEST_QUESTIONS"},
+ {(char *)"AT^AI_RENAME_SESSION_ROUND", ai_rename_session_round_at, (char *)"重命名会话轮次: AT^AI_RENAME_SESSION_ROUND[=<new_name>]"},
+ {(char *)"AT^AI_GET_SESSION_META", ai_get_session_meta_at, (char *)"获取会话meta信息: AT^AI_GET_SESSION_META"},
+};
+
+at_cmd_table_t *get_ai_api_cmd_table(uint32_t *cmd_count)
+{
+ *cmd_count = ARRAY_COUNT(g_ai_api_cmd);
+ return (at_cmd_table_t *)g_ai_api_cmd;
+}
--- /dev/null
+#ifndef AI_API_AT_H
+#define AI_API_AT_H
+
+#include <stdint.h>
+#include "at_cmd_api.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief 获取AI API AT命令表
+ * @param cmd_count 输出参数,返回命令数量
+ * @return AT命令表指针
+ */
+at_cmd_table_t *get_ai_api_cmd_table(uint32_t *cmd_count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AI_API_AT_H */
+
+
#ifndef ZJ_AIAGENT_H
#define ZJ_AIAGENT_H
+#include "zj_type.h"
+
#ifdef __cplusplus
extern "C" {
#endif
--- /dev/null
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Socket 连接测试程序
+用于测试指定 IP 和端口的 TCP/UDP 连接
+
+用法:
+ python socket_test.py [--host HOST] [--port PORT] [--protocol PROTOCOL] [--timeout TIMEOUT]
+
+示例:
+ python socket_test.py --host 192.168.1.100 --port 8080 --protocol tcp
+ python socket_test.py --host 192.168.1.100 --port 8080 --protocol udp
+"""
+
+import socket
+import sys
+import argparse
+import time
+
+
+class SocketTester:
+ def __init__(self, host, port, protocol='tcp', timeout=5):
+ self.host = host
+ self.port = port
+ self.protocol = protocol.lower()
+ self.timeout = timeout
+ self.sock = None
+
+ def test_tcp_connection(self):
+ """测试 TCP 连接"""
+ print(f"[TCP] 开始连接 {self.host}:{self.port}")
+ print(f"[TCP] 超时设置: {self.timeout} 秒")
+
+ try:
+ # 创建 TCP socket
+ self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ self.sock.settimeout(self.timeout)
+
+ # 尝试连接
+ print(f"[TCP] 正在连接...")
+ start_time = time.time()
+ self.sock.connect((self.host, self.port))
+ elapsed_time = time.time() - start_time
+
+ print(f"[TCP] ✓ 连接成功! 耗时: {elapsed_time:.3f} 秒")
+ print(f"[TCP] 本地地址: {self.sock.getsockname()}")
+ print(f"[TCP] 远程地址: {self.sock.getpeername()}")
+
+ # 发送测试数据
+ test_data = b"Hello from socket test!"
+ print(f"\n[TCP] 发送测试数据: {test_data}")
+ self.sock.send(test_data)
+ print(f"[TCP] ✓ 数据发送成功 ({len(test_data)} 字节)")
+
+ # 尝试接收响应
+ try:
+ self.sock.settimeout(2) # 接收超时 2 秒
+ response = self.sock.recv(1024)
+ if response:
+ print(f"[TCP] ✓ 接收到响应: {response} ({len(response)} 字节)")
+ else:
+ print(f"[TCP] 未接收到响应")
+ except socket.timeout:
+ print(f"[TCP] 接收超时 (2秒内无响应)")
+ except Exception as e:
+ print(f"[TCP] 接收数据时出错: {e}")
+
+ return True
+
+ except socket.timeout:
+ print(f"[TCP] ✗ 连接超时 (超过 {self.timeout} 秒)")
+ return False
+ except ConnectionRefusedError:
+ print(f"[TCP] ✗ 连接被拒绝 (服务器未监听此端口或拒绝连接)")
+ return False
+ except OSError as e:
+ if e.errno == 113: # No route to host
+ print(f"[TCP] ✗ 无法到达主机 (网络不可达)")
+ elif e.errno == 111: # Connection refused
+ print(f"[TCP] ✗ 连接被拒绝")
+ else:
+ print(f"[TCP] ✗ 连接失败: {e}")
+ return False
+ except Exception as e:
+ print(f"[TCP] ✗ 发生错误: {e}")
+ return False
+ finally:
+ if self.sock:
+ self.sock.close()
+ print(f"[TCP] Socket 已关闭")
+
+ def test_udp_connection(self):
+ """测试 UDP 连接"""
+ print(f"[UDP] 开始连接 {self.host}:{self.port}")
+ print(f"[UDP] 超时设置: {self.timeout} 秒")
+
+ try:
+ # 创建 UDP socket
+ self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ self.sock.settimeout(self.timeout)
+
+ # UDP 是无连接的,直接发送数据
+ test_data = b"Hello from UDP socket test!"
+ print(f"\n[UDP] 发送测试数据到 {self.host}:{self.port}")
+ print(f"[UDP] 数据内容: {test_data}")
+
+ start_time = time.time()
+ bytes_sent = self.sock.sendto(test_data, (self.host, self.port))
+ elapsed_time = time.time() - start_time
+
+ print(f"[UDP] ✓ 数据发送成功 ({bytes_sent} 字节), 耗时: {elapsed_time:.3f} 秒")
+ print(f"[UDP] 本地地址: {self.sock.getsockname()}")
+
+ # 尝试接收响应
+ try:
+ print(f"[UDP] 等待响应...")
+ response, addr = self.sock.recvfrom(1024)
+ print(f"[UDP] ✓ 接收到来自 {addr} 的响应: {response} ({len(response)} 字节)")
+ except socket.timeout:
+ print(f"[UDP] 接收超时 (UDP 可能无法接收响应,这是正常的)")
+ except Exception as e:
+ print(f"[UDP] 接收数据时出错: {e}")
+
+ return True
+
+ except OSError as e:
+ if e.errno == 113: # No route to host
+ print(f"[UDP] ✗ 无法到达主机 (网络不可达)")
+ else:
+ print(f"[UDP] ✗ 发送失败: {e}")
+ return False
+ except Exception as e:
+ print(f"[UDP] ✗ 发生错误: {e}")
+ return False
+ finally:
+ if self.sock:
+ self.sock.close()
+ print(f"[UDP] Socket 已关闭")
+
+ def test(self):
+ """执行测试"""
+ print("=" * 60)
+ print(f"Socket 连接测试")
+ print("=" * 60)
+ print(f"目标地址: {self.host}:{self.port}")
+ print(f"协议: {self.protocol.upper()}")
+ print(f"超时: {self.timeout} 秒")
+ print("=" * 60)
+ print()
+
+ if self.protocol == 'tcp':
+ return self.test_tcp_connection()
+ elif self.protocol == 'udp':
+ return self.test_udp_connection()
+ else:
+ print(f"✗ 不支持的协议: {self.protocol}")
+ print(" 支持的协议: tcp, udp")
+ return False
+
+
+def main():
+ parser = argparse.ArgumentParser(
+ description='Socket 连接测试程序',
+ formatter_class=argparse.RawDescriptionHelpFormatter,
+ epilog="""
+示例:
+ %(prog)s --host 192.168.1.100 --port 8080 --protocol tcp
+ %(prog)s --host 192.168.1.100 --port 8080 --protocol udp --timeout 10
+ %(prog)s -H 127.0.0.1 -p 80 -P tcp
+ """
+ )
+
+ parser.add_argument(
+ '--host', '-H',
+ default='127.0.0.1',
+ help='目标主机 IP 地址 (默认: 127.0.0.1)'
+ )
+
+ parser.add_argument(
+ '--port', '-p',
+ type=int,
+ required=True,
+ help='目标端口号 (必需)'
+ )
+
+ parser.add_argument(
+ '--protocol', '-P',
+ choices=['tcp', 'udp', 'TCP', 'UDP'],
+ default='tcp',
+ help='协议类型: tcp 或 udp (默认: tcp)'
+ )
+
+ parser.add_argument(
+ '--timeout', '-t',
+ type=float,
+ default=5.0,
+ help='连接超时时间(秒) (默认: 5.0)'
+ )
+
+ args = parser.parse_args()
+
+ # 验证参数
+ if args.port < 1 or args.port > 65535:
+ print(f"✗ 错误: 端口号必须在 1-65535 之间")
+ sys.exit(1)
+
+ if args.timeout <= 0:
+ print(f"✗ 错误: 超时时间必须大于 0")
+ sys.exit(1)
+
+ # 创建测试器并执行测试
+ tester = SocketTester(
+ host=args.host,
+ port=args.port,
+ protocol=args.protocol,
+ timeout=args.timeout
+ )
+
+ success = tester.test()
+
+ print()
+ print("=" * 60)
+ if success:
+ print("测试完成: ✓ 成功")
+ sys.exit(0)
+ else:
+ print("测试完成: ✗ 失败")
+ sys.exit(1)
+
+
+if __name__ == '__main__':
+ main()
add_subdirectory_if_exist(config)
add_subdirectory_if_exist(UI)
add_subdirectory_if_exist(AI)
+add_subdirectory_if_exist(CT_AI)
add_subdirectory_if_exist(leiniao)
add_subdirectory_if_exist(leiniao/ln_api_cpp)
add_subdirectory_if_exist(dmp)
add_subdirectory_if_exist(MQTT)
add_subdirectory_if_exist(test_opus_frame_to_pcm)
-
-
+add_subdirectory_if_exist(uarttest)
+add_subdirectory_if_exist(ChangAan)
--- /dev/null
+#===============================================================================
+# @brief CT_AI (HiAI Agent) component CMake
+# Copyright (c) @CompanyNameMagicTag 2022-2023. All rights reserved.
+#===============================================================================
+
+# This component mainly provides:
+# 1) Public headers: hiai-sdk-include/include
+# 2) Optional prebuilt connection library: libhiaiConn/libhiaiConn.{a,so}
+
+set(COMPONENT_NAME "CT_AI")
+
+# Sources: CT_AI HTTP/WebSocket 封装,以及 AT 测试命令
+set(SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/ct_ai_http.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/ct_ai_websocket.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/ct_ai_at_cmd.c
+)
+
+set(PUBLIC_HEADER
+ ${CMAKE_CURRENT_SOURCE_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}/hiai-sdk-include/include
+ ${ROOT_DIR}/middleware/utils/at/wstp_at/inc
+ ${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/modules/netstack/http/include
+ ${ROOT_DIR}/open_source/openharmony/third_party/cJSON
+ ${ROOT_DIR}/zhihui/websocket/os_ws
+
+)
+
+set(PRIVATE_HEADER
+ ${ROOT_DIR}/middleware/services/media/foundation/audiomanager/interfaces/kits/audiocommon
+ ${ROOT_DIR}/middleware/chips/brandy/pm/include
+ ${ROOT_DIR}/middleware/chips/brandy/pm/service
+ ${ROOT_DIR}/zhihui/utils
+ ${ROOT_DIR}/zhihui/ai/include
+ ${ROOT_DIR}/zhihui/test_opus_frame_to_pcm/include
+)
+
+set(PRIVATE_DEFINES
+ TARGET_NAME="${TARGET_COMMAND}"
+ BUILD_TIME="${BUILD_TIME}"
+ SUPPORT_AT_CT_AI
+)
+
+set(PUBLIC_DEFINES
+ SUPPORT_AT_CT_AI
+)
+
+set(COMPONENT_PUBLIC_CCFLAGS
+)
+
+set(COMPONENT_CCFLAGS
+ -Wno-error
+ -Wno-unused-parameter
+ -fno-exceptions
+ -fno-unwind-tables
+ -fno-asynchronous-unwind-tables
+ -Wno-undef
+ -Wno-bitwise-op-parentheses
+ -Wno-shift-op-parentheses
+ -nostdlibinc
+ -nostdinc
+ -nostdlib
+ -Wno-c++11-narrowing
+ -Wno-error=unused-function
+)
+
+# Avoid `--whole-archive` wrapping for prebuilt libs unless explicitly needed.
+set(WHOLE_LINK
+ false
+)
+
+# Link prebuilt library if it exists.
+set(LIB_PATH_HIAICONN "")
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/libhiaiConn")
+ find_library(
+ LIB_PATH_HIAICONN
+ NAMES hiaiConn
+ PATHS "${CMAKE_CURRENT_SOURCE_DIR}/libhiaiConn"
+ )
+
+ if(LIB_PATH_HIAICONN)
+ set(LIBS
+ ${LIB_PATH_HIAICONN}
+ )
+ else()
+ message(WARNING "[CT_AI] libhiaiConn exists but hiaiConn library not found")
+ endif()
+endif()
+
+set(MAIN_COMPONENT
+ false
+)
+
+build_component()
--- /dev/null
+#ifndef CT_AI_API_H
+#define CT_AI_API_H
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef enum {
+ CT_AI_WS_CMD_TEXT = 0,
+ CT_AI_WS_CMD_AUDIO,
+ CT_AI_WS_CMD_VIDEO,
+
+ CT_AI_WS_CMD_CONNECTED,
+ CT_AI_WS_CMD_DISCONNECTED,
+ CT_AI_WS_CMD_HEARTBEAT,
+ CT_AI_WS_CMD_RECONNECT_SUCCESS,
+ CT_AI_WS_CMD_RECONNECT_FAILED,
+ CT_AI_WS_CMD_RECONNECT_TIMEOUT,
+ CT_AI_WS_CMD_RECONNECT_MAX,
+
+} ws_command_t;
+
+
+/* 消息数据结构 */
+typedef struct {
+ char device_id[64];
+ uint32_t timestamp;
+ char message_id[64];
+ ws_command_t command;
+ char command_str[32];
+ char *raw_json; // 原始JSON字符串,用于需要完整数据的场景
+} ws_data_msg_t;
+
+
+typedef void (*ws_message_callback_t_ct_ai)(const ws_data_msg_t *data_msg, ws_command_t type);
+
+/* HTTP */
+int ct_ai_http_token(char *token, char* deviceId, uint32_t max_len_token, uint32_t max_len_deviceId, int port);
+
+/* WebSocket */
+int ct_ai_ws_start(ws_message_callback_t_ct_ai callback, uint32_t audio_timeout_ticks);
+bool ct_ai_ws_stop(void);
+/** 与 leiniao ln_ws_audio_init 对齐:在 WebSocket 已连接后启动 AI 语音(录音上行 / TTS 下行管线) */
+void ct_ai_ws_audio_init(bool is_vad_server_enabled);
+void ct_ai_ws_audio_deinit(void);
+bool ct_ai_ws_is_audio_initialized(void);
+int ct_ai_ws_verify_ip_port(const char *ip, uint16_t port, uint32_t timeout_ms);
+int ct_ai_ws_verify_default_server(uint32_t timeout_ms);
+
+/** C2S_VOICE_STREAM:开始一段 PCM 上行(后续 send 的 hasNext 为 true,直至 voice_stream_end) */
+void ct_ai_ws_voice_stream_start(void);
+/** 置位“下一包为最后一包”,下一帧 JSON 中 hasNext=false,发送成功后自动结束会话 */
+void ct_ai_ws_voice_stream_end(void);
+/**
+ * 将 PCM 封装为 C2S_VOICE_STREAM JSON 并 uapi_ws_send_text。
+ * @param sample_rate 为 0 时使用默认 16000
+ * @return 0 成功,-1 失败
+ */
+int ct_ai_ws_send_voice_stream_pcm(const uint8_t *pcm, uint32_t pcm_len, uint32_t sample_rate);
+
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif
\ No newline at end of file
--- /dev/null
+/**
+ * @file ct_ai_at_cmd.c
+ * @brief CT_AI AT 测试命令实现(独立 AT 接口)
+ */
+
+#include "ct_ai_at_cmd.h"
+#include "ct_ai_api.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define CT_AI_UNUSED(x) ((void)(x))
+
+#ifndef CT_AI_AT_MAX_ARGC
+#define CT_AI_AT_MAX_ARGC 8
+#endif
+
+#ifndef CT_AI_AT_MAX_ARGV_LEN
+#define CT_AI_AT_MAX_ARGV_LEN 512
+#endif
+
+/* 解析 AT 参数:para 中以 ',' 或 '=' 或空白分隔 */
+static int ct_ai_parse_params(uint8_t *para, uint32_t para_len,
+ uint8_t argv[CT_AI_AT_MAX_ARGC][CT_AI_AT_MAX_ARGV_LEN],
+ uint32_t *argc)
+{
+ uint32_t pos = 0;
+ *argc = 0;
+
+ if (para == NULL || para_len == 0) {
+ return -1;
+ }
+
+ for (uint32_t i = 0; i < para_len; i++) {
+ uint8_t ch = para[i];
+ if (ch == ',' || ch == '=' || ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t') {
+ if (pos > 0) {
+ argv[*argc][pos] = '\0';
+ (*argc)++;
+ pos = 0;
+ if (*argc >= CT_AI_AT_MAX_ARGC) {
+ return -1;
+ }
+ }
+ continue;
+ }
+
+ if (pos >= CT_AI_AT_MAX_ARGV_LEN - 1) {
+ return -1;
+ }
+ argv[*argc][pos++] = ch;
+ }
+
+ if (pos > 0) {
+ argv[*argc][pos] = '\0';
+ (*argc)++;
+ }
+
+ return 0;
+}
+
+/* AT^CTAI_TEST - 仅打印,用于确认模块已加载 */
+static uint32_t ct_ai_test_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CT_AI_UNUSED(para);
+ CT_AI_UNUSED(para_len);
+ CT_AI_UNUSED(str_cmd);
+
+ printf("[CT_AI][AT] AT^CTAI_TEST ok\r\n");
+ return ERRCODE_SUCC;
+}
+
+/* AT^CTAI_HTTP_TOKEN - 调用 ct_ai_http_token 并打印 token */
+static uint32_t ct_ai_http_token_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CT_AI_UNUSED(para);
+ CT_AI_UNUSED(para_len);
+ CT_AI_UNUSED(str_cmd);
+
+ char token[256] = {0};
+ char deviceId[256] = {0};
+ int ret = ct_ai_http_token(token, deviceId, sizeof(token), sizeof(deviceId), 9011);
+ if (ret == 0 && token[0] != '\0') {
+ printf("[CT_AI][AT] HTTP_TOKEN ok\r\n");
+ printf("[CT_AI][AT] token: %s\r\n", token);
+ return ERRCODE_SUCC;
+ }
+
+ printf("[CT_AI][AT] HTTP_TOKEN failed, ret=%d, token_empty=%d\r\n", ret, (token[0] == '\0'));
+ return ERRCODE_FAIL;
+}
+
+/* AT^CTAI_WS_START=<audio_timeout_ticks>
+ * audio_timeout_ticks 用于音频超时(tick 数),不传则为 0(使用默认逻辑)
+ */
+static uint32_t ct_ai_ws_start_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CT_AI_UNUSED(str_cmd);
+
+ uint32_t audio_timeout_ticks = 0;
+
+ if (para != NULL && para_len > 0) {
+ uint8_t argv[CT_AI_AT_MAX_ARGC][CT_AI_AT_MAX_ARGV_LEN] = {0};
+ uint32_t argc = 0;
+ if (ct_ai_parse_params(para, para_len, argv, &argc) == 0 && argc >= 1) {
+ audio_timeout_ticks = (uint32_t)atoi((char *)argv[0]);
+ } else {
+ printf("[CT_AI][AT] invalid params\r\n");
+ return ERRCODE_INVALID_PARAM;
+ }
+ }
+
+ int ret = ct_ai_ws_start(NULL, audio_timeout_ticks);
+ if (ret == 0) {
+ printf("[CT_AI][AT] WS_START ok (audio_timeout_ticks=%u)\r\n", audio_timeout_ticks);
+ return ERRCODE_SUCC;
+ }
+
+ printf("[CT_AI][AT] WS_START failed, ret=%d\r\n", ret);
+ return ERRCODE_FAIL;
+}
+
+/* AT^CTAI_WS_STOP */
+static uint32_t ct_ai_ws_stop_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CT_AI_UNUSED(para);
+ CT_AI_UNUSED(para_len);
+ CT_AI_UNUSED(str_cmd);
+
+ bool ok = ct_ai_ws_stop();
+ printf("[CT_AI][AT] WS_STOP %s\r\n", ok ? "ok" : "fail");
+ return ok ? ERRCODE_SUCC : ERRCODE_FAIL;
+}
+
+/* AT^CTAI_VOICE_STREAM_START - 测试 ct_ai_ws_voice_stream_start(无参数) */
+static uint32_t ct_ai_voice_stream_start_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CT_AI_UNUSED(para);
+ CT_AI_UNUSED(para_len);
+ CT_AI_UNUSED(str_cmd);
+
+ ct_ai_ws_voice_stream_start();
+ printf("[CT_AI][AT] VOICE_STREAM_START ok\r\n");
+ return ERRCODE_SUCC;
+}
+
+/* AT^CTAI_VOICE_STREAM_END - 测试 ct_ai_ws_voice_stream_end(无参数) */
+static uint32_t ct_ai_voice_stream_end_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CT_AI_UNUSED(para);
+ CT_AI_UNUSED(para_len);
+ CT_AI_UNUSED(str_cmd);
+
+ ct_ai_ws_voice_stream_end();
+ printf("[CT_AI][AT] VOICE_STREAM_END ok (next send PCM will have hasNext=false)\r\n");
+ return ERRCODE_SUCC;
+}
+
+/* AT^CTAI_WS_VERIFY[=<ip>,<port>,<timeout_ms>]
+ * - 无参数: 验证默认服务器地址和端口
+ * - 2个参数: ip,port
+ * - 3个参数: ip,port,timeout_ms
+ */
+static uint32_t ct_ai_ws_verify_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CT_AI_UNUSED(str_cmd);
+
+ int ret = -1;
+ uint32_t timeout_ms = 2000;
+
+
+ ret = ct_ai_ws_verify_default_server(timeout_ms);
+ printf("[CT_AI][AT] WS_VERIFY default_server timeout_ms=%u => %s\r\n",
+ timeout_ms, (ret == 0) ? "ok" : "fail");
+
+
+ return (ret == 0) ? ERRCODE_SUCC : ERRCODE_FAIL;
+}
+
+static const at_cmd_table_t g_ct_ai_at_table[] = {
+ {(char *)"AT^CTAI_TEST", ct_ai_test_at_cmd, (char *)"module load check"},
+ {(char *)"AT^CTAI_HTTP_TOKEN", ct_ai_http_token_at_cmd, (char *)"request token and print"},
+ {(char *)"AT^CTAI_WS_START", ct_ai_ws_start_at_cmd, (char *)"audio_timeout_ticks"},
+ {(char *)"AT^CTAI_WS_STOP", ct_ai_ws_stop_at_cmd, (char *)"stop websocket"},
+ {(char *)"AT^CTAI_WS_VERIFY", ct_ai_ws_verify_at_cmd, (char *)"[ip,port,timeout_ms]"},
+ {(char *)"AT^CTAI_VOICE_STREAM_START", ct_ai_voice_stream_start_at_cmd, (char *)"voice stream: start (hasNext=true for chunks)"},
+ {(char *)"AT^CTAI_VOICE_STREAM_END", ct_ai_voice_stream_end_at_cmd, (char *)"voice stream: next send has hasNext=false"},
+};
+
+at_cmd_table_t *get_ct_ai_at_table(uint32_t *cmd_count)
+{
+ if (cmd_count != NULL) {
+ *cmd_count = (uint32_t)(sizeof(g_ct_ai_at_table) / sizeof(g_ct_ai_at_table[0]));
+ }
+ return (at_cmd_table_t *)g_ct_ai_at_table;
+}
+
--- /dev/null
+/**
+ * @file ct_ai_at_cmd.h
+ * @brief CT_AI AT 测试命令导出
+ */
+#ifndef CT_AI_AT_CMD_H
+#define CT_AI_AT_CMD_H
+
+#include <stdint.h>
+
+#include "errcode.h"
+#include "at_cmd_api.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief 获取 CT_AI AT 命令表
+ * @param cmd_count 输出命令数量
+ * @return AT 命令表指针
+ */
+at_cmd_table_t *get_ct_ai_at_table(uint32_t *cmd_count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CT_AI_AT_CMD_H */
+
--- /dev/null
+#include "ct_ai_api.h"
+#include "httpclient.h"
+
+#include "cJSON.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+
+int ct_ai_http_common(const char *tag,
+ char *post_buf, char *url, char *put_buf,uint32_t max_len,char *content_type,int port)
+{
+
+ HttpClient client = (HttpClient){0};
+ HttpClientData client_data = (HttpClientData){0};
+ int ret = -1;
+
+ if (url == NULL) {
+ printf("[changan_http][%s] url is NULL\r\n", tag);
+ return -1;
+ }
+
+ /* httpclient 要求 headerBuf/responseBuf 不小于 2048 */
+ char *req_buf = (char *)malloc(2048);
+ char *rsp_buf = (char *)malloc(2048);
+ if (req_buf == NULL || rsp_buf == NULL) {
+ printf("[changan_http][%s] malloc failed\r\n", tag);
+ goto EXIT;
+ }
+
+ memset(req_buf, 0, 2048);
+ client_data.headerBuf = req_buf;
+ client_data.headerBufLen = 2048;
+
+ memset(rsp_buf, 0, 2048);
+ client_data.responseBuf = rsp_buf;
+ client_data.responseBufLen = 2048;
+
+ printf("[changan_http][%s] url: %s\r\n", tag, url);
+
+ if (post_buf != NULL) {
+ client_data.postBuf = post_buf;
+ client_data.postBufLen = (int)strlen(post_buf);
+ } else {
+ client_data.postBuf = NULL;
+ client_data.postBufLen = 0;
+ }
+
+ /* ChangAn 接口默认都是 JSON */
+ client.header = content_type;
+ client.remotePort = port;
+ client.isHttp = true;
+
+ if(strcmp(tag, "POST") == 0)
+ {
+ ret = HttpClientPostRequest(&client, url, &client_data);
+ }
+ else if(strcmp(tag, "PUT") == 0)
+ {
+ ret = HttpClientPutRequest(&client, url, &client_data);
+ }
+ else if(strcmp(tag, "GET") == 0)
+ {
+ ret = HttpClientGetRequest(&client, url, &client_data);
+ }
+
+ char create_time_str[32] = {0};
+ time_t now = time(NULL);
+ struct tm tm_now;
+ (void)localtime_r(&now, &tm_now);
+ (void)strftime(create_time_str, sizeof(create_time_str), "%Y-%m-%d %H:%M:%S", &tm_now);
+ printf("create_time_str: %s\r\n", create_time_str);
+ printf("[changan_http][%s] Post_buf: %s\r\n", tag, post_buf);
+ printf("[changan_http][%s] url: %s\r\n", tag, url);
+
+
+ if (ret >= 0 && client.responseCode == 200) {
+ printf("[changan_http][%s] resp: %s\r\n", tag, client_data.responseBuf);
+ // printf("[changan_http][%s] header: %s\r\n", tag, client_data.headerBuf);
+ printf("[changan_http][%s] code: %d\r\n", tag, client.responseCode);
+ if (put_buf != NULL && client_data.responseBuf != NULL) {
+ /* 简单 memcpy,调用方保证 put_buf 足够大 */
+ memcpy_s(put_buf, max_len, client_data.responseBuf, strlen(client_data.responseBuf) + 1);
+ }
+ ret = 0;
+ } else {
+ printf("[changan_http][%s] failed, code=%d ret=0x%x\r\n",
+ tag, client.responseCode, ret);
+ printf("[changan_http][%s] header: %s\r\n", tag, client_data.headerBuf);
+ printf("[changan_http][%s] response: %s\r\n", tag, client_data.responseBuf);
+ printf("[changan_http][%s] code: %d\r\n", tag, client.responseCode);
+ }
+
+EXIT:
+ if (req_buf != NULL) {
+ free(req_buf);
+ }
+ if (rsp_buf != NULL) {
+ free(rsp_buf);
+ }
+ return client.responseCode;
+}
+
+// http://8.152.162.54:9011
+
+// 接⼝: POST /api/auth/token
+// 请求头: Content-Type: application/json
+// 请求体:
+// {
+// "appId": "your_app_id",
+// "imei": "your_device_imei",
+// "softwareVersion": "your_software_version",
+// "deviceType": "KXS51"
+// }
+
+// 成功响应:
+// {
+// "success": true,
+// "message": "Token⽣成成功",
+// "data": {
+// "deviceId": "deviceId",
+// "token": "eb9cb9b5e94af3984a88a919854dd0972a3ed88cfa...",
+// "expiresIn": 86400
+// }
+// }
+
+// deviceType=KuNuoN9; imei=123456; appId=123test
+
+int ct_ai_http_token(char *token,char* deviceId,uint32_t max_len_token, uint32_t max_len_deviceId, int port)
+{
+ if(token == NULL || max_len_token == 0 || deviceId == NULL || max_len_deviceId == 0)
+ {
+ return -1;
+ }
+ printf("ct_ai_http_token: token_len: %d, deviceId_len: %d\r\n", max_len_token, max_len_deviceId);
+ memset(token, 0, max_len_token);
+ memset(deviceId, 0, max_len_deviceId);
+
+ // parser.add_argument("--app-id", default="123test", help="应用 ID")
+ // parser.add_argument("--imei", default="123456", help="设备 IMEI")
+ // parser.add_argument("--device-type", default="simulator", help="设备类型")
+
+ char *url = "http://8.152.162.54:9011/api/auth/token";
+ const char *post_buf_json = "{\"appId\": \"123test\", \"imei\": \"123456\", \"softwareVersion\": \"1.0.0\", \"deviceType\": \"KuNuoN9\"}";
+
+ char *put_buf = NULL;
+ put_buf = (char*)malloc(1024);
+ if(put_buf == NULL)
+ {
+ return -1;
+ }
+ memset(put_buf, 0, 1024);
+
+ /* 1) JSON 尝试 */
+ int ret = ct_ai_http_common("POST",
+ (char *)post_buf_json,
+ url,
+ put_buf,
+ 1024,
+ "Content-Type: application/json\r\n",
+ port);
+ if (ret == 200) {
+ cJSON *root = cJSON_Parse(put_buf);
+ if (root == NULL) {
+ return -1;
+ }
+
+ cJSON *data_obj = cJSON_GetObjectItem(root, "data");
+ if (data_obj != NULL) {
+ cJSON *token_obj = cJSON_GetObjectItem(data_obj, "token");
+ cJSON *deviceId_obj = cJSON_GetObjectItem(data_obj, "deviceId");
+ if (token_obj != NULL && token_obj->valuestring != NULL) {
+ strncpy(token, token_obj->valuestring, max_len_token);
+ token[max_len_token - 1] = '\0';
+ printf("token: %s\r\n", token);
+ }
+ if (deviceId_obj != NULL && deviceId_obj->valuestring != NULL) {
+ strncpy(deviceId, deviceId_obj->valuestring, max_len_deviceId);
+ deviceId[max_len_deviceId - 1] = '\0';
+ printf("deviceId: %s\r\n", deviceId);
+ }
+ }
+ cJSON_Delete(root);
+ }
+ return ret;
+}
--- /dev/null
+
+// #include "net_websocket.h"
+#include "haisi_websocket.h"
+#include "ct_ai_api.h"
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <ctype.h>
+#include "cJSON.h" // Added for JSON parsing
+#include "custom_utils.h"
+#include "soc_osal.h"
+#include "cmsis_os2.h"
+#include "mbedtls/base64.h"
+#include "ai_media.h" // Added for AI_RegisterWriteAudioDataCallback
+#include "audio_base_type.h"
+#include "opus_frame_to_pcm.h"
+#include "pm.h"
+#include "pm_veto.h"
+
+#define OPUS_DEBUG_PCM_BUF_SAMPLES 5760 /* 单帧解码 PCM 缓冲(与 ln_UDP.c 一致) */
+static short g_opus_debug_pcm_buf[OPUS_DEBUG_PCM_BUF_SAMPLES];
+
+/* HTTP 下载模块(与 ln_ws_audio_init 中 ln_http_download_init 一致,由链接期解析) */
+extern int ln_http_download_init(void);
+extern void ln_http_download_deinit(void);
+
+// Socket verify (IP:port TCP connect check)
+#include <errno.h>
+#include <fcntl.h>
+#include "lwip/sockets.h"
+#include "lwip/inet.h"
+
+// 功能开关宏定义
+#define ENABLE_BINARY_DATA_INTERRUPT_CHECK 1 // 启用二进制数据间隔检查
+#define ENABLE_AUDIO_FILE_WRITE_CT_AI 0 // 启用音频文件写入功能(根据chat_id生成文件)
+
+// 主线程循环间隔时长(毫秒)
+#define CT_AI_WS_MAIN_THREAD_INTERVAL_MS 500
+
+ // 心跳间隔(秒)
+// #define LN_WS_HEARTBEAT_INTERVAL_SEC 60*5 //5分钟发送一次心跳,正常最大7分钟
+static volatile uint32_t CT_AI_WS_HEARTBEAT_INTERVAL_SEC = 30; //5分钟发送一次心跳,正常最大7分钟
+
+void ct_ai_ws_set_heartbeat_interval_sec(uint32_t interval)
+{
+ CT_AI_WS_HEARTBEAT_INTERVAL_SEC = interval;
+}
+uint32_t ct_ai_ws_get_heartbeat_interval_sec(void)
+{
+ return CT_AI_WS_HEARTBEAT_INTERVAL_SEC;
+}
+// 心跳间隔计数器阈值(基于主线程间隔计算)
+#define CT_AI_WS_HEARTBEAT_COUNTER_THRESHOLD ((CT_AI_WS_HEARTBEAT_INTERVAL_SEC * 1000) / CT_AI_WS_MAIN_THREAD_INTERVAL_MS)
+
+// 打印等级定义
+typedef enum {
+ CT_AI_WS_LOG_ERROR = 0, // 错误信息
+ CT_AI_WS_LOG_WARN = 1, // 警告信息
+ CT_AI_WS_LOG_INFO = 2, // 一般信息
+ CT_AI_WS_LOG_DEBUG = 3 // 调试信息
+} ct_ai_ws_log_level_t;
+
+// 当前日志等级(可通过配置修改)
+static ct_ai_ws_log_level_t g_log_level = CT_AI_WS_LOG_DEBUG;
+
+void ct_ai_ws_set_log_level(uint8_t level)
+{
+ g_log_level = (ct_ai_ws_log_level_t)level;
+}
+// 打印函数
+// 日志等级字符串数组
+static const char *g_log_level_str[] = {
+ "[ERROR]", "[WARN]", "[INFO]", "[DEBUG]"
+};
+
+// 日志宏定义
+#define CT_AI_WS_LOG(level, line, fmt, ...) do { \
+ if (level <= g_log_level) { \
+ printf("[CT_AI][WS]%s " fmt, g_log_level_str[level], ##__VA_ARGS__); \
+ } \
+} while(0)
+
+// 便捷打印宏
+#define CT_AI_WS_ERROR(fmt, ...) CT_AI_WS_LOG(CT_AI_WS_LOG_ERROR, __LINE__, fmt, ##__VA_ARGS__)
+#define CT_AI_WS_WARN(fmt, ...) CT_AI_WS_LOG(CT_AI_WS_LOG_WARN, __LINE__, fmt, ##__VA_ARGS__)
+#define CT_AI_WS_INFO(fmt, ...) CT_AI_WS_LOG(CT_AI_WS_LOG_INFO, __LINE__, fmt, ##__VA_ARGS__)
+#define CT_AI_WS_DEBUG(fmt, ...) CT_AI_WS_LOG(CT_AI_WS_LOG_DEBUG, __LINE__, fmt, ##__VA_ARGS__)
+
+#ifndef CT_AI_S2C_OPUS_QUEUE_DEPTH
+#define CT_AI_S2C_OPUS_QUEUE_DEPTH 256
+#endif
+#ifndef CT_AI_S2C_OPUS_WORKER_STACK
+#define CT_AI_S2C_OPUS_WORKER_STACK (0x8000)
+#endif
+
+/* 1:Base64+Opus 在独立 worker 线程解码并入队;0:在 WebSocket 消息回调线程同步解码并写入 AI_SendAudioDataToQueue */
+#ifndef CT_AI_S2C_OPUS_USE_DECODE_QUEUE
+#define CT_AI_S2C_OPUS_USE_DECODE_QUEUE 0
+#endif
+
+/* S2C 下行:按 hasNext 聚合整段 PCM,仅在 hasNext=false 时一次性写入播放队列(仅解码线程持锁修改) */
+static uint8_t *g_s2c_pcm_accum_buf = NULL;
+static size_t g_s2c_pcm_accum_len = 0;
+static size_t g_s2c_pcm_accum_cap = 0;
+static osMutexId_t g_s2c_pcm_accum_mutex = NULL;
+
+static void ct_ai_ws_s2c_pcm_accum_free_inner(void)
+{
+ free(g_s2c_pcm_accum_buf);
+ g_s2c_pcm_accum_buf = NULL;
+ g_s2c_pcm_accum_len = 0;
+ g_s2c_pcm_accum_cap = 0;
+}
+
+static void ct_ai_ws_s2c_pcm_accum_free(void)
+{
+ if (g_s2c_pcm_accum_mutex != NULL) {
+ (void)osMutexAcquire(g_s2c_pcm_accum_mutex, osWaitForever);
+ ct_ai_ws_s2c_pcm_accum_free_inner();
+ (void)osMutexRelease(g_s2c_pcm_accum_mutex);
+ } else {
+ ct_ai_ws_s2c_pcm_accum_free_inner();
+ }
+}
+
+static int ct_ai_ws_s2c_pcm_accum_append_inner(const uint8_t *pcm, size_t pcm_bytes)
+{
+ if (pcm == NULL || pcm_bytes == 0) {
+ return 0;
+ }
+
+ size_t new_len = g_s2c_pcm_accum_len + pcm_bytes;
+ if (new_len > g_s2c_pcm_accum_cap) {
+ size_t new_cap = g_s2c_pcm_accum_cap ? g_s2c_pcm_accum_cap : 4096U;
+ while (new_cap < new_len) {
+ if (new_cap > (SIZE_MAX / 2U)) {
+ return -1;
+ }
+ new_cap *= 2U;
+ }
+ uint8_t *nb = (uint8_t *)realloc(g_s2c_pcm_accum_buf, new_cap);
+ if (nb == NULL) {
+ return -1;
+ }
+ g_s2c_pcm_accum_buf = nb;
+ g_s2c_pcm_accum_cap = new_cap;
+ }
+
+ memcpy(g_s2c_pcm_accum_buf + g_s2c_pcm_accum_len, pcm, pcm_bytes);
+ g_s2c_pcm_accum_len = new_len;
+ return 0;
+}
+
+static void ct_ai_ws_s2c_pcm_accum_flush_to_queue_inner(void)
+{
+ const uint8_t *pcm_pos = g_s2c_pcm_accum_buf;
+ uint32_t pcm_bytes_left = (g_s2c_pcm_accum_len > (size_t)UINT32_MAX) ? UINT32_MAX : (uint32_t)g_s2c_pcm_accum_len;
+ const uint32_t pcm_chunk_size = 1024U;
+
+ while (pcm_bytes_left > 0U) {
+ uint32_t send_len = (pcm_bytes_left > pcm_chunk_size) ? pcm_chunk_size : pcm_bytes_left;
+
+ AI_SendAudioDataToQueue(pcm_pos, send_len);
+ pcm_pos += send_len;
+ pcm_bytes_left -= send_len;
+ }
+
+ ct_ai_ws_s2c_pcm_accum_free_inner();
+}
+
+#if CT_AI_S2C_OPUS_USE_DECODE_QUEUE
+
+typedef struct ct_ai_s2c_opus_job {
+ char *b64_chunk; /* 队列内负责释放;NULL 表示仅 flush(如 hasNext=false 且无 chunk) */
+ size_t b64_len;
+ int sample_rate;
+ bool has_next;
+ struct ct_ai_s2c_opus_job *next_overflow; /* 主队列满时挂到 FIFO 侧链,由 worker 消费 */
+} ct_ai_s2c_opus_job_t;
+
+static osMessageQueueId_t g_s2c_opus_queue = NULL;
+static uint32_t g_s2c_opus_thread = 0U;
+static osMutexId_t g_s2c_opus_overflow_mutex = NULL;
+static ct_ai_s2c_opus_job_t *g_s2c_opus_overflow_head = NULL;
+static ct_ai_s2c_opus_job_t *g_s2c_opus_overflow_tail = NULL;
+
+static void ct_ai_s2c_opus_job_free(ct_ai_s2c_opus_job_t *job)
+{
+ if (job == NULL) {
+ return;
+ }
+ job->next_overflow = NULL;
+ free(job->b64_chunk);
+ job->b64_chunk = NULL;
+ free(job);
+}
+
+/* 主队列优先,其次溢出 FIFO;主队列空时在主队列上阻塞等待(含 shutdown NULL) */
+static ct_ai_s2c_opus_job_t *ct_ai_s2c_opus_pop_one_job(void)
+{
+ for (;;) {
+ ct_ai_s2c_opus_job_t *job = NULL;
+ osStatus_t mq = osMessageQueueGet(g_s2c_opus_queue, &job, NULL, 0U);
+ if (mq == osOK && job != NULL) {
+ return job;
+ }
+ if (mq == osOK && job == NULL) {
+ return NULL;
+ }
+
+ if (g_s2c_opus_overflow_mutex != NULL &&
+ osMutexAcquire(g_s2c_opus_overflow_mutex, osWaitForever) == osOK) {
+ job = g_s2c_opus_overflow_head;
+ if (job != NULL) {
+ g_s2c_opus_overflow_head = job->next_overflow;
+ if (g_s2c_opus_overflow_head == NULL) {
+ g_s2c_opus_overflow_tail = NULL;
+ }
+ job->next_overflow = NULL;
+ }
+ (void)osMutexRelease(g_s2c_opus_overflow_mutex);
+ if (job != NULL) {
+ return job;
+ }
+ }
+
+ mq = osMessageQueueGet(g_s2c_opus_queue, &job, NULL, osWaitForever);
+ if (mq != osOK) {
+ continue;
+ }
+ return job;
+ }
+}
+
+static void ct_ai_s2c_opus_worker_main(void *argument)
+{
+ (void)argument;
+
+ for (;;) {
+ ct_ai_s2c_opus_job_t *job = ct_ai_s2c_opus_pop_one_job();
+ if (job == NULL) {
+ break;
+ }
+
+ const int tick_decode_start = (int)osKernelGetTickCount();
+ int tick_b64 = 0;
+ int tick_opus = 0;
+ int tick_pcm_path = 0;
+
+ int pcm_samples = 0;
+ int dec_ret = -1;
+
+ if (job->b64_chunk != NULL && job->b64_len > 0U) {
+ size_t dec_cap = job->b64_len;
+ uint8_t *opus_bin = (uint8_t *)malloc(dec_cap);
+ if (opus_bin == NULL) {
+ CT_AI_WS_ERROR("opus worker: malloc(base64 decode buf) failed\n");
+ dec_ret = -1;
+ } else {
+ size_t opus_bin_len = 0;
+ int t0 = (int)osKernelGetTickCount();
+ int b64_r = mbedtls_base64_decode(opus_bin, dec_cap, &opus_bin_len, (const unsigned char *)job->b64_chunk,
+ job->b64_len);
+ int t1 = (int)osKernelGetTickCount();
+ tick_b64 = t1 - t0;
+ if (b64_r == 0 && opus_bin_len > 0U) {
+ int t2 = (int)osKernelGetTickCount();
+ dec_ret = opus_frame_to_pcm_decode_packet(opus_bin, (int)opus_bin_len, job->sample_rate, 1,
+ g_opus_debug_pcm_buf, OPUS_DEBUG_PCM_BUF_SAMPLES, &pcm_samples);
+ int t3 = (int)osKernelGetTickCount();
+ tick_opus = t3 - t2;
+ } else {
+ dec_ret = -1;
+ }
+ free(opus_bin);
+ }
+ }
+
+ int tp0 = (int)osKernelGetTickCount();
+ if (g_s2c_pcm_accum_mutex != NULL) {
+ (void)osMutexAcquire(g_s2c_pcm_accum_mutex, osWaitForever);
+ }
+
+ if (job->b64_chunk != NULL && job->b64_len > 0U) {
+ if (dec_ret == 0 && pcm_samples > 0) {
+ size_t pcm_bytes = (size_t)pcm_samples * sizeof(short);
+ if (ct_ai_ws_s2c_pcm_accum_append_inner((const uint8_t *)g_opus_debug_pcm_buf, pcm_bytes) != 0) {
+ CT_AI_WS_ERROR("opus worker: pcm accum append/realloc failed\n");
+ ct_ai_ws_s2c_pcm_accum_free_inner();
+ }
+ } else {
+ CT_AI_WS_ERROR("opus worker: decode fail ret=%d pcm_samples=%d\n", dec_ret, pcm_samples);
+ ct_ai_ws_s2c_pcm_accum_free_inner();
+ }
+ }
+
+ if (!job->has_next) {
+ ct_ai_ws_s2c_pcm_accum_flush_to_queue_inner();
+ }
+
+ if (g_s2c_pcm_accum_mutex != NULL) {
+ (void)osMutexRelease(g_s2c_pcm_accum_mutex);
+ }
+ int tp1 = (int)osKernelGetTickCount();
+ tick_pcm_path = tp1 - tp0;
+
+ {
+ const int tick_decode_total = tp1 - tick_decode_start;
+ const int has_payload = (job->b64_chunk != NULL && job->b64_len > 0U) ? 1 : 0;
+ CT_AI_WS_INFO(
+ "opus worker: decode ticks b64=%d opus=%d pcm_flush=%d total=%d ret=%d samples=%d has_next=%d b64_len=%zu\n",
+ tick_b64, tick_opus, tick_pcm_path, tick_decode_total, has_payload ? dec_ret : 0, pcm_samples,
+ (int)job->has_next, job->b64_len);
+ }
+
+ ct_ai_s2c_opus_job_free(job);
+ }
+}
+
+static int ct_ai_ws_s2c_opus_worker_init(void)
+{
+ if (g_s2c_opus_queue != NULL) {
+ return 0;
+ }
+
+ g_s2c_pcm_accum_mutex = osMutexNew(NULL);
+ if (g_s2c_pcm_accum_mutex == NULL) {
+ CT_AI_WS_ERROR("opus worker: osMutexNew failed\n");
+ return -1;
+ }
+
+ g_s2c_opus_overflow_mutex = osMutexNew(NULL);
+ if (g_s2c_opus_overflow_mutex == NULL) {
+ CT_AI_WS_ERROR("opus worker: osMutexNew(overflow) failed\n");
+ osMutexDelete(g_s2c_pcm_accum_mutex);
+ g_s2c_pcm_accum_mutex = NULL;
+ return -1;
+ }
+
+ g_s2c_opus_queue = osMessageQueueNew(CT_AI_S2C_OPUS_QUEUE_DEPTH, sizeof(ct_ai_s2c_opus_job_t *), NULL);
+ if (g_s2c_opus_queue == NULL) {
+ CT_AI_WS_ERROR("opus worker: osMessageQueueNew failed\n");
+ osMutexDelete(g_s2c_opus_overflow_mutex);
+ g_s2c_opus_overflow_mutex = NULL;
+ osMutexDelete(g_s2c_pcm_accum_mutex);
+ g_s2c_pcm_accum_mutex = NULL;
+ return -1;
+ }
+
+ app_task_definition_ext_t opus_task = {
+ .attr = {
+ .name = "ct_ai_opus",
+ .stack_size = CT_AI_S2C_OPUS_WORKER_STACK,
+ .priority = osPriorityNormal,
+ },
+ .func = ct_ai_s2c_opus_worker_main,
+ .task_handle = &g_s2c_opus_thread,
+ .create_queue_handle = NULL,
+ .use_mem = USE_EXTEND_MEM,
+ .inst_args = NULL,
+ };
+
+ errcode_t thr_ret = uapi_create_osThread_custom_with_args(&opus_task);
+ if (thr_ret != ERRCODE_SUCC) {
+ CT_AI_WS_ERROR("opus worker: uapi_create_osThread_custom_with_args failed %d\n", (int)thr_ret);
+ osMessageQueueDelete(g_s2c_opus_queue);
+ g_s2c_opus_queue = NULL;
+ osMutexDelete(g_s2c_opus_overflow_mutex);
+ g_s2c_opus_overflow_mutex = NULL;
+ osMutexDelete(g_s2c_pcm_accum_mutex);
+ g_s2c_pcm_accum_mutex = NULL;
+ return -1;
+ }
+
+ /* uapi_create_osThread_custom_with_args 将 osThreadNew 返回值写入 task_handle 成员(见 custom_utils.c) */
+ g_s2c_opus_thread = (uint32_t)(uintptr_t)opus_task.task_handle;
+
+ return 0;
+}
+
+static void ct_ai_ws_s2c_opus_worker_deinit(void)
+{
+ if (g_s2c_opus_queue == NULL) {
+ return;
+ }
+
+ ct_ai_s2c_opus_job_t *shutdown = NULL;
+ (void)osMessageQueuePut(g_s2c_opus_queue, &shutdown, 0U, osWaitForever);
+
+ if (g_s2c_opus_thread != 0U) {
+ (void)osThreadJoin((osThreadId_t)g_s2c_opus_thread);
+ g_s2c_opus_thread = 0U;
+ }
+
+ if (g_s2c_opus_overflow_mutex != NULL) {
+ (void)osMutexAcquire(g_s2c_opus_overflow_mutex, osWaitForever);
+ while (g_s2c_opus_overflow_head != NULL) {
+ ct_ai_s2c_opus_job_t *oj = g_s2c_opus_overflow_head;
+ g_s2c_opus_overflow_head = oj->next_overflow;
+ ct_ai_s2c_opus_job_free(oj);
+ }
+ g_s2c_opus_overflow_tail = NULL;
+ (void)osMutexRelease(g_s2c_opus_overflow_mutex);
+ osMutexDelete(g_s2c_opus_overflow_mutex);
+ g_s2c_opus_overflow_mutex = NULL;
+ }
+
+ for (;;) {
+ ct_ai_s2c_opus_job_t *left = NULL;
+ osStatus_t st = osMessageQueueGet(g_s2c_opus_queue, &left, NULL, 0U);
+ if (st != osOK) {
+ break;
+ }
+ ct_ai_s2c_opus_job_free(left);
+ }
+
+ osMessageQueueDelete(g_s2c_opus_queue);
+ g_s2c_opus_queue = NULL;
+
+ if (g_s2c_pcm_accum_mutex != NULL) {
+ (void)osMutexAcquire(g_s2c_pcm_accum_mutex, osWaitForever);
+ ct_ai_ws_s2c_pcm_accum_free_inner();
+ (void)osMutexRelease(g_s2c_pcm_accum_mutex);
+ osMutexDelete(g_s2c_pcm_accum_mutex);
+ g_s2c_pcm_accum_mutex = NULL;
+ }
+}
+
+static int ct_ai_ws_s2c_opus_job_post(const char *b64_chunk, size_t b64_len, int sample_rate, bool has_next)
+{
+ if (g_s2c_opus_queue == NULL) {
+ return -1;
+ }
+
+ ct_ai_s2c_opus_job_t *job = (ct_ai_s2c_opus_job_t *)malloc(sizeof(ct_ai_s2c_opus_job_t));
+ if (job == NULL) {
+ CT_AI_WS_ERROR("opus job_post: malloc(job) failed\n");
+ return -1;
+ }
+
+ job->b64_chunk = NULL;
+ job->b64_len = 0U;
+ job->sample_rate = sample_rate;
+ job->has_next = has_next;
+ job->next_overflow = NULL;
+
+ if (b64_len > 0U && b64_chunk != NULL) {
+ job->b64_chunk = (char *)malloc(b64_len + 1U);
+ if (job->b64_chunk == NULL) {
+ CT_AI_WS_ERROR("opus job_post: malloc(b64) failed\n");
+ free(job);
+ return -1;
+ }
+ memcpy(job->b64_chunk, b64_chunk, b64_len);
+ job->b64_chunk[b64_len] = '\0';
+ job->b64_len = b64_len;
+ }
+
+ /* 非阻塞入队:主队列满则挂 FIFO 侧链,避免 WS 回调长时间等 worker 消费完 */
+ osStatus_t pq = osMessageQueuePut(g_s2c_opus_queue, &job, 0U, 0U);
+ if (pq == osOK) {
+ return 0;
+ }
+
+ if (g_s2c_opus_overflow_mutex == NULL) {
+ CT_AI_WS_ERROR("opus job_post: main queue full ret=%d, no overflow\n", (int)pq);
+ ct_ai_s2c_opus_job_free(job);
+ return -1;
+ }
+
+ (void)osMutexAcquire(g_s2c_opus_overflow_mutex, osWaitForever);
+ job->next_overflow = NULL;
+ if (g_s2c_opus_overflow_tail != NULL) {
+ g_s2c_opus_overflow_tail->next_overflow = job;
+ g_s2c_opus_overflow_tail = job;
+ } else {
+ g_s2c_opus_overflow_head = job;
+ g_s2c_opus_overflow_tail = job;
+ }
+ (void)osMutexRelease(g_s2c_opus_overflow_mutex);
+ CT_AI_WS_WARN("opus job_post: main queue full (ret=%d), job moved to overflow fifo\n", (int)pq);
+ return 0;
+}
+
+#else /* !CT_AI_S2C_OPUS_USE_DECODE_QUEUE */
+
+static int ct_ai_ws_s2c_opus_worker_init(void)
+{
+ if (g_s2c_pcm_accum_mutex != NULL) {
+ return 0;
+ }
+
+ g_s2c_pcm_accum_mutex = osMutexNew(NULL);
+ if (g_s2c_pcm_accum_mutex == NULL) {
+ CT_AI_WS_ERROR("opus inline: osMutexNew(pcm accum) failed\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+static void ct_ai_ws_s2c_opus_worker_deinit(void)
+{
+ if (g_s2c_pcm_accum_mutex == NULL) {
+ return;
+ }
+
+ (void)osMutexAcquire(g_s2c_pcm_accum_mutex, osWaitForever);
+ ct_ai_ws_s2c_pcm_accum_free_inner();
+ (void)osMutexRelease(g_s2c_pcm_accum_mutex);
+ osMutexDelete(g_s2c_pcm_accum_mutex);
+ g_s2c_pcm_accum_mutex = NULL;
+}
+
+/* WS 回调线程内联解码:不依赖 hasNext,解码成功后立即按块写入播放队列(与 flush 一致每片最多 1024 字节) */
+static void ct_ai_ws_s2c_opus_decode_on_ws_thread(const char *b64_chunk, size_t b64_len, int sample_rate, bool has_next)
+{
+ (void)has_next;
+
+ int pcm_samples = 0;
+ int dec_ret = -1;
+
+ if (b64_chunk != NULL && b64_len > 0U) {
+ uint8_t *opus_bin = (uint8_t *)malloc(b64_len);
+ if (opus_bin == NULL) {
+ CT_AI_WS_ERROR("opus inline: malloc(base64 decode buf) failed\n");
+ dec_ret = -1;
+ } else {
+ size_t opus_bin_len = 0U;
+ int b64_r = mbedtls_base64_decode(opus_bin, b64_len, &opus_bin_len, (const unsigned char *)b64_chunk, b64_len);
+ if (b64_r == 0 && opus_bin_len > 0U) {
+ dec_ret = opus_frame_to_pcm_decode_packet(opus_bin, (int)opus_bin_len, sample_rate, 1, g_opus_debug_pcm_buf,
+ OPUS_DEBUG_PCM_BUF_SAMPLES, &pcm_samples);
+ } else {
+ dec_ret = -1;
+ }
+ free(opus_bin);
+ }
+ }
+
+ if (b64_chunk != NULL && b64_len > 0U) {
+ if (dec_ret == 0 && pcm_samples > 0) {
+ const uint8_t *pcm_pos = (const uint8_t *)g_opus_debug_pcm_buf;
+ size_t pcm_bytes = (size_t)pcm_samples * sizeof(short);
+ const uint32_t pcm_chunk_size = 1024U;
+
+ while (pcm_bytes > 0U) {
+ uint32_t send_len = (pcm_bytes > (size_t)pcm_chunk_size) ? pcm_chunk_size : (uint32_t)pcm_bytes;
+ AI_SendAudioDataToQueue(pcm_pos, send_len);
+ pcm_pos += send_len;
+ pcm_bytes -= (size_t)send_len;
+ }
+ } else {
+ CT_AI_WS_ERROR("opus inline: decode fail ret=%d pcm_samples=%d\n", dec_ret, pcm_samples);
+ }
+ }
+}
+
+#endif /* CT_AI_S2C_OPUS_USE_DECODE_QUEUE */
+
+// WebSocket服务器地址(与 ct_ai_ws_url_callback 保持一致)
+#define CT_AI_WS_SERVER_IP "8.152.162.54"
+#define CT_AI_WS_SERVER_PORT 9011
+
+// 仅用于“TCP 连接是否可达”的预检超时
+#ifndef CT_AI_WS_CONNECT_VERIFY_TIMEOUT_MS
+#define CT_AI_WS_CONNECT_VERIFY_TIMEOUT_MS 2000
+#endif
+
+// 是否在生成 ws url 前做一次 IP:port TCP 可连通性验证
+#ifndef CT_AI_WS_VERIFY_IP_PORT_BEFORE_CONNECT
+#define CT_AI_WS_VERIFY_IP_PORT_BEFORE_CONNECT 1
+#endif
+
+/**
+ * @brief 验证目标 IP:端口是否可建立 WS 握手连接
+ * @return 0=可连接且握手成功,-1=失败(TCP失败/超时/握手失败/参数错误)
+ */
+static int ct_ai_ws_verify_ip_port_connect(const char *ip, uint16_t port, uint32_t timeout_ms)
+{
+ if (ip == NULL || ip[0] == '\0' || port == 0) {
+ CT_AI_WS_WARN("ct_ai_ws_verify_ip_port_connect: invalid param ip=%p port=%u\n", ip, port);
+ return -1;
+ }
+
+ int sockfd = lwip_socket(AF_INET, SOCK_STREAM, 0);
+ if (sockfd < 0) {
+ CT_AI_WS_ERROR("ct_ai_ws_verify_ip_port_connect: socket create failed: %s\n", strerror(errno));
+ return -1;
+ }
+
+ // 设为非阻塞,避免 lwip_connect 长时间阻塞
+ int flags = fcntl(sockfd, F_GETFL, 0);
+ if (flags >= 0) {
+ (void)fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
+ }
+
+ struct sockaddr_in server_addr;
+ memset(&server_addr, 0, sizeof(server_addr));
+ server_addr.sin_family = AF_INET;
+ server_addr.sin_port = lwip_htons(port);
+
+ if (inet_aton(ip, &server_addr.sin_addr) == 0) {
+ CT_AI_WS_WARN("ct_ai_ws_verify_ip_port_connect: invalid ip=%s\n", ip);
+ lwip_close(sockfd);
+ return -1;
+ }
+
+ int connect_ret = lwip_connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
+ if (connect_ret < 0 && errno != EINPROGRESS) {
+ CT_AI_WS_WARN("ct_ai_ws_verify_ip_port_connect: connect failed ip=%s port=%u err=%s\n",
+ ip, port, strerror(errno));
+ lwip_close(sockfd);
+ return -1;
+ }
+
+ // 等待连接完成(写就绪)
+ fd_set write_fds;
+ FD_ZERO(&write_fds);
+ FD_SET(sockfd, &write_fds);
+
+ struct timeval timeout;
+ timeout.tv_sec = timeout_ms / 1000;
+ timeout.tv_usec = (timeout_ms % 1000) * 1000;
+
+ int sel_ret = lwip_select(sockfd + 1, NULL, &write_fds, NULL, &timeout);
+ if (sel_ret <= 0 || !FD_ISSET(sockfd, &write_fds)) {
+ CT_AI_WS_WARN("ct_ai_ws_verify_ip_port_connect: timeout/fail ip=%s port=%u timeout_ms=%u\n",
+ ip, port, timeout_ms);
+ lwip_close(sockfd);
+ return -1;
+ }
+
+ // 检查 SO_ERROR:0 表示连接成功
+ int so_error = 0;
+ socklen_t optlen = sizeof(so_error);
+ if (lwip_getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &so_error, &optlen) != 0) {
+ CT_AI_WS_WARN("ct_ai_ws_verify_ip_port_connect: getsockopt failed ip=%s port=%u\n", ip, port);
+ lwip_close(sockfd);
+ return -1;
+ }
+
+ if (so_error != 0) {
+ CT_AI_WS_WARN("ct_ai_ws_verify_ip_port_connect: connect not ready ip=%s port=%u so_error=%d\n",
+ ip, port, so_error);
+ lwip_close(sockfd);
+ return -1;
+
+ }
+ /* TCP 已连通,继续发送 WebSocket Upgrade 报文验证 WS 服务可用性 */
+ char ws_req[512] = {0};
+ int req_len = snprintf(ws_req, sizeof(ws_req),
+ "GET /ws/audio HTTP/1.1\r\n"
+ "Host: %s:%u\r\n"
+ "Upgrade: websocket\r\n"
+ "Connection: Upgrade\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "\r\n",
+ ip, port);
+ if (req_len <= 0 || req_len >= (int)sizeof(ws_req)) {
+ CT_AI_WS_WARN("ct_ai_ws_verify_ip_port_connect: build ws request failed\n");
+ lwip_close(sockfd);
+ return -1;
+ }
+
+ int sent = lwip_send(sockfd, ws_req, (size_t)req_len, 0);
+ if (sent != req_len) {
+ CT_AI_WS_WARN("ct_ai_ws_verify_ip_port_connect: send ws request failed sent=%d req_len=%d err=%s\n",
+ sent, req_len, strerror(errno));
+ lwip_close(sockfd);
+ return -1;
+ }
+
+ fd_set read_fds;
+ FD_ZERO(&read_fds);
+ FD_SET(sockfd, &read_fds);
+ timeout.tv_sec = timeout_ms / 1000;
+ timeout.tv_usec = (timeout_ms % 1000) * 1000;
+
+ int read_sel_ret = lwip_select(sockfd + 1, &read_fds, NULL, NULL, &timeout);
+ if (read_sel_ret <= 0 || !FD_ISSET(sockfd, &read_fds)) {
+ CT_AI_WS_WARN("ct_ai_ws_verify_ip_port_connect: ws response timeout/fail ip=%s port=%u timeout_ms=%u\n",
+ ip, port, timeout_ms);
+ lwip_close(sockfd);
+ return -1;
+ }
+
+ char ws_resp[1024] = {0};
+ int recv_len = lwip_recv(sockfd, ws_resp, sizeof(ws_resp) - 1, 0);
+ if (recv_len <= 0) {
+ CT_AI_WS_WARN("ct_ai_ws_verify_ip_port_connect: recv ws response failed len=%d err=%s\n",
+ recv_len, strerror(errno));
+ lwip_close(sockfd);
+ return -1;
+ }
+ ws_resp[recv_len] = '\0';
+
+ if (strstr(ws_resp, "HTTP/1.1 101") == NULL &&
+ strstr(ws_resp, "HTTP/1.0 101") == NULL) {
+ CT_AI_WS_WARN("ct_ai_ws_verify_ip_port_connect: ws handshake status invalid, resp=%s\n", ws_resp);
+ lwip_close(sockfd);
+ return -1;
+ }
+
+ if (strstr(ws_resp, "Upgrade: websocket") == NULL &&
+ strstr(ws_resp, "upgrade: websocket") == NULL) {
+ CT_AI_WS_WARN("ct_ai_ws_verify_ip_port_connect: ws handshake missing Upgrade header, resp=%s\n", ws_resp);
+ lwip_close(sockfd);
+ return -1;
+ }
+
+ CT_AI_WS_INFO("ct_ai_ws_verify_ip_port_connect: ws response: %s\n", ws_resp);
+
+ CT_AI_WS_INFO("ct_ai_ws_verify_ip_port_connect: ws verify success ip=%s port=%u\n", ip, port);
+
+ lwip_close(sockfd);
+ return 0;
+}
+
+int ct_ai_ws_verify_ip_port(const char *ip, uint16_t port, uint32_t timeout_ms)
+{
+ return ct_ai_ws_verify_ip_port_connect(ip, port, timeout_ms);
+}
+
+int ct_ai_ws_verify_default_server(uint32_t timeout_ms)
+{
+ uint32_t verify_timeout_ms = timeout_ms == 0 ? CT_AI_WS_CONNECT_VERIFY_TIMEOUT_MS : timeout_ms;
+ return ct_ai_ws_verify_ip_port_connect(CT_AI_WS_SERVER_IP, CT_AI_WS_SERVER_PORT, verify_timeout_ms);
+}
+
+/*
+ * - g_ws_client_fd 当前 WebSocket 客户端fd
+ * - g_ws_connected 连接状态:0=未连接,1=连接中,2=连接成功
+ * - g_ws_running 心跳线程运行标志
+ */
+
+/* 连接状态定义 */
+#define CT_AI_WS_STATE_DISCONNECTED 0 // 未连接
+#define CT_AI_WS_STATE_CONNECTING 1 // 连接中
+#define CT_AI_WS_STATE_CONNECTED 2 // 连接成功
+#define CT_AI_WS_STATE_SLEEP 3 // 休眠状态
+#define CT_AI_WS_STATE_RECONNECTING 4 // 重连执行中
+
+/* WebSocket关闭状态枚举 */
+typedef enum {
+ WS_CLOSE_NOT_EXECUTED = 0, // 未执行
+ WS_CLOSE_STARTING = 1, // 开始执行
+ WS_CLOSE_SUCCESS = 2 // 执行成功
+} ws_close_status_t;
+
+
+static volatile int g_ws_connected = CT_AI_WS_STATE_DISCONNECTED;
+static volatile int g_ws_running = 0;
+static volatile unsigned int g_ws_reconnect_count = 0; /* 断线后递增,用于URL reconnect参数 */
+// ct_ai_ws_message_callback_t g_ws_message_callback = NULL; /* 消息处理回调函数 */
+static ws_message_callback_t_ct_ai g_ws_message_callback = NULL; /* 消息处理回调函数 */
+
+static volatile ws_close_status_t g_ws_close_status = WS_CLOSE_NOT_EXECUTED; /* WebSocket关闭状态标志位 */
+
+static ws_call_backs_t g_ws_callbacks;
+
+
+static char g_ws_token[256] = {0};
+static char g_ws_deviceId[256] = {0};
+
+/** AI 语音管线是否已由 ct_ai_ws_audio_init 拉起(对齐 ln_api_websocket g_audio_initialized) */
+static volatile bool g_ct_ai_audio_initialized = false;
+
+#ifdef SUPPORT_CAT1_SERVICE
+extern void cat1_api_keep_wakeup(uint8_t keep_wakeup);
+extern void cat1_api_wakeup_cat1(uint8_t wakeup);
+#endif
+
+/** C2S_VOICE_STREAM:默认 PCM 采样率(与协议注释一致) */
+#define CT_AI_WS_VOICE_PCM_DEFAULT_SAMPLE_RATE 16000
+
+/*
+ * 语音流会话:先 ct_ai_ws_voice_stream_start,中间多次 ct_ai_ws_send_voice_stream_pcm(hasNext=true),
+ * 再 ct_ai_ws_voice_stream_end,最后再发一包(可为空)使 hasNext=false 结束。
+ */
+static volatile bool g_voice_stream_started = false;
+/** 为 true 时,下一次 send 的 JSON 中 hasNext=false(由 ct_ai_ws_voice_stream_end 置位) */
+static volatile bool g_voice_stream_next_is_last = false;
+
+static void ct_ai_ws_voice_stream_reset_session(void)
+{
+ g_voice_stream_started = false;
+ g_voice_stream_next_is_last = false;
+}
+
+void ct_ai_ws_voice_stream_start(void)
+{
+ g_voice_stream_started = true;
+ g_voice_stream_next_is_last = false;
+ CT_AI_WS_DEBUG("voice stream start\n");
+}
+
+void ct_ai_ws_voice_stream_end(void)
+{
+ if (!g_voice_stream_started) {
+ CT_AI_WS_WARN("voice stream end: not started\n");
+ return;
+ }
+ g_voice_stream_next_is_last = true;
+ CT_AI_WS_DEBUG("voice stream end: next send will use hasNext=false\n");
+}
+
+int ct_ai_ws_send_voice_stream_pcm(const uint8_t *pcm, uint32_t pcm_len, uint32_t sample_rate)
+{
+ if (g_ws_connected != CT_AI_WS_STATE_CONNECTED) {
+ CT_AI_WS_WARN("send_voice_stream: ws not connected\n");
+ return -1;
+ }
+ if (!g_voice_stream_started) {
+ CT_AI_WS_WARN("send_voice_stream: call ct_ai_ws_voice_stream_start first\n");
+ return -1;
+ }
+
+ if (sample_rate == 0) {
+ sample_rate = CT_AI_WS_VOICE_PCM_DEFAULT_SAMPLE_RATE;
+ }
+
+ const uint8_t *src = pcm;
+ uint32_t slen = pcm_len;
+ if (pcm == NULL || pcm_len == 0) {
+ src = (const uint8_t *)"";
+ slen = 0;
+ }
+
+ size_t b64_buf_len = (slen == 0) ? 1u : ((slen + 2u) / 3u) * 4u + 4u;
+ unsigned char *b64_buf = (unsigned char *)malloc(b64_buf_len);
+ if (b64_buf == NULL) {
+ CT_AI_WS_ERROR("send_voice_stream: malloc failed\n");
+ return -1;
+ }
+
+ size_t olen = 0;
+ int br = mbedtls_base64_encode(b64_buf, b64_buf_len, &olen, src, slen);
+ if (br != 0) {
+ CT_AI_WS_ERROR("send_voice_stream: base64 encode failed %d\n", br);
+ free(b64_buf);
+ return -1;
+ }
+ b64_buf[olen] = '\0';
+
+ bool has_next = !g_voice_stream_next_is_last;
+
+ cJSON *root = cJSON_CreateObject();
+ if (root == NULL) {
+ free(b64_buf);
+ return -1;
+ }
+ cJSON_AddStringToObject(root, "type", "C2S_VOICE_STREAM");
+ cJSON *data = cJSON_CreateObject();
+ if (data == NULL) {
+ cJSON_Delete(root);
+ free(b64_buf);
+ return -1;
+ }
+ cJSON_AddStringToObject(data, "format", "PCM");
+ cJSON_AddNumberToObject(data, "sampleRate", (double)sample_rate);
+ cJSON_AddStringToObject(data, "chunk", (const char *)b64_buf);
+ cJSON_AddBoolToObject(data, "hasNext", (cJSON_bool)(has_next ? 1 : 0));
+ cJSON_AddItemToObject(root, "data", data);
+
+ char *json_str = cJSON_PrintUnformatted(root);
+ cJSON_Delete(root);
+ free(b64_buf);
+
+ if (json_str == NULL) {
+ CT_AI_WS_ERROR("send_voice_stream: cJSON_Print failed\n");
+ return -1;
+ }
+
+ int send_ret = uapi_ws_send_text(json_str);
+ cJSON_free(json_str);
+
+ if (send_ret != 0) {
+ CT_AI_WS_ERROR("send_voice_stream: uapi_ws_send_text failed %d\n", send_ret);
+ return -1;
+ }
+
+ if (g_voice_stream_next_is_last) {
+ ct_ai_ws_voice_stream_reset_session();
+ }
+
+ return 0;
+}
+
+/* 播放侧写盘回调:对齐 ln_ws_audio_write_callback(此处不强制拉 A2DP,避免依赖雷鸟蓝牙符号) */
+static void ct_ai_ws_audio_write_callback(uint32_t size)
+{
+ (void)size;
+}
+
+/*
+ * 录音编码后的上行数据回调(对齐 AIVoiceDataCallback_ln 的入口职责)。
+ * 上行 PCM 发往服务端:先 ct_ai_ws_voice_stream_start(),再在回调或任务中调用 ct_ai_ws_send_voice_stream_pcm(),
+ * 结束前 ct_ai_ws_voice_stream_end(),再发最后一包(hasNext=false)。
+ */
+static void ct_ai_AIVoiceDataCallback(const uint8_t *data, uint32_t size, void *userData)
+{
+ (void)data;
+ (void)size;
+ (void)userData;
+ if(g_ct_ai_audio_initialized==true && data!=NULL && size>0 && g_voice_stream_started==true)
+ {
+ CT_AI_WS_DEBUG("ct_ai_AIVoiceDataCallback: size=%u\n", size);
+ // CT_AI_WS_ERROR("ct_ai_AIVoiceDataCallback: g_ct_ai_audio_initialized=%d, data=%p, size=%u, g_voice_stream_started=%d\n", g_ct_ai_audio_initialized, data, size, g_voice_stream_started);
+ ct_ai_ws_send_voice_stream_pcm(data, size, CT_AI_WS_VOICE_PCM_DEFAULT_SAMPLE_RATE);
+ return;
+ }
+}
+
+
+
+void ct_ai_ws_set_token(void)
+{
+ char token[256] = {0};
+ char deviceId[256] = {0};
+ int ret = ct_ai_http_token(token, deviceId, sizeof(token), sizeof(deviceId), 9011);
+
+ strncpy(g_ws_token, token, sizeof(g_ws_token));
+ strncpy(g_ws_deviceId, deviceId, sizeof(g_ws_deviceId));
+ CT_AI_WS_INFO("ct_ai_ws_set_token: token=%s, deviceId=%s\n", g_ws_token, g_ws_deviceId);
+
+ if (ret != 200) {
+ CT_AI_WS_ERROR("ct_ai_ws_set_token failed: %d\n", ret);
+ }
+}
+// C2S_HEARTBEAT
+
+void ct_ai_send_ws_ping(void)
+{
+ char ping_buf[256] = {0};
+ snprintf(ping_buf, sizeof(ping_buf), "{\"type\":\"C2S_HEARTBEAT\"}");
+
+
+ int ret = uapi_ws_send_text(ping_buf);
+ if (ret != 0) {
+ CT_AI_WS_ERROR("ct_ai_send_ws_ping failed: %d\n", ret);
+ }
+}
+
+// {
+// "type": "C2S_AUTH",
+// "data": {
+// "deviceId": "device_123456",
+// "token": "your_token_here",
+// "imei": "your_device_imei"
+// }
+// }
+void ct_ai_send_ws_auth(void)
+{
+ cJSON *root = cJSON_CreateObject();
+ cJSON_AddStringToObject(root, "type", "C2S_AUTH");
+ cJSON *data = cJSON_CreateObject();
+ cJSON_AddStringToObject(data, "token", g_ws_token);
+ cJSON_AddStringToObject(data, "deviceId", g_ws_deviceId);
+
+ cJSON_AddItemToObject(root, "data", data);
+
+ char *json_str = cJSON_Print(root);
+ cJSON_Delete(root);
+ if (json_str == NULL) {
+ CT_AI_WS_ERROR("ct_ai_send_ws_auth failed: json_str is null\n");
+ return;
+ }
+ int ret = uapi_ws_send_text(json_str);
+ if (ret != 0) {
+ CT_AI_WS_ERROR("ct_ai_send_ws_auth failed: %d\n", ret);
+ }
+ cJSON_free(json_str);
+}
+
+
+char *ct_ai_ws_get_token(void)
+{
+ return g_ws_token;
+}
+// {"type":"S2C_AUDIO_STREAM","data":{"format":"PCM","sampleRate":16000,"chunk":"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","hasNext":true}}
+
+static void ct_ai_ws_message_callback(const char *raw_data, uint32_t timestamp)
+{
+ // CT_AI_WS_INFO("ct_ai_ws_message_callback: %s\n", raw_data);
+ if(raw_data != NULL)
+ {
+ CT_AI_WS_INFO("ct_ai_ws_message_callback: %s\n", raw_data);
+ cJSON *root = cJSON_Parse(raw_data);
+ if (root == NULL) {
+ CT_AI_WS_ERROR("ct_ai_ws_message_callback: cJSON_Parse failed\n");
+ return;
+ }
+ cJSON *data = cJSON_GetObjectItem(root, "data");
+ if (data == NULL) {
+ CT_AI_WS_ERROR("ct_ai_ws_message_callback: data is null\n");
+ cJSON_Delete(root);
+ return;
+ }
+ cJSON *format = cJSON_GetObjectItem(data, "format");
+ if (format == NULL) {
+ CT_AI_WS_ERROR("ct_ai_ws_message_callback: format is null\n");
+ cJSON_Delete(root);
+ return;
+ }
+ CT_AI_WS_INFO("ct_ai_ws_message_callback: format: %s\n", format->valuestring);
+ cJSON *sampleRate = cJSON_GetObjectItem(data, "sampleRate");
+ if (sampleRate == NULL) {
+ CT_AI_WS_ERROR("ct_ai_ws_message_callback: sampleRate is null\n");
+ cJSON_Delete(root);
+ return;
+ }
+ CT_AI_WS_INFO("ct_ai_ws_message_callback: sampleRate: %d\n", sampleRate->valueint);
+ cJSON *chunk = cJSON_GetObjectItem(data, "chunk");
+ if (chunk == NULL) {
+ CT_AI_WS_ERROR("ct_ai_ws_message_callback: chunk is null\n");
+ cJSON_Delete(root);
+ return;
+ }
+
+ cJSON *has_next_item = cJSON_GetObjectItem(data, "hasNext");
+ bool has_next = true;
+ if (cJSON_IsBool(has_next_item)) {
+ has_next = (bool)cJSON_IsTrue(has_next_item);
+ } else if (cJSON_IsNumber(has_next_item)) {
+ has_next = (has_next_item->valueint != 0);
+ }
+
+ const char *chunk_str = (chunk->valuestring != NULL) ? chunk->valuestring : "";
+ size_t chunk_b64_len = strlen(chunk_str);
+
+ int sample_rate = (sampleRate->valueint > 0) ? sampleRate->valueint : 16000;
+#if CT_AI_S2C_OPUS_USE_DECODE_QUEUE
+ if (chunk_b64_len > 0U) {
+ if (ct_ai_ws_s2c_opus_job_post(chunk_str, chunk_b64_len, sample_rate, has_next) != 0) {
+ CT_AI_WS_ERROR("ct_ai_ws_message_callback: opus job post failed\n");
+ }
+ } else if (!has_next) {
+ if (ct_ai_ws_s2c_opus_job_post(NULL, 0U, sample_rate, false) != 0) {
+ CT_AI_WS_ERROR("ct_ai_ws_message_callback: opus flush job post failed\n");
+ }
+ } else {
+ CT_AI_WS_ERROR("ct_ai_ws_message_callback: chunk b64 len is 0\n");
+ }
+#else
+ if (chunk_b64_len > 0U) {
+ ct_ai_ws_s2c_opus_decode_on_ws_thread(chunk_str, chunk_b64_len, sample_rate, has_next);
+ } else if (!has_next) {
+ ct_ai_ws_s2c_opus_decode_on_ws_thread(NULL, 0U, sample_rate, false);
+ } else {
+ CT_AI_WS_ERROR("ct_ai_ws_message_callback: chunk b64 len is 0\n");
+ }
+#endif
+
+ cJSON_Delete(root);
+ }
+ else
+ {
+ CT_AI_WS_ERROR("ct_ai_ws_message_callback: raw_data is null\n");
+ }
+}
+
+
+/* 连接事件回调函数 */
+static void ct_ai_ws_event_callback(ws_event_type_t event_type)
+{
+ switch (event_type) {
+ case WS_EVENT_CONNECTING:
+ CT_AI_WS_INFO("Event: Connecting\n");
+ g_ws_connected = CT_AI_WS_STATE_CONNECTING;
+ break;
+ case WS_EVENT_CONNECTED:
+ CT_AI_WS_INFO("Event: Connected\n");
+ g_ws_connected = CT_AI_WS_STATE_CONNECTED;
+ ct_ai_ws_set_token();
+ ct_ai_send_ws_auth();
+ /* 连接就绪后启动 AI 语音服务(与 ln_ws_audio_init 一致,使用本模块连接状态) */
+ ct_ai_ws_audio_init(false);
+ // 重置 ping 超时状态
+ // g_ping_timeout_active = false;
+ // g_ping_send_tick = 0;
+
+ // 触发连接成功事件
+ if (g_ws_message_callback != NULL) {
+ g_ws_message_callback(NULL, CT_AI_WS_CMD_CONNECTED);
+ }
+ break;
+ case WS_EVENT_DISCONNECTED:
+ CT_AI_WS_INFO("Event: Disconnected\n");
+ g_ws_connected = CT_AI_WS_STATE_DISCONNECTED;
+ ct_ai_ws_s2c_pcm_accum_free();
+ ct_ai_ws_voice_stream_reset_session();
+ // 重置 ping 超时状态
+ // g_ping_timeout_active = false;
+ // g_ping_send_tick = 0;
+
+ // // 触发断连事件
+ if (g_ws_message_callback != NULL) {
+ g_ws_message_callback(NULL, CT_AI_WS_CMD_DISCONNECTED);
+ }
+
+ /* 断开后增加重连计数,由监督线程在下一次连接时携带 */
+ if (g_ws_running) {
+ if (g_ws_reconnect_count < 0xFFFFFFFFu) {
+ g_ws_reconnect_count++;
+ }
+ }
+ break;
+ default:
+ CT_AI_WS_ERROR("Event: Unknown event type %d\n", event_type);
+ break;
+ }
+}
+// ws://8.152.162.54:9011/ws/audio
+
+/* 心跳处理回调函数 */
+static int ct_ai_ws_heartbeat_callback(void)
+{
+ // 每30秒发送一次心跳
+ static int heartbeat_counter = 0;
+ heartbeat_counter++;
+
+
+ if (heartbeat_counter >= CT_AI_WS_HEARTBEAT_COUNTER_THRESHOLD) { // 30秒心跳间隔
+ heartbeat_counter = 0;
+ CT_AI_WS_INFO("Sending heartbeat (interval: %u ms, threshold: %u)\n",
+ CT_AI_WS_MAIN_THREAD_INTERVAL_MS, CT_AI_WS_HEARTBEAT_COUNTER_THRESHOLD);
+ // ct_ai_ws_send_ping();
+ ct_ai_send_ws_ping();
+ return 1;
+ }
+ return 0;
+}
+
+static int ct_ai_ws_url_callback(char *url, size_t url_size, char *header_buf, size_t header_size)
+{
+ // CT_AI_WS_INFO("ct_ai_ws_url_callback: url=%s, url_size=%u, header_buf=%s, header_size=%u\n", url, url_size, header_buf, header_size);
+#if CT_AI_WS_VERIFY_IP_PORT_BEFORE_CONNECT
+ if (ct_ai_ws_verify_ip_port_connect(CT_AI_WS_SERVER_IP, CT_AI_WS_SERVER_PORT, CT_AI_WS_CONNECT_VERIFY_TIMEOUT_MS) != 0) {
+ CT_AI_WS_WARN("Pre-check TCP connect failed: %s:%d\n", CT_AI_WS_SERVER_IP, CT_AI_WS_SERVER_PORT);
+ return -1;
+ }
+#endif
+ snprintf(url, url_size, "ws://%s:%d/ws/audio", CT_AI_WS_SERVER_IP, CT_AI_WS_SERVER_PORT);
+ // snprintf(header_buf, header_size, "X-WS-Debug: handshake-probe\r\n");
+ // snprintf(url, url_size, "ws://115.190.94.208:22080/vc/chat");
+ return 0;
+}
+
+static void ai_binary_message_handler(const uint8_t *raw_data, uint32_t timestamp, uint32_t data_len)
+{
+ CT_AI_WS_INFO("ai_binary_message_handler");
+}
+
+void ct_ai_ws_audio_init(bool is_vad_server_enabled)
+{
+ if (g_ct_ai_audio_initialized) {
+ CT_AI_WS_WARN("Audio already initialized, skip\n");
+ return;
+ }
+ if (g_ws_connected != CT_AI_WS_STATE_CONNECTED) {
+ CT_AI_WS_WARN("WebSocket not connected (state=%d), skip audio init\n", g_ws_connected);
+ return;
+ }
+
+ AIVoiceAudioParams audioParams_in = {
+ .audioFormat = PCM,
+ .channelCount = 1,
+ .sampleRate = 16000,
+ };
+ AIVoiceAudioParams audioParams_in_vad = {
+ .audioFormat = PCM,
+ .channelCount = 1,
+ .sampleRate = 16000,
+ };
+ AIVoiceAudioParams audioParams_out = {
+ .audioFormat = PCM,
+ .channelCount = 1,
+ .sampleRate = 16000,
+ };
+
+#ifdef SUPPORT_CAT1_SERVICE
+ cat1_api_keep_wakeup(1);
+ cat1_api_wakeup_cat1(1);
+#endif
+ uapi_cat1_add_cat1_vote();
+
+ if (old_Start_AIVoice(ct_ai_AIVoiceDataCallback, NULL, &audioParams_in, &audioParams_out,
+ NULL, false) != 0) {
+ CT_AI_WS_ERROR("old_Start_AIVoice failed\n");
+ uapi_cat1_remove_cat1_vote();
+#ifdef SUPPORT_CAT1_SERVICE
+ cat1_api_keep_wakeup(0);
+ cat1_api_wakeup_cat1(0);
+#endif
+ return;
+ }
+
+ g_ct_ai_audio_initialized = true;
+ uapi_ws_wake_keep(1);
+ CT_AI_WS_INFO("ct_ai_ws_audio_init done (vad_server=%d)\n", (int)is_vad_server_enabled);
+}
+
+void ct_ai_ws_audio_deinit(void)
+{
+ if (!g_ct_ai_audio_initialized) {
+ CT_AI_WS_WARN("Audio not initialized, skip deinit\n");
+ return;
+ }
+
+ StopAIVoice();
+
+#ifdef SUPPORT_CAT1_SERVICE
+ cat1_api_keep_wakeup(0);
+ cat1_api_wakeup_cat1(0);
+#endif
+ uapi_cat1_remove_cat1_vote();
+
+ uapi_ws_wake_keep(0);
+ g_ct_ai_audio_initialized = false;
+ CT_AI_WS_INFO("ct_ai_ws_audio_deinit done\n");
+}
+
+bool ct_ai_ws_is_audio_initialized(void)
+{
+ return g_ct_ai_audio_initialized;
+}
+
+int ct_ai_ws_start(ws_message_callback_t_ct_ai callback, uint32_t audio_timeout_ticks)
+{
+ if (g_ws_running) {
+ return 0;
+ }
+ g_ws_running = 1;
+ g_ws_reconnect_count = 0; /* 启动时从0开始 */
+ g_ws_connected = CT_AI_WS_STATE_DISCONNECTED; /* 启动时重置连接状态 */
+
+
+ // 注册回调函数
+ g_ws_message_callback = callback;
+ if (callback != NULL) {
+ CT_AI_WS_DEBUG("Message callback registered successfully\n");
+ } else {
+ CT_AI_WS_WARN("Using default message handler\n");
+ }
+
+ // 设置回调函数结构体
+ g_ws_callbacks.message_callback = ct_ai_ws_message_callback;
+ g_ws_callbacks.event_callback = ct_ai_ws_event_callback;
+ g_ws_callbacks.url_callback = ct_ai_ws_url_callback;
+ g_ws_callbacks.heartbeat_callback = ct_ai_ws_heartbeat_callback;
+ g_ws_callbacks.reconnect_success_callback = NULL;
+ g_ws_callbacks.incomplete_callback = NULL;
+ g_ws_callbacks.binary_callback = ai_binary_message_handler;
+ g_ws_callbacks.main_thread_interval_ms = CT_AI_WS_MAIN_THREAD_INTERVAL_MS;
+ // 启动WebSocket服务
+ int ret = uapi_ws_start(&g_ws_callbacks);
+ if (ret != 0) {
+ CT_AI_WS_WARN("uapi_ws_start failed: %d\n", ret);
+ g_ws_running = 0;
+ return ret;
+ }
+
+ if (ct_ai_ws_s2c_opus_worker_init() != 0) {
+ CT_AI_WS_ERROR("ct_ai_ws_start: opus worker init failed\n");
+ uapi_ws_stop();
+ g_ws_running = 0;
+ return -1;
+ }
+
+ /* 与 ln_ws_start 一致:先注册播放写回调,再在连接成功时 ct_ai_ws_audio_init 内 old_Start_AIVoice */
+ (void)AI_RegisterWriteAudioDataCallback(ct_ai_ws_audio_write_callback);
+
+ (void)audio_timeout_ticks;
+
+ uint8_t cnt = pm_veto_get_id_cnt(PM_ID_SPI);
+ if (cnt == 0)
+ {
+ uapi_pm_add_sleep_veto(PM_ID_SPI);
+ }
+
+ ret = uapi_pm_request_mode(PM_ID_SPI, PM_MODE_PERFORMACE);
+ CT_AI_WS_INFO("uapi_pm_request_mode ret : %X\n",ret);
+
+ return 0;
+}
+
+
+bool ct_ai_ws_stop(void)
+{
+ ct_ai_ws_audio_deinit();
+ uapi_ws_stop();
+ ct_ai_ws_s2c_opus_worker_deinit();
+ g_ws_connected = CT_AI_WS_STATE_DISCONNECTED;
+ g_ws_running = 0;
+ g_ws_reconnect_count = 0;
+ g_ws_message_callback = NULL;
+ g_ws_close_status = WS_CLOSE_NOT_EXECUTED;
+ CT_AI_WS_INFO("ct_ai_ws_stop success");
+ return true;
+}
+
+
--- /dev/null
+cmake_minimum_required(VERSION 3.16)
+
+# ChangAn 业务 HTTP 模块
+set(COMPONENT_NAME "ChangAan")
+
+set(SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/http/changan_http_common.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/http/changan_http_sign.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/changan_api_at.c
+)
+
+set(PUBLIC_HEADER
+ ${CMAKE_CURRENT_SOURCE_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}/http
+ ${ROOT_DIR}/middleware/utils/at/wstp_at/inc
+ ${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/include
+ ${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include
+ ${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/modules/netstack/http/include
+)
+
+set(PRIVATE_HEADER
+ ${ROOT_DIR}/include/middleware/services/bts/common
+ ${ROOT_DIR}/zhihui/services/ble_service/bleservice
+ ${ROOT_DIR}/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/include
+ ${ROOT_DIR}/open_source/mbedtls/mbedtls_v3.6.0/include
+)
+
+# ChangAan AT 调用 bleICCE 会话密钥自测,链接 bleservice
+set(LIBS
+ bleservice
+)
+
+set(PUBLIC_DEFINES
+ SUPPORT_AT_CHANGAN
+)
+
+set(PRIVATE_DEFINES
+ SUPPORT_AT_CHANGAN
+)
+
+set(COMPONENT_PUBLIC_CCFLAGS
+)
+
+set(COMPONENT_CCFLAGS
+ -Wall
+ -Wextra
+)
+
+set(WHOLE_LINK
+ false
+)
+
+set(MAIN_COMPONENT
+ false
+)
+
+build_component()
+
--- /dev/null
+# SessionKey 自测:icce_session_key_selftest.c → 可执行文件(与 bleICCE.c 派生逻辑一致)
+# 认证响应 payload TLV 自测:icce_auth_payload_selftest.c → 与 bleICCE.c icce_tlv_build + icce_auth_send_sync_response 组包一致
+#
+# WSL / Linux:
+# 1) 安装系统 mbedtls(链接用,必须):
+# sudo apt update && sudo apt install -y build-essential libmbedtls-dev
+# 2) 编译头文件优先用本仓库 SDK 内 mbedtls(无需 pkg-config):
+# cd code/sdk/zhihui/ChangAan && make && ./icce_session_key_selftest
+#
+# make run # 编译并运行
+# make clean # 删除生成文件
+#
+# 若链接报错 cannot find -lmbedcrypto:请执行上面的 apt install libmbedtls-dev
+
+THIS_MAKE := $(abspath $(lastword $(MAKEFILE_LIST)))
+CHANGAN_DIR := $(dir $(THIS_MAKE))
+# code/sdk/zhihui/ChangAan -> code/sdk/open_source/mbedtls/.../include
+MBEDTLS_SDK_INC := $(abspath $(CHANGAN_DIR)../../open_source/mbedtls/mbedtls_v3.6.0/include)
+
+CC ?= gcc
+CFLAGS ?= -O2 -Wall -std=c11
+# 始终带上 SDK 头文件路径(不依赖 pkg-config / 未装 libmbedtls-dev 时也能通过 #include)
+CFLAGS += -I$(MBEDTLS_SDK_INC)
+
+TARGET := icce_session_key_selftest
+SRC := icce_session_key_selftest.c
+
+TARGET_AUTH_PL := icce_auth_payload_selftest
+SRC_AUTH_PL := icce_auth_payload_selftest.c
+
+# 无 pkg-config 时静默,避免 “Command not found”
+PKG_CFLAGS := $(shell command -v pkg-config >/dev/null 2>&1 && pkg-config --silence-errors --cflags mbedtls 2>/dev/null)
+PKG_LIBS := $(shell command -v pkg-config >/dev/null 2>&1 && pkg-config --silence-errors --libs mbedtls 2>/dev/null)
+
+ifneq ($(strip $(PKG_LIBS)),)
+ CFLAGS += $(PKG_CFLAGS)
+ LDLIBS := $(PKG_LIBS)
+else
+ LDLIBS := -lmbedcrypto
+endif
+
+.PHONY: all clean run run-auth-payload check help
+
+help:
+ @echo "ChangAan host selftests"
+ @echo " SessionKey: $(TARGET) (needs mbedtls)"
+ @echo " Auth TLV: $(TARGET_AUTH_PL) (no extra libs)"
+ @echo " Headers: -I $(MBEDTLS_SDK_INC)"
+ @echo " SessionKey link: $(LDLIBS)"
+ @echo "Install lib if link fails: sudo apt install -y libmbedtls-dev"
+
+all: $(TARGET) $(TARGET_AUTH_PL)
+
+$(TARGET): $(SRC)
+ $(CC) $(CFLAGS) -o $@ $< $(LDLIBS)
+
+$(TARGET_AUTH_PL): $(SRC_AUTH_PL)
+ $(CC) $(CFLAGS) -o $@ $<
+
+clean:
+ rm -f $(TARGET) $(TARGET_AUTH_PL)
+
+run: $(TARGET)
+ ./$(TARGET)
+
+run-auth-payload: $(TARGET_AUTH_PL)
+ ./$(TARGET_AUTH_PL)
+
+check: $(TARGET) $(TARGET_AUTH_PL)
+ ./$(TARGET_AUTH_PL)
+ ./$(TARGET)
--- /dev/null
+/**
+ * @file changan_api_at.c
+ * @brief ChangAn 统一 AT 接口:注册 AT^CHANGAN_* 命令(HTTP、OAuth/控车/vrtm、DKEY含 ENSURE 一体流程、ICCE 等),放在 ChangAan 根目录。
+ */
+
+#include <ctype.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#ifndef CHANGAN_AT_QR_RESP_CAP
+#define CHANGAN_AT_QR_RESP_CAP (64u * 1024u)
+#endif
+#ifndef CHANGAN_AT_QR_STATUS_RSP_CAP
+#define CHANGAN_AT_QR_STATUS_RSP_CAP 4096u
+#endif
+#ifndef CHANGAN_AT_OAUTH_RSP_CAP
+#define CHANGAN_AT_OAUTH_RSP_CAP 4096u
+#endif
+#ifndef CHANGAN_AT_CTRL_CAR_RSP_CAP
+#define CHANGAN_AT_CTRL_CAR_RSP_CAP (64u * 1024u)
+#endif
+#ifndef CHANGAN_AT_DKEY_RSP_CAP
+#define CHANGAN_AT_DKEY_RSP_CAP (64u * 1024u)
+#endif
+#ifndef CHANGAN_AT_DKEY_PEM_CAP
+#define CHANGAN_AT_DKEY_PEM_CAP 4096u
+#endif
+#ifndef CHANGAN_AT_DKEY_SPKI_CAP
+#define CHANGAN_AT_DKEY_SPKI_CAP 768u
+#endif
+#ifndef CHANGAN_AT_DKEY_CARD_INFO_CAP
+#define CHANGAN_AT_DKEY_CARD_INFO_CAP 4096u
+#endif
+#ifndef CHANGAN_AT_DKEY_PUBLIC_KEY_ID_CAP
+#define CHANGAN_AT_DKEY_PUBLIC_KEY_ID_CAP 64u
+#endif
+#ifndef CHANGAN_AT_QR_ID_CAP
+#define CHANGAN_AT_QR_ID_CAP 128u
+#endif
+
+#include "errcode.h"
+#include "at_cmd_api.h"
+#include "changan_http_api.h"
+#include "securec.h"
+#include "stdbool.h"
+#include "bts_def.h"
+#include "bleICCE.h"
+#include "bleService.h"
+
+#define CHANGAN_UNUSED(a) ((void)(a))
+
+extern bool ble_icce_start_scan_for_device(bd_addr_t *addr);
+extern bool ble_icce_connect_to_device(bd_addr_t *addr);
+extern void ble_icce_notify_frame_process(uint8_t client_id, uint16_t conn_id, const uint8_t *data, uint16_t len);
+
+#ifndef CHANGAN_AT_MAX_ARGC
+#define CHANGAN_AT_MAX_ARGC 8
+#endif
+#ifndef CHANGAN_AT_MAX_ARGV_LEN
+#define CHANGAN_AT_MAX_ARGV_LEN 10
+#endif
+
+/* 解析 AT 参数:para 中以 ',' 或 '=' 分隔,结果写入 argv[][], *argc */
+static int changan_parse_params(uint8_t *para, uint32_t para_len,
+ uint8_t argv[CHANGAN_AT_MAX_ARGC][CHANGAN_AT_MAX_ARGV_LEN],
+ uint32_t *argc)
+{
+ uint32_t pos = 0;
+ *argc = 0;
+ if (para == NULL) {
+ return -1;
+ }
+ for (uint32_t i = 0; i < para_len && *argc < CHANGAN_AT_MAX_ARGC; i++) {
+ if (para[i] == ',' || para[i] == '=' || para[i] == ' ' || para[i] == '\n' || para[i] == '\r') {
+ if (pos > 0) {
+ argv[*argc][pos] = '\0';
+ (*argc)++;
+ pos = 0;
+ }
+ continue;
+ }
+ if (pos >= CHANGAN_AT_MAX_ARGV_LEN - 1) {
+ return -1;
+ }
+ argv[*argc][pos++] = para[i];
+ }
+ if (pos > 0) {
+ argv[*argc][pos] = '\0';
+ (*argc)++;
+ }
+ return 0;
+}
+
+/* 解析蓝牙地址:"AA:BB:CC:DD:EE:FF" 或 "AABBCCDDEEFF",与栈内 bd_addr_t 字节序一致(与 LN AT 一致:反序存储) */
+static int changan_parse_bt_address(const char *addr_str, bd_addr_t *addr)
+{
+ if (addr_str == NULL || addr == NULL) {
+ return -1;
+ }
+ unsigned int addr_bytes[6] = { 0 };
+ int count = sscanf(addr_str, "%02X:%02X:%02X:%02X:%02X:%02X",
+ &addr_bytes[0], &addr_bytes[1], &addr_bytes[2],
+ &addr_bytes[3], &addr_bytes[4], &addr_bytes[5]);
+ if (count != 6) {
+ count = sscanf(addr_str, "%02X%02X%02X%02X%02X%02X",
+ &addr_bytes[0], &addr_bytes[1], &addr_bytes[2],
+ &addr_bytes[3], &addr_bytes[4], &addr_bytes[5]);
+ if (count != 6) {
+ return -1;
+ }
+ }
+ addr->addr[0] = (uint8_t)addr_bytes[5];
+ addr->addr[1] = (uint8_t)addr_bytes[4];
+ addr->addr[2] = (uint8_t)addr_bytes[3];
+ addr->addr[3] = (uint8_t)addr_bytes[2];
+ addr->addr[4] = (uint8_t)addr_bytes[1];
+ addr->addr[5] = (uint8_t)addr_bytes[0];
+ addr->type = BT_ADDRESS_TYPE_PUBLIC_DEVICE_ADDRESS;
+ return 0;
+}
+
+/* 与 bleICCE.c 组包上限一致,避免超长写 GATT */
+#ifndef CHANGAN_ICCE_SEND_RAW_MAX_FRAME
+#define CHANGAN_ICCE_SEND_RAW_MAX_FRAME 320u
+#endif
+
+static int changan_at_hex_nibble(int c)
+{
+ if (c >= '0' && c <= '9') {
+ return c - '0';
+ }
+ if (c >= 'A' && c <= 'F') {
+ return c - 'A' + 10;
+ }
+ if (c >= 'a' && c <= 'f') {
+ return c - 'a' + 10;
+ }
+ return -1;
+}
+
+/* 将连续十六进制串转为字节(可含空格/逗号/制表,忽略);半字节数则失败。sl 可为 para 区(可非 '\\0' 结尾) */
+static int changan_at_hex_to_bytes_s(const char *s, uint32_t sl, uint8_t *out, uint16_t out_cap, uint16_t *out_len)
+{
+ if (s == NULL || out == NULL || out_len == NULL) {
+ return -1;
+ }
+ *out_len = 0;
+ int hi = -1;
+ for (uint32_t i = 0; i < sl; i++) {
+ char c = s[i];
+ if (c == '\0') {
+ break;
+ }
+ if (isspace((unsigned char)c) || c == ',') {
+ continue;
+ }
+ int v = changan_at_hex_nibble((int)(unsigned char)c);
+ if (v < 0) {
+ return -1;
+ }
+ if (hi < 0) {
+ hi = v;
+ } else {
+ if (*out_len >= out_cap) {
+ return -2;
+ }
+ out[*out_len] = (uint8_t)(((unsigned)hi << 4) | (unsigned)v);
+ (*out_len)++;
+ hi = -1;
+ }
+ }
+ if (hi >= 0) {
+ return -3; /* 奇数个十六进制半字节 */
+ }
+ return 0;
+}
+
+/* 异步入队;HTTP 完成日志见 changan_http_default_result_handler([changan_http][default]) */
+static void changan_at_http_noop_cb(void *ud, const changan_http_result_t *r)
+{
+ (void)ud;
+ (void)r;
+}
+
+static uint32_t changan_at_http_submit_ok(int ret, const char *tag)
+{
+ if (ret == 0) {
+ printf("[CHANGAN][AT] %s enqueued\r\n", tag);
+ return ERRCODE_SUCC;
+ }
+ printf("[CHANGAN][AT] %s submit failed ret=%d\r\n", tag, ret);
+ return ERRCODE_FAIL;
+}
+
+/* AT^CHANGAN_TEST - 仅打印,用于确认 AT 模块已加载 */
+static uint32_t changan_test_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+ printf("[CHANGAN][AT] AT^CHANGAN_TEST ok\r\n");
+ return ERRCODE_SUCC;
+}
+
+/* AT^CHANGAN_HTTP_GET=<url> */
+static uint32_t changan_http_get_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(str_cmd);
+ if (para == NULL || para_len == 0) {
+ printf("[CHANGAN][AT] Usage: AT^CHANGAN_HTTP_GET=<url>\r\n");
+ return ERRCODE_FAIL;
+ }
+ uint8_t argv[CHANGAN_AT_MAX_ARGC][CHANGAN_AT_MAX_ARGV_LEN];
+ uint32_t argc = 0;
+ if (changan_parse_params(para, para_len, argv, &argc) != 0 || argc < 1) {
+ printf("[CHANGAN][AT] invalid params\r\n");
+ return ERRCODE_FAIL;
+ }
+ char *url = (char *)argv[0];
+ int ret = changan_http_get(NULL, url, changan_at_http_noop_cb, NULL);
+
+ return changan_at_http_submit_ok(ret, "HTTP_GET");
+}
+
+/* AT^CHANGAN_HTTP_POST=<url>,<body> */
+static uint32_t changan_http_post_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(str_cmd);
+ if (para == NULL || para_len == 0) {
+ printf("[CHANGAN][AT] Usage: AT^CHANGAN_HTTP_POST=<url>,<body>\r\n");
+ return ERRCODE_FAIL;
+ }
+ uint8_t argv[CHANGAN_AT_MAX_ARGC][CHANGAN_AT_MAX_ARGV_LEN];
+ uint32_t argc = 0;
+ if (changan_parse_params(para, para_len, argv, &argc) != 0 || argc < 2) {
+ printf("[CHANGAN][AT] invalid params, need url,body\r\n");
+ return ERRCODE_FAIL;
+ }
+ char *url = (char *)argv[0];
+ char *body = (char *)argv[1];
+ int ret = changan_http_post(body, url, changan_at_http_noop_cb, NULL);
+
+ return changan_at_http_submit_ok(ret, "HTTP_POST");
+}
+
+/* AT^CHANGAN_HTTP_PUT=<url>,<body> */
+static uint32_t changan_http_put_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(str_cmd);
+ if (para == NULL || para_len == 0) {
+ printf("[CHANGAN][AT] Usage: AT^CHANGAN_HTTP_PUT=<url>,<body>\r\n");
+ return ERRCODE_FAIL;
+ }
+ uint8_t argv[CHANGAN_AT_MAX_ARGC][CHANGAN_AT_MAX_ARGV_LEN];
+ uint32_t argc = 0;
+ if (changan_parse_params(para, para_len, argv, &argc) != 0 || argc < 2) {
+ printf("[CHANGAN][AT] invalid params, need url,body\r\n");
+ return ERRCODE_FAIL;
+ }
+ char *url = (char *)argv[0];
+ char *body = (char *)argv[1];
+ int ret = changan_http_put(body, url, changan_at_http_noop_cb, NULL);
+
+ return changan_at_http_submit_ok(ret, "HTTP_PUT");
+}
+
+/* 上次 QR_GEN 解析到的 qrcode_id,供 AT^CHANGAN_HTTP_QR_ST 使用(堆分配,首次 AT 使用时 lazy init) */
+static char *g_changan_at_last_qrcode_id = NULL;
+
+/* dkey AT:内存缓存 PEM/SPKI、最近一次 download 响应与 publicKeyId;HTTP 默认从落盘文件加载密钥材料 */
+static char *g_changan_at_dkey_private_pem = NULL;
+static char *g_changan_at_dkey_last_spki_b64 = NULL;
+static char *g_changan_at_dkey_last_download_rsp = NULL;
+static char *g_changan_at_dkey_last_public_key_id = NULL;
+
+static void changan_at_heap_bufs_free(void)
+{
+ free(g_changan_at_last_qrcode_id);
+ g_changan_at_last_qrcode_id = NULL;
+ free(g_changan_at_dkey_private_pem);
+ g_changan_at_dkey_private_pem = NULL;
+ free(g_changan_at_dkey_last_spki_b64);
+ g_changan_at_dkey_last_spki_b64 = NULL;
+ free(g_changan_at_dkey_last_download_rsp);
+ g_changan_at_dkey_last_download_rsp = NULL;
+ free(g_changan_at_dkey_last_public_key_id);
+ g_changan_at_dkey_last_public_key_id = NULL;
+}
+
+static bool changan_at_heap_bufs_ensure(void)
+{
+ if (g_changan_at_last_qrcode_id != NULL) {
+ return true;
+ }
+ g_changan_at_last_qrcode_id = (char *)calloc(1, (size_t)CHANGAN_AT_QR_ID_CAP);
+ g_changan_at_dkey_private_pem = (char *)calloc(1, (size_t)CHANGAN_AT_DKEY_PEM_CAP);
+ g_changan_at_dkey_last_spki_b64 = (char *)calloc(1, (size_t)CHANGAN_AT_DKEY_SPKI_CAP);
+ g_changan_at_dkey_last_download_rsp = (char *)calloc(1, (size_t)CHANGAN_AT_DKEY_RSP_CAP);
+ g_changan_at_dkey_last_public_key_id = (char *)calloc(1, (size_t)CHANGAN_AT_DKEY_PUBLIC_KEY_ID_CAP);
+ if (g_changan_at_last_qrcode_id == NULL || g_changan_at_dkey_private_pem == NULL ||
+ g_changan_at_dkey_last_spki_b64 == NULL || g_changan_at_dkey_last_download_rsp == NULL ||
+ g_changan_at_dkey_last_public_key_id == NULL) {
+ printf("[CHANGAN][AT] heap bufs calloc fail\r\n");
+ changan_at_heap_bufs_free();
+ return false;
+ }
+ return true;
+}
+
+/** 供 QR_ST:从结果写入 g_changan_at_last_qrcode_id */
+static void changan_at_qr_gen_cache_qrcode_id_cb(void *ud, const changan_http_result_t *r)
+{
+ (void)ud;
+ if (!changan_at_heap_bufs_ensure() || r == NULL) {
+ return;
+ }
+ if (r->qrcode_id[0] != '\0') {
+ (void)snprintf(g_changan_at_last_qrcode_id, (size_t)CHANGAN_AT_QR_ID_CAP, "%s", r->qrcode_id);
+ } else {
+ g_changan_at_last_qrcode_id[0] = '\0';
+ }
+}
+
+static bool changan_at_copy_param(uint8_t *para, uint32_t para_len, char *out, uint32_t cap)
+{
+ if (out == NULL || cap == 0U) {
+ return false;
+ }
+ if (para == NULL || para_len == 0U) {
+ out[0] = '\0';
+ return true;
+ }
+ if (para_len >= cap) {
+ return false;
+ }
+ if (memcpy_s(out, cap, para, para_len) != 0) {
+ return false;
+ }
+ out[para_len] = '\0';
+ return true;
+}
+
+static void changan_at_print_hex(const char *tag, const uint8_t *buf, uint32_t len)
+{
+ if (tag == NULL || buf == NULL || len == 0U) {
+ printf("[CHANGAN][AT] %s (empty)\r\n", (tag != NULL) ? tag : "hex");
+ return;
+ }
+ printf("[CHANGAN][AT] %s len=%u hex=", tag, (unsigned)len);
+ for (uint32_t i = 0; i < len; i++) {
+ printf("%02X", buf[i]);
+ }
+ printf("\r\n");
+}
+
+static void changan_at_print_long_ascii(const char *tag, const char *s)
+{
+ const size_t chunk = 128u;
+ size_t pos = 0;
+ size_t total;
+
+ if (tag == NULL || s == NULL) {
+ return;
+ }
+ total = strlen(s);
+ printf("[CHANGAN][AT] %s len=%u\r\n", tag, (unsigned)total);
+ while (pos < total) {
+ char line[129];
+ size_t n = total - pos;
+
+ if (n > chunk) {
+ n = chunk;
+ }
+ if (memcpy_s(line, sizeof(line), s + pos, n) != 0) {
+ return;
+ }
+ line[n] = '\0';
+ printf("[CHANGAN][AT] %s\r\n", line);
+ pos += n;
+ }
+}
+
+/*
+ * AT^CHANGAN_HTTP_QR_GEN — 无参数;openC 拉业务二维码(v1 表单签名),参数与 py/qrcode_generate_v1_test.py 默认一致。
+ */
+static uint32_t changan_http_qr_gen_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+
+ if (!changan_at_heap_bufs_ensure()) {
+ return ERRCODE_FAIL;
+ }
+
+ changan_qrcode_generate_v1_params_t p = {
+ .client_id = CHANGAN_HTTP_QRCODE_DEFAULT_CLIENT_ID,
+ .nonce = "WYYL",
+ .size = "L",
+ .state = "OPPOWATCH",
+ .timestamp_ms = NULL,
+ .app_key = CHANGAN_HTTP_QRCODE_DEFAULT_APP_KEY,
+ .app_code = CHANGAN_HTTP_QRCODE_DEFAULT_APP_CODE,
+ .exclude_app_code_from_sign = true,
+ };
+
+ int ret = changan_http_qrcode_generate_v1(&p, changan_at_qr_gen_cache_qrcode_id_cb, NULL);
+
+ return changan_at_http_submit_ok(ret, "QR_GEN");
+}
+
+/*
+ * AT^CHANGAN_HTTP_QR_ST — 无参数;getQrcodeStatusNoBackend 单次查询(须先执行 QR_GEN 以保存 qrcode_id)。
+ */
+static uint32_t changan_http_qr_st_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+
+ if (!changan_at_heap_bufs_ensure()) {
+ return ERRCODE_FAIL;
+ }
+
+ if (g_changan_at_last_qrcode_id[0] == '\0') {
+ printf("[CHANGAN][AT] QR_ST: no qrcode_id, run AT^CHANGAN_HTTP_QR_GEN first\r\n");
+ return ERRCODE_FAIL;
+ }
+
+ changan_qrcode_status_no_backend_v1_params_t p = {
+ .nonce = "WYYL",
+ .timestamp_sec = NULL,
+ .qrcode_id = g_changan_at_last_qrcode_id,
+ .app_key = CHANGAN_HTTP_QRCODE_DEFAULT_APP_KEY,
+ .no_app_key = false,
+ };
+
+ int ret = changan_http_qrcode_status_no_backend_v1(&p, changan_at_http_noop_cb, NULL);
+
+ return changan_at_http_submit_ok(ret, "QR_ST");
+}
+
+/*
+ * AT^CHANGAN_HTTP_OAUTH — 无参数;POST /oauth/token,client_credentials,
+ * 默认 client 与 openc_oauth_token_test.py / CHANGAN_HTTP_OPENC_DEFAULT_* 一致;成功时在 HTTP 层缓存 access_token、secret_key(见 [changan_http][default])。
+ */
+static uint32_t changan_http_oauth_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+
+ changan_oauth_token_params_t p = {
+ .client_id = CHANGAN_HTTP_CLIENT_ID,
+ .client_secret = CHANGAN_HTTP_CLIENT_SECRET,
+ .grant_type = CHANGAN_OAUTH_GRANT_CLIENT_CREDENTIALS,
+ .code = NULL,
+ .redirect_uri = NULL,
+ .refresh_token = NULL,
+ };
+
+ int ret = changan_http_oauth_token_request(&p, changan_at_http_noop_cb, NULL);
+
+ return changan_at_http_submit_ok(ret, "OAUTH");
+}
+
+/*
+ * AT^CHANGAN_HTTP_OAUTH_SET=<access_token>|<secret_key>[|persist]
+ * 分隔符为 '|'(避免 secret 中含逗号);persist 省略或 0=仅内存,1=同时落盘(与 OAUTH 成功解析后路径一致)。
+ * 例:AT^CHANGAN_HTTP_OAUTH_SET=8afd...|KRLC0AYQ...|1
+ */
+// --access-token 8afdacfa-3fe4-4f3f-8442-b123545c93b9 --secret-key KRLC0AYQ94j263nkYD5EJg==
+static uint32_t changan_http_oauth_set_cache_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ uint32_t p0 = 0U;
+ uint32_t p1 = para_len;
+ uint32_t i;
+ bool persist = false;
+ int set_ret;
+
+
+
+ set_ret = changan_http_oauth_set_cached_credentials("8afdacfa-3fe4-4f3f-8442-b123545c93b9", "KRLC0AYQ94j263nkYD5EJg==", 1);
+ if (set_ret != 0) {
+ printf("[CHANGAN][AT] OAUTH_SET failed ret=%d\r\n", set_ret);
+ return ERRCODE_FAIL;
+ }
+
+ printf("[CHANGAN][AT] OAUTH_SET ok persist=%d\r\n", persist ? 1 : 0);
+ return ERRCODE_SUCC;
+}
+
+/*
+ * AT^CHANGAN_HTTP_CTRL_CAR — 可选 brandCode;GET getCarListByBrandCode 控车签名,access_token/secret 用缓存(须先 AT^CHANGAN_HTTP_OAUTH 成功)。
+ * 例:AT^CHANGAN_HTTP_CTRL_CAR 或 AT^CHANGAN_HTTP_CTRL_CAR=CHANGAN
+ */
+
+// PS D:\log\usr> python .\openc_car_getCarListByBrandCode_control_car_test.py --access-token 8afdacfa-3fe4-4f3f-8442-b123545c93b9 --secret-key KRLC0AYQ94j263nkYD5EJg== --sign-debug
+
+// PS D:\log\usr> python .\openc_car_getCarListByBrandCode_control_car_test.py --access-token 8afdacfa-3fe4-4f3f-8442-b123545c93b9 --secret-key KRLC0AYQ94j263nkYD5EJg==
+static uint32_t changan_http_ctrl_car_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(str_cmd);
+ // uint8_t argv[CHANGAN_AT_MAX_ARGC][CHANGAN_AT_MAX_ARGV_LEN];
+ // uint32_t argc = 0;
+ // const char *brand = NULL;
+
+ // if (para != NULL && para_len > 0) {
+ // if (changan_parse_params(para, para_len, argv, &argc) == 0 && argc >= 1) {
+ // brand = (const char *)argv[0];
+ // }
+ // }
+
+ changan_get_car_list_by_brand_params_t p = {
+ .access_token = NULL,
+ .secret_key = NULL,
+ .brand_code = "CHANGAN",
+ .timestamp_sec = NULL,
+ .nonce = NULL,
+ .api_path = NULL,
+ .oauth_bootstrap = NULL,
+ };
+
+ int ret = changan_http_get_car_list_by_brand_code_control_car(&p, changan_at_http_noop_cb, NULL);
+
+ return changan_at_http_submit_ok(ret, "CTRL_CAR");
+}
+
+/*
+ * AT^CHANGAN_HTTP_UNLOCK_DOOR — 兼容入口:内部走 vrtm unLockDoor(与 AT^CHANGAN_HTTP_VRTM_CTRL=7,<carId> 等价)。
+ */
+static uint32_t changan_http_unlock_door_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(str_cmd);
+ // uint8_t argv[CHANGAN_AT_MAX_ARGC][CHANGAN_AT_MAX_ARGV_LEN];
+ // uint32_t argc = 0;
+
+ // if (para == NULL || para_len == 0U) {
+ // printf("[CHANGAN][AT] Usage: AT^CHANGAN_HTTP_UNLOCK_DOOR=<carId>[,mapArgsJson][,senderType]\r\n");
+ // return ERRCODE_FAIL;
+ // }
+ // if (changan_parse_params(para, para_len, argv, &argc) != 0 || argc < 1 || argv[0][0] == '\0') {
+ // printf("[CHANGAN][AT] UNLOCK_DOOR: need carId\r\n");
+ // return ERRCODE_FAIL;
+ // }
+
+ changan_vrtm_car_control_v2_params_t p = {
+ .access_token = NULL,
+ .secret_key = NULL,
+ .oauth_bootstrap = NULL,
+ .car_id = "8873c446e8a4f52d287d63f75fc79e14",
+ .map_args_json = "{}",
+ .sender_type = "APP",
+ .timestamp_ms = true,
+ .timestamp = NULL,
+ .nonce = NULL,
+ .api_path = NULL,
+ .command = CHANGAN_VRTM_CAR_CTRL_UNLOCK_DOOR,
+ .body_cmd_override = NULL,
+ };
+
+ int ret = changan_http_post_vrtm_car_control_v2(&p, changan_at_http_noop_cb, NULL);
+
+ return changan_at_http_submit_ok(ret, "UNLOCK_DOOR");
+}
+
+/*
+ * AT^CHANGAN_HTTP_VRTM_CTRL=<cmd>,<carId>[,mapArgsJson][,senderType]
+ * vrtm 控车综合 POST(对齐 http/py/openc_car_control_v2_test.py --command)。
+ * cmd:十进制数字 1–9 选择指令(不用英文指令名):
+ * 1关空调 2关车窗 3闪灯 4锁门 5开空调 6寻车 7解锁 8车窗留缝 9上报车况
+ * mapArgsJson 勿含未转义双引号;含逗号时请用其它方式发包(本 AT 按逗号分参)。
+ * token/secret 用 OAUTH 缓存(与 VRTM_CTRL 一致)。
+ */
+static bool changan_at_vrtm_cmd_from_digit_menu(const char *s, changan_vrtm_car_control_command_e *out_cmd)
+{
+ char *end = NULL;
+ unsigned long v;
+
+ if (s == NULL || out_cmd == NULL) {
+ return false;
+ }
+ v = strtoul(s, &end, 10);
+ if (end == s || *end != '\0') {
+ return false;
+ }
+ if (v < 1UL || v > (unsigned long)CHANGAN_VRTM_CAR_CTRL_COUNT) {
+ return false;
+ }
+ *out_cmd = (changan_vrtm_car_control_command_e)(v - 1UL);
+ return true;
+}
+
+static uint32_t changan_http_vrtm_ctrl_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ uint8_t argv[CHANGAN_AT_MAX_ARGC][CHANGAN_AT_MAX_ARGV_LEN];
+ uint32_t argc = 0;
+ changan_vrtm_car_control_command_e cmd = CHANGAN_VRTM_CAR_CTRL_COUNT;
+ const char *mapj = "{}";
+ const char *snd = "APP";
+
+ CHANGAN_UNUSED(str_cmd);
+ if (para == NULL || para_len == 0U) {
+ printf("[CHANGAN][AT] Usage: AT^CHANGAN_HTTP_VRTM_CTRL=<cmd>,<carId>[,mapArgsJson][,senderType]\r\n");
+ printf("[CHANGAN][AT] cmd 1-9: 1关空调 2关车窗 3闪灯 4锁门 5开空调 6寻车 7解锁 8车窗留缝 9上报车况\r\n");
+ return ERRCODE_FAIL;
+ }
+ if (changan_parse_params(para, para_len, argv, &argc) != 0 || argc < 2) {
+ printf("[CHANGAN][AT] VRTM_CTRL: need cmd,carId\r\n");
+ return ERRCODE_FAIL;
+ }
+ if (!changan_at_vrtm_cmd_from_digit_menu((const char *)argv[0], &cmd)) {
+ printf("[CHANGAN][AT] VRTM_CTRL: bad cmd \"%s\" (need 1-%u)\r\n", (const char *)argv[0],
+ (unsigned)CHANGAN_VRTM_CAR_CTRL_COUNT);
+ return ERRCODE_FAIL;
+ }
+ if (argv[1][0] == '\0') {
+ printf("[CHANGAN][AT] VRTM_CTRL: carId empty\r\n");
+ return ERRCODE_FAIL;
+ }
+ if (argc >= 3U && argv[2][0] != '\0') {
+ mapj = (const char *)argv[2];
+ }
+ if (argc >= 4U && argv[3][0] != '\0') {
+ snd = (const char *)argv[3];
+ }
+
+ {
+ changan_vrtm_car_control_v2_params_t p = {
+ .access_token = NULL,
+ .secret_key = NULL,
+ .oauth_bootstrap = NULL,
+ .car_id = (const char *)argv[1],
+ .map_args_json = mapj,
+ .sender_type = snd,
+ .timestamp_ms = true,
+ .timestamp = NULL,
+ .nonce = NULL,
+ .api_path = NULL,
+ .command = cmd,
+ .body_cmd_override = NULL,
+ };
+ int ret = changan_http_post_vrtm_car_control_v2(&p, changan_at_http_noop_cb, NULL);
+
+ return changan_at_http_submit_ok(ret, "VRTM_CTRL");
+ }
+}
+
+/*
+ * AT^CHANGAN_HTTP_DKEY_SET_PEM=<PEM 全文> — 写入内存缓存并同步落盘,供 DKEY_DL / DKEY_DEC
+ * 与 HTTP 层默认从文件加载的路径一致。
+ * 参数为 AT 行内 PEM 文本(可含 -----BEGIN/END-----);勿含逗号分隔的其它字段。
+ */
+static uint32_t changan_http_dkey_set_pem_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(str_cmd);
+ if (!changan_at_heap_bufs_ensure()) {
+ return ERRCODE_FAIL;
+ }
+ if (para == NULL || para_len == 0U) {
+ printf("[CHANGAN][AT] Usage: AT^CHANGAN_HTTP_DKEY_SET_PEM=<PEM text>\r\n");
+ return ERRCODE_FAIL;
+ }
+ if (!changan_at_copy_param(para, para_len, g_changan_at_dkey_private_pem,
+ (uint32_t)CHANGAN_AT_DKEY_PEM_CAP)) {
+ printf("[CHANGAN][AT] DKEY_SET_PEM: PEM too long (max %u)\r\n",
+ (unsigned)CHANGAN_AT_DKEY_PEM_CAP);
+ return ERRCODE_FAIL;
+ }
+ (void)changan_http_dkey_store_private_pem_file(g_changan_at_dkey_private_pem);
+ printf("[CHANGAN][AT] DKEY_SET_PEM ok len=%u\r\n", (unsigned)strlen(g_changan_at_dkey_private_pem));
+ return ERRCODE_SUCC;
+}
+
+/*
+ * AT^CHANGAN_HTTP_DKEY_GEN — 无参数;本地 RSA-2048,落盘 PEM/SPKI 文件(HTTP 默认加载),并写入缓存打印 SPKI。
+ */
+static uint32_t changan_http_dkey_gen_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+ char spki[CHANGAN_AT_DKEY_SPKI_CAP];
+
+ if (!changan_at_heap_bufs_ensure()) {
+ return ERRCODE_FAIL;
+ }
+
+ if (changan_http_dkey_generate_rsa2048_keypair(g_changan_at_dkey_private_pem,
+ (uint32_t)CHANGAN_AT_DKEY_PEM_CAP, spki, (uint32_t)sizeof(spki)) != 0) {
+ printf("[CHANGAN][AT] DKEY_GEN failed\r\n");
+ g_changan_at_dkey_private_pem[0] = '\0';
+ g_changan_at_dkey_last_spki_b64[0] = '\0';
+ return ERRCODE_FAIL;
+ }
+ if (memcpy_s(g_changan_at_dkey_last_spki_b64, (uint32_t)CHANGAN_AT_DKEY_SPKI_CAP, spki,
+ strlen(spki) + 1U) != 0) {
+ printf("[CHANGAN][AT] DKEY_GEN spki cache overflow\r\n");
+ return ERRCODE_FAIL;
+ }
+ printf("[CHANGAN][AT] DKEY_GEN ok pem_len=%u\r\n", (unsigned)strlen(g_changan_at_dkey_private_pem));
+ changan_at_print_long_ascii("DKEY_GEN publicKeySpkiB64", g_changan_at_dkey_last_spki_b64);
+ return ERRCODE_SUCC;
+}
+
+/** 供 DKEY_DL / DKEY_ENSURE:缓存 download-owner-key JSON 响应,便于 AT^CHANGAN_HTTP_DKEY_DEC */
+static void changan_at_dkey_copy_download_json_cb(void *ud, const changan_http_result_t *r)
+{
+ (void)ud;
+ if (!changan_at_heap_bufs_ensure() || r == NULL) {
+ return;
+ }
+ if (r->body != NULL && r->body_len > 0U && !r->body_is_binary) {
+ uint32_t n = r->body_len;
+
+ if (n >= CHANGAN_AT_DKEY_RSP_CAP) {
+ n = CHANGAN_AT_DKEY_RSP_CAP - 1U;
+ }
+ (void)memcpy_s(g_changan_at_dkey_last_download_rsp, (size_t)CHANGAN_AT_DKEY_RSP_CAP, r->body, (size_t)n);
+ g_changan_at_dkey_last_download_rsp[n] = '\0';
+ }
+}
+
+#if 0 /* 隐藏 AT:钥匙注册 / 下载;凭据由 OAUTH 缓存提供(先 REG 再 DL,DL 的 publicKeyId 来自 REG 回调) */
+static void changan_at_dkey_cache_public_key_id_cb(void *ud, const changan_http_result_t *r)
+{
+ (void)ud;
+ if (!changan_at_heap_bufs_ensure() || r == NULL) {
+ return;
+ }
+ if (r->public_key_id[0] != '\0') {
+ (void)snprintf(g_changan_at_dkey_last_public_key_id, (size_t)CHANGAN_AT_DKEY_PUBLIC_KEY_ID_CAP, "%s",
+ r->public_key_id);
+ }
+}
+
+/*
+ * AT^CHANGAN_HTTP_DKEY_REG — public-key-register;OAuth 缓存须有效。
+ * publicKeySpki 默认从落盘文件加载(与 DKEY_GEN 一致);不传指针即 NULL。
+ */
+
+// PS D:\log\usr> python openc_dkey_register_and_download_owner_key_control_car_test.py --access-token 8afdacfa-3fe4-4f3f-8442-b123545c93b9 --secret-key KRLC0AYQ94j263nkYD5EJg== --user-id 91d5c96d-7f6d-4077-954b-fc0fcef0b730 --car-id 8873c446e8a4f52d287d63f75fc79e14 --debug
+static uint32_t changan_http_dkey_reg_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+
+ if (!changan_at_heap_bufs_ensure()) {
+ return ERRCODE_FAIL;
+ }
+
+ changan_dkey_public_key_register_params_t p = {
+ .access_token = NULL,
+ .secret_key = NULL,
+ .oauth_bootstrap = NULL,
+ .timestamp_ms = true,
+ .timestamp = NULL,
+ .header_nonce = NULL,
+ .api_path = NULL,
+ .user_id = "91d5c96d-7f6d-4077-954b-fc0fcef0b730",
+ .app_id = "cn.com.changan_1234.cvim",
+ .algorithm = "RSA",
+ .public_key_spki_b64 = NULL,
+ };
+
+ int ret = changan_http_dkey_public_key_register(&p, changan_at_dkey_cache_public_key_id_cb, NULL);
+
+ return changan_at_http_submit_ok(ret, "DKEY_REG");
+}
+
+/*
+ * AT^CHANGAN_HTTP_DKEY_DL — download-owner-key;私钥 PEM 默认从落盘文件加载(与 DKEY_GEN 一致)。
+ * publicKeyId 使用最近一次 DKEY_REG 回调缓存。
+ */
+static uint32_t changan_http_dkey_dl_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+ const char *pk_id = g_changan_at_dkey_last_public_key_id;
+
+ if (!changan_at_heap_bufs_ensure()) {
+ return ERRCODE_FAIL;
+ }
+
+ changan_dkey_download_owner_key_params_t p = {
+ .access_token = NULL,
+ .secret_key = NULL,
+ .oauth_bootstrap = NULL,
+ .timestamp_ms = true,
+ .timestamp = NULL,
+ .header_nonce = NULL,
+ .api_path = NULL,
+ .user_id = "91d5c96d-7f6d-4077-954b-fc0fcef0b730",
+ .car_id = "8873c446e8a4f52d287d63f75fc79e14",
+ .public_key_id = pk_id,
+ .body_nonce = NULL,
+ .protocol_type = 1,
+ .private_sign_exclude_protocol_type = false,
+ .protocol_type_json_number = false,
+ .rsa_private_key_pem = NULL,
+ };
+
+ g_changan_at_dkey_last_download_rsp[0] = '\0';
+
+ int ret = changan_http_dkey_download_owner_key(&p, changan_at_dkey_copy_download_json_cb, NULL);
+
+ return changan_at_http_submit_ok(ret, "DKEY_DL");
+}
+#endif
+
+/*
+ * AT^CHANGAN_HTTP_DKEY_ENSURE=<vehicle_car_id>[,user_id]
+ * 一体流程:changan_http_dkey_ensure_owner_key_for_vehicle(OAuth 须已由 AT^CHANGAN_HTTP_OAUTH 写入缓存;
+ * user_id 可省略则用 token 响应中的 uid)。成功入队或同步 200 后看串口 [changan_http][default];下载 JSON 写入缓存供 DKEY_DEC。
+ */
+static uint32_t changan_http_dkey_ensure_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ // uint8_t argv[CHANGAN_AT_MAX_ARGC][CHANGAN_AT_MAX_ARGV_LEN];
+ uint32_t argc = 0;
+ CHANGAN_UNUSED(str_cmd);
+
+
+ // g_changan_at_dkey_last_download_rsp[0] = '\0';
+ changan_http_dkey_ensure_owner_key_params_t ep = {
+ .vehicle_car_id = "8873c446e8a4f52d287d63f75fc79e14",
+ .user_id = "91d5c96d-7f6d-4077-954b-fc0fcef0b730",
+ };
+ printf("[CHANGAN][AT] DKEY_ENSURE car_id=%s user_id=%s\r\n", ep.vehicle_car_id, ep.user_id);
+ int ret = changan_http_dkey_ensure_owner_key_for_vehicle(&ep, changan_at_dkey_copy_download_json_cb, NULL);
+
+ if (ret == 0) {
+ printf("[CHANGAN][AT] DKEY_ENSURE ok (enqueued or sync success); rsp cache for DKEY_DEC on download cb\r\n");
+ return ERRCODE_SUCC;
+ }
+ if (ret == CHANGAN_HTTP_DKEY_ENSURE_ERR_MISSING_OAUTH) {
+ printf("[CHANGAN][AT] DKEY_ENSURE fail: missing oauth access_token/secret (run AT^CHANGAN_HTTP_OAUTH first)\r\n");
+ return ERRCODE_FAIL;
+ }
+ printf("[CHANGAN][AT] DKEY_ENSURE fail ret=%d (e.g. -1 param/uid, -103 busy, -104 gen, http code if sync)\r\n",
+ ret);
+ return ERRCODE_FAIL;
+}
+
+/*
+ * AT^CHANGAN_HTTP_DKEY_DEC — 无参数;解密 g_changan_at_dkey_last_download_rsp 中下载 JSON;私钥 PEM 默认从落盘文件加载。
+ */
+static uint32_t changan_http_dkey_dec_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+ char card_info[CHANGAN_AT_DKEY_CARD_INFO_CAP];
+ uint8_t dkey[64];
+ uint32_t card_info_len = 0;
+ uint32_t dkey_len = 0;
+
+ if (!changan_at_heap_bufs_ensure()) {
+ return ERRCODE_FAIL;
+ }
+
+ if (g_changan_at_dkey_last_download_rsp[0] == '\0') {
+ printf("[CHANGAN][AT] DKEY_DEC: no download rsp in buffer\r\n");
+ return ERRCODE_FAIL;
+ }
+
+ card_info[0] = '\0';
+ if (changan_http_dkey_decrypt_download_owner_key_response(g_changan_at_dkey_last_download_rsp,
+ NULL, card_info, (uint32_t)sizeof(card_info), &card_info_len,
+ dkey, (uint32_t)sizeof(dkey), &dkey_len, NULL) != 0) {
+ printf("[CHANGAN][AT] DKEY_DEC failed\r\n");
+ return ERRCODE_FAIL;
+ }
+
+ printf("[CHANGAN][AT] DKEY_DEC ok card_info_len=%u\r\n", (unsigned)card_info_len);
+ if (card_info_len > 0U) {
+ printf("[CHANGAN][AT] DKEY_DEC card_info: %.2048s%s\r\n",
+ card_info, card_info_len > 2048u ? "..." : "");
+ }
+ changan_at_print_hex("DKEY_DEC dkey", dkey, dkey_len);
+ return ERRCODE_SUCC;
+}
+
+/*
+ * AT^CHANGAN_ICCE_NOTIFY_RAW — 无参数;固定注入首段联调数据(BLE_CARKEY Frame RX 65B),client_id=0 conn_id=0。
+ * 来源示例:5A003C1000...52E3;改测试请替换 k_icce_notify_test_raw[]。
+ */
+static uint32_t changan_icce_notify_raw_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+ static const uint8_t k_icce_notify_test_raw[] = {
+ 0x5a, 0x00, 0x3c, 0x10, 0x00, 0x01, 0x01, 0x01, 0x36, 0x80, 0xca, 0x00, 0x00, 0x31, 0x9f, 0x1e,
+ 0x10, 0x60, 0x00, 0x10, 0x01, 0x25, 0x05, 0x28, 0x33, 0x00, 0x00, 0x00, 0x69, 0x25, 0x95, 0x14,
+ 0x06, 0x9f, 0x37, 0x08, 0x9b, 0x86, 0x66, 0x66, 0x34, 0xef, 0x3c, 0xe8, 0x9f, 0x0c, 0x10, 0x60,
+ 0x00, 0x10, 0x01, 0x25, 0x05, 0x28, 0x33, 0x00, 0x00, 0x00, 0x69, 0x25, 0x95, 0x14, 0x06, 0x52,
+ 0xe3,
+ };
+
+ static const uint8_t k_icce_notify_test_raw2[] = {
+ 0x5a, 0x00, 0x3c, 0x10, 0x00, 0x01, 0x01, 0x01, 0x36, 0x80, 0xca, 0x00, 0x00, 0x31, 0x9f, 0x1e,
+ 0x10, 0x60, 0x00, 0x10, 0x01, 0x25, 0x05, 0x28, 0x33, 0x00, 0x00, 0x00, 0x69, 0x25, 0x95, 0x14,
+ 0x06, 0x9f, 0x37, 0x08, 0xa8, 0xf4, 0x30, 0xcb, 0x6b, 0xee, 0x15, 0x18, 0x9f, 0x0c, 0x10, 0x60,
+ 0x00, 0x10, 0x01, 0x25, 0x05, 0x28, 0x33, 0x00, 0x00, 0x00, 0x69, 0x25, 0x95, 0x14, 0x06, 0x01,
+ 0xcc,
+ };
+ ble_icce_notify_frame_process(0, 0, k_icce_notify_test_raw2, (uint16_t)sizeof(k_icce_notify_test_raw2));
+
+ // 5A002D10000101012780800000227720FB314C62845D1F6AAD3B8405DAB5D9445BB45979B6AD0B1F6D43210DBC2C8BE067D0
+ static const uint8_t k_icce_notify_test_raw3[] = {
+ 0x5a, 0x00, 0x2d, 0x10, 0x00, 0x01, 0x01, 0x01, 0x27, 0x80, 0x80, 0x00, 0x00, 0x22, 0x77, 0x20,
+ 0xfb, 0x31, 0x4c, 0x62, 0x84, 0x5d, 0x1f, 0x6a, 0xad, 0x3b, 0x84, 0x05, 0xda, 0xb5, 0xd9, 0x44,
+ 0x5b, 0xb4, 0x59, 0x79, 0xb6, 0xad, 0x0b, 0x1f, 0x6d, 0x43, 0x21, 0x0d, 0xbc, 0x2c, 0x8b, 0xe0,
+ 0x67, 0xd0,
+ };
+ ble_icce_notify_frame_process(0, 0, k_icce_notify_test_raw3, (uint16_t)sizeof(k_icce_notify_test_raw3));
+ printf("[CHANGAN][AT] ICCE_NOTIFY_RAW fixed 65B (BLE_CARKEY RX#1) client=0 conn=0\r\n");
+ return ERRCODE_SUCC;
+}
+
+/* AT^CHANGAN_ICCE_CONNECT=<mac> — 测试 ble_icce_connect_to_device:直接 gap 连接指定地址(不扫描) */
+static uint32_t changan_icce_connect_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(str_cmd);
+ if (para == NULL || para_len == 0) {
+ printf("[CHANGAN][AT] Usage: AT^CHANGAN_ICCE_CONNECT=<AA:BB:CC:DD:EE:FF>\r\n");
+ return ERRCODE_FAIL;
+ }
+ uint8_t argv[CHANGAN_AT_MAX_ARGC][CHANGAN_AT_MAX_ARGV_LEN];
+ uint32_t argc = 0;
+ if (changan_parse_params(para, para_len, argv, &argc) != 0 || argc < 1) {
+ printf("[CHANGAN][AT] invalid params\r\n");
+ return ERRCODE_FAIL;
+ }
+ bd_addr_t addr = { 0 };
+ if (changan_parse_bt_address((char *)argv[0], &addr) != 0) {
+ printf("[CHANGAN][AT] invalid MAC, use AA:BB:CC:DD:EE:FF or AABBCCDDEEFF\r\n");
+ return ERRCODE_FAIL;
+ }
+ printf("[CHANGAN][AT] ICCE_CONNECT addr=%02X:%02X:%02X:%02X:%02X:%02X\r\n",
+ addr.addr[0], addr.addr[1], addr.addr[2], addr.addr[3], addr.addr[4], addr.addr[5]);
+ bool ok = ble_icce_connect_to_device(&addr);
+ // if (!ok) {
+ bd_addr_t addr_rev = addr;
+ for (int i = 0; i < 3; i++) {
+ uint8_t t = addr_rev.addr[i];
+ addr_rev.addr[i] = addr_rev.addr[5 - i];
+ addr_rev.addr[5 - i] = t;
+ }
+ printf("[CHANGAN][AT] ICCE_CONNECT retry reversed=%02X:%02X:%02X:%02X:%02X:%02X\r\n",
+ addr_rev.addr[0], addr_rev.addr[1], addr_rev.addr[2],
+ addr_rev.addr[3], addr_rev.addr[4], addr_rev.addr[5]);
+ ok = ble_icce_connect_to_device(&addr_rev);
+ // }
+ printf("[CHANGAN][AT] ICCE_CONNECT ret=%d\r\n", ok ? 1 : 0);
+ return ok ? ERRCODE_SUCC : ERRCODE_FAIL;
+}
+
+/* AT^CHANGAN_ICCE_START_SCAN=<mac> — 测试 ble_icce_start_scan_for_device:先扫描再连接目标设备 */
+static uint32_t changan_icce_start_scan_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(str_cmd);
+ if (para == NULL || para_len == 0) {
+ printf("[CHANGAN][AT] Usage: AT^CHANGAN_ICCE_START_SCAN=<AA:BB:CC:DD:EE:FF>\r\n");
+ return ERRCODE_FAIL;
+ }
+ uint8_t argv[CHANGAN_AT_MAX_ARGC][CHANGAN_AT_MAX_ARGV_LEN];
+ uint32_t argc = 0;
+ if (changan_parse_params(para, para_len, argv, &argc) != 0 || argc < 1) {
+ printf("[CHANGAN][AT] invalid params\r\n");
+ return ERRCODE_FAIL;
+ }
+ bd_addr_t addr = { 0 };
+ if (changan_parse_bt_address((char *)argv[0], &addr) != 0) {
+ printf("[CHANGAN][AT] invalid MAC, use AA:BB:CC:DD:EE:FF or AABBCCDDEEFF\r\n");
+ return ERRCODE_FAIL;
+ }
+ bool ok = ble_icce_start_scan_for_device(&addr);
+ printf("[CHANGAN][AT] ICCE_START_SCAN ret=%d\r\n", ok ? 1 : 0);
+ return ok ? ERRCODE_SUCC : ERRCODE_FAIL;
+}
+
+/*
+ * AT^CHANGAN_ICCE_SK_ZHIXING — 无参数;会话密钥派生自测(ZhixingApp initBlueKey 向量)。
+ * 与 ChangAan/icce_session_key_selftest.c 一致;详细十六进制见 [ICCE] 日志。
+ * 注意:平台 AT 解析里命令名最大 32 字节(at_cmd_task.c AT_CMD_NAME_MAX_LEN),勿用更长名字。
+ */
+static uint32_t changan_icce_session_key_zhixing_test_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+ ble_icce_changan_session_key_zhixing_at_test();
+ printf("[CHANGAN][AT] ICCE_SK_ZHIXING done (see [ICCE] logs)\r\n");
+ return ERRCODE_SUCC;
+}
+
+/*
+ * AT^CHANGAN_ICCE_SUB — 无参数;使用全局 g_changan_icce_sub_conn_id / g_changan_icce_sub_client_id
+ *(在 MTU 交换成功时由 bleService 写入,勿在 AT 里传参)。
+ */
+static uint32_t changan_icce_sub_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+
+ if (g_changan_icce_sub_conn_id == 0) {
+ printf("[CHANGAN][AT] ICCE_SUB: globals unset (wait for MTU ok, g_changan_icce_sub_conn_id)\r\n");
+ return ERRCODE_FAIL;
+ }
+
+ uint8_t ret = ble_icce_setup_and_subscribe(g_changan_icce_sub_client_id, g_changan_icce_sub_conn_id);
+ printf("[CHANGAN][AT] ICCE_SUB client_id=%u conn_id=%u ret=%u\r\n",
+ (unsigned)g_changan_icce_sub_client_id, (unsigned)g_changan_icce_sub_conn_id, (unsigned)ret);
+ return (ret == 0) ? ERRCODE_SUCC : ERRCODE_FAIL;
+}
+
+/*
+ * AT^CHANGAN_ICCE_SEND_RAW=<HEX> — 将完整 ICCE 线帧(以 5A 起)经 ble_icce_send_icce_frame_raw 写到 FFFD。
+ * 使用 g_changan_icce_sub_client_id / g_changan_icce_sub_conn_id(与 ICCE_SUB 相同,需先连车且 MTU 已设)。
+ * 十六进制可含空格;最大线帧 320 字节;HEX 最多 640 个有效十六进制字符。
+ */
+static uint32_t changan_icce_send_raw_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(str_cmd);
+ if (para == NULL || para_len == 0) {
+ printf("[CHANGAN][AT] Usage: AT^CHANGAN_ICCE_SEND_RAW=5A0012... (ICCE line frame HEX, max %u B)\r\n",
+ (unsigned)CHANGAN_ICCE_SEND_RAW_MAX_FRAME);
+ return ERRCODE_FAIL;
+ }
+ if (g_changan_icce_sub_conn_id == 0) {
+ printf("[CHANGAN][AT] ICCE_SEND_RAW: unset conn (wait for MTU / g_changan_icce_sub_conn_id)\r\n");
+ return ERRCODE_FAIL;
+ }
+ uint8_t *frame = (uint8_t *)malloc((size_t)CHANGAN_ICCE_SEND_RAW_MAX_FRAME);
+ if (frame == NULL) {
+ printf("[CHANGAN][AT] ICCE_SEND_RAW: malloc fail\r\n");
+ return ERRCODE_FAIL;
+ }
+ uint16_t flen = 0;
+ int perr = changan_at_hex_to_bytes_s((const char *)para, para_len, frame, CHANGAN_ICCE_SEND_RAW_MAX_FRAME, &flen);
+ if (perr != 0 || flen == 0) {
+ free(frame);
+ printf("[CHANGAN][AT] ICCE_SEND_RAW: bad HEX perr=%d flen=%u\r\n", perr, (unsigned)flen);
+ return ERRCODE_FAIL;
+ }
+ if (frame[0] != 0x5A) {
+ printf("[CHANGAN][AT] ICCE_SEND_RAW: warn: SOF=0x%02X (expect 0x5A)\r\n", frame[0]);
+ }
+ uint8_t ret = ble_icce_send_icce_frame_raw(
+ g_changan_icce_sub_client_id, g_changan_icce_sub_conn_id, frame, flen);
+ free(frame);
+ printf("[CHANGAN][AT] ICCE_SEND_RAW client_id=%u conn_id=%u len=%u ret=%u\r\n",
+ (unsigned)g_changan_icce_sub_client_id, (unsigned)g_changan_icce_sub_conn_id, (unsigned)flen, (unsigned)ret);
+ return (ret == 0) ? ERRCODE_SUCC : ERRCODE_FAIL;
+}
+
+/*
+ * RKE 控车 AT(无参数,依赖 g_changan_icce_sub_* 与已派生 SessionKey;固定 body 加密发送)
+ * 1=开行李箱 2=关行李箱 3=解锁四门 4=闭锁四门
+ */
+static uint32_t changan_icce_rke_test_send(uint32_t code_be, const char *label)
+{
+ if (g_changan_icce_sub_conn_id == 0) {
+ printf("[CHANGAN][AT] ICCE_RKE: no link (g_changan_icce_sub_conn_id=0)\r\n");
+ return ERRCODE_FAIL;
+ }
+ uint8_t ret = ble_icce_send_rke03_vehicle_control(code_be);
+ printf("[CHANGAN][AT] ICCE_RKE %s code=0x%08X ret=%u (client=%u conn=%u)\r\n",
+ label, (unsigned)code_be, (unsigned)ret,
+ (unsigned)g_changan_icce_sub_client_id, (unsigned)g_changan_icce_sub_conn_id);
+ return (ret == 0u) ? ERRCODE_SUCC : ERRCODE_FAIL;
+}
+
+static uint32_t changan_icce_rke1_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+ return changan_icce_rke_test_send(ICCE_RKE_CODE_OPEN_TRUNK, "1-open_trunk");
+}
+
+static uint32_t changan_icce_rke2_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+ return changan_icce_rke_test_send(ICCE_RKE_CODE_CLOSE_TRUNK, "2-close_trunk");
+}
+
+static uint32_t changan_icce_rke3_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+ return changan_icce_rke_test_send(ICCE_RKE_CODE_UNLOCK_4DOORS, "3-unlock_4doors");
+}
+
+static uint32_t changan_icce_rke4_at_cmd(uint8_t *para, uint32_t para_len, char *str_cmd)
+{
+ CHANGAN_UNUSED(para);
+ CHANGAN_UNUSED(para_len);
+ CHANGAN_UNUSED(str_cmd);
+ return changan_icce_rke_test_send(ICCE_RKE_CODE_LOCK_4DOORS, "4-lock_4doors");
+}
+
+/* AT^CHANGAN_* 注册表:命令字与 handler 对应关系(联调 / 产测) */
+static at_cmd_table_t g_changan_at_table[] = {
+ { "AT^CHANGAN_TEST", changan_test_at_cmd, NULL }, /* 模块自检 */
+ { "AT^CHANGAN_HTTP_GET", changan_http_get_at_cmd, NULL }, /* HTTP GET(通用) */
+ { "AT^CHANGAN_HTTP_POST", changan_http_post_at_cmd, NULL }, /* HTTP POST(通用) */
+ { "AT^CHANGAN_HTTP_PUT", changan_http_put_at_cmd, NULL }, /* HTTP PUT(通用) */
+ { "AT^CHANGAN_HTTP_QR_GEN", changan_http_qr_gen_at_cmd, NULL }, /* openC 业务二维码 v1 生成 */
+ { "AT^CHANGAN_HTTP_QR_ST", changan_http_qr_st_at_cmd, NULL }, /* 二维码状态(须先 QR_GEN) */
+ { "AT^CHANGAN_HTTP_OAUTH", changan_http_oauth_at_cmd, NULL }, /* OAuth client_credentials,缓存 token/secret */
+ { "AT^CHANGAN_HTTP_OAUTH_SET", changan_http_oauth_set_cache_at_cmd, NULL }, /* 手动写入 access|secret[|1] 缓存/可选落盘 */
+ { "AT^CHANGAN_HTTP_CTRL_CAR", changan_http_ctrl_car_at_cmd, NULL }, /* 控车签名 GET getCarListByBrandCode */
+ { "AT^CHANGAN_HTTP_UNLOCK_DOOR", changan_http_unlock_door_at_cmd, NULL }, /* vrtm POST unLockDoor(ControlCarSign) */
+ { "AT^CHANGAN_HTTP_VRTM_CTRL", changan_http_vrtm_ctrl_at_cmd, NULL }, /* vrtm 控车 v2(openc_car_control_v2_test.py) */
+ { "AT^CHANGAN_HTTP_DKEY_SET_PEM", changan_http_dkey_set_pem_at_cmd, NULL }, /* PEM 入缓存并落盘 */
+ { "AT^CHANGAN_HTTP_DKEY_GEN", changan_http_dkey_gen_at_cmd, NULL }, /* RSA-2048 落盘+缓存 */
+ { "AT^CHANGAN_HTTP_DKEY_ENSURE", changan_http_dkey_ensure_at_cmd, NULL }, /* 按车 ensure:注册链或直拉 download */
+#if 0 /* 与上方 #if 0 成对:隐藏 DKEY_REG / DKEY_DL */
+ { "AT^CHANGAN_HTTP_DKEY_REG", changan_http_dkey_reg_at_cmd, NULL }, /* register,SPKI 默认读文件 */
+ { "AT^CHANGAN_HTTP_DKEY_DL", changan_http_dkey_dl_at_cmd, NULL }, /* download,私钥默认读文件 */
+#endif
+ { "AT^CHANGAN_HTTP_DKEY_DEC", changan_http_dkey_dec_at_cmd, NULL }, /* 解密,私钥默认读文件 */
+ { "AT^CHANGAN_ICCE_CONNECT", changan_icce_connect_at_cmd, NULL }, /* ICCE BLE 按地址连接 */
+ { "AT^CHANGAN_ICCE_NOTIFY_RAW", changan_icce_notify_raw_at_cmd, NULL }, /* 注入联调 NOTIFY 原始帧 */
+ { "AT^CHANGAN_ICCE_START_SCAN", changan_icce_start_scan_at_cmd, NULL }, /* ICCE 扫描 */
+ { "AT^CHANGAN_ICCE_SUB", changan_icce_sub_at_cmd, NULL }, /* ICCE 订阅 / 会话上下文 */
+ { "AT^CHANGAN_ICCE_SEND_RAW", changan_icce_send_raw_at_cmd, NULL }, /* 发送 ICCE 原始帧 */
+ { "AT^CHANGAN_ICCE_SK_ZHIXING", changan_icce_session_key_zhixing_test_at_cmd, NULL }, /* SessionKey 智行联调 */
+ { "AT^CHANGAN_ICCE_RKE1", changan_icce_rke1_at_cmd, NULL }, /* RKE:开行李箱 */
+ { "AT^CHANGAN_ICCE_RKE2", changan_icce_rke2_at_cmd, NULL }, /* RKE:关行李箱 */
+ { "AT^CHANGAN_ICCE_RKE3", changan_icce_rke3_at_cmd, NULL }, /* RKE:解锁四门 */
+ { "AT^CHANGAN_ICCE_RKE4", changan_icce_rke4_at_cmd, NULL }, /* RKE:闭锁四门 */
+};
+
+errcode_t changan_at_init(void)
+{
+ printf("changan_at_init\r\n");
+ return at_cmd_add_moudle(g_changan_at_table,
+ (uint32_t)(sizeof(g_changan_at_table) / sizeof(g_changan_at_table[0])));
+}
+
+at_cmd_table_t* get_changan_at_table(uint32_t *cmd_count)
+{
+ printf("get_changan_at_table\r\n");
+ if (cmd_count) {
+ *cmd_count = sizeof(g_changan_at_table) / sizeof(g_changan_at_table[0]);
+ }
+ return (at_cmd_table_t *)g_changan_at_table;
+}
--- /dev/null
+/**
+ * @file changan_api_at.h
+ * @brief ChangAn 统一 AT 接口声明(根目录统一入口)
+ */
+
+#ifndef CHANGAN_API_AT_H
+#define CHANGAN_API_AT_H
+
+#include "errcode.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** 注册 ChangAn AT 命令,在 service_init 中调用 */
+errcode_t changan_at_init(void);
+
+at_cmd_table_t* get_changan_at_table(uint32_t *cmd_count);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CHANGAN_API_AT_H */
--- /dev/null
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Parse ICCE wire hex and compare TLV fields between two frames (reference vs current).
+
+Tag 0x9F05:规范为车钥匙应用自定义数据 **Card Info1**(VAR/VAR,表中常写作 Card Info)。
+
+逐字节对比使用 ANSI 颜色(绿=一致,红/黄=不一致)。无颜色终端可传 ``--no-color`` 或设置 ``NO_COLOR``;需管道着色时可设 ``FORCE_COLOR=1``。
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+# ANSI(Windows Terminal / 现代 PowerShell / Linux 终端;无 TTY 时默认关,可设 FORCE_COLOR=1)
+_RESET = "\033[0m"
+_DIM = "\033[2m"
+_GREEN = "\033[32m"
+_RED = "\033[91m"
+_YELLOW = "\033[93m"
+def _use_color() -> bool:
+ if "--no-color" in sys.argv:
+ return False
+ if os.environ.get("NO_COLOR", "").strip():
+ return False
+ if os.environ.get("FORCE_COLOR", "").lower() in ("1", "true", "yes"):
+ return True
+ return sys.stdout.isatty()
+
+
+def color_byte_pair(b_ref: int, b_cur: int, use_color: bool) -> tuple[str, str]:
+ """返回 (参考侧两字符, 当前侧两字符),不一致时参考红、当前黄。"""
+ if not use_color:
+ return f"{b_ref:02X}", f"{b_cur:02X}"
+ if b_ref == b_cur:
+ s = f"{_GREEN}{b_ref:02X}{_RESET}"
+ return s, s
+ return f"{_RED}{b_ref:02X}{_RESET}", f"{_YELLOW}{b_cur:02X}{_RESET}"
+
+
+def print_full_frame_byte_diff(ref: bytes, cur: bytes, *, label: str = "全帧", use_color: bool | None = None) -> None:
+ """
+ 逐字节对比两段等长或不等长 buffer;每行 16 字节,两行分别打印参考 / 当前。
+ 图例:一致=绿色;不一致=参考红色、当前黄色。
+ """
+ if use_color is None:
+ use_color = _use_color()
+ n = max(len(ref), len(cur))
+ print(f"\n=== 逐字节对比({label},共 {n} 字节偏移 0..{n - 1})===")
+ print(
+ f"图例: {_GREEN}一致{_RESET} | {_RED}参考≠{_RESET} / {_YELLOW}当前≠{_RESET}"
+ if use_color
+ else "图例: 一致无标记 | 不一致时参考(ref)与当前(cur)数值见下列"
+ )
+ width = 16
+ for row in range(0, n, width):
+ parts_ref: list[str] = []
+ parts_cur: list[str] = []
+ for j in range(width):
+ off = row + j
+ if off >= n:
+ break
+ br = ref[off] if off < len(ref) else None
+ bc = cur[off] if off < len(cur) else None
+ if br is not None and bc is not None:
+ sr, sc = color_byte_pair(br, bc, use_color)
+ parts_ref.append(sr)
+ parts_cur.append(sc)
+ elif br is not None:
+ parts_ref.append(f"{br:02X}" if not use_color else f"{_RED}{br:02X}{_RESET}")
+ parts_cur.append("--" if not use_color else f"{_DIM}--{_RESET}")
+ else:
+ parts_ref.append("--" if not use_color else f"{_DIM}--{_RESET}")
+ parts_cur.append(f"{bc:02X}" if not use_color else f"{_YELLOW}{bc:02X}{_RESET}")
+ pad = f"{row:04X}"
+ print(f"{pad} ref: {' '.join(parts_ref)}")
+ print(f"{pad} cur: {' '.join(parts_cur)}")
+ same_len = len(ref) == len(cur)
+ mismatch = sum(1 for i in range(min(len(ref), len(cur))) if ref[i] != cur[i])
+ extra = abs(len(ref) - len(cur))
+ print(
+ f"统计: 相同长度={same_len}, 相异字节数={mismatch}"
+ + (f", 长度差={extra} B" if extra else "")
+ )
+
+
+def print_payload_byte_diff(
+ rp: bytes, cp: bytes, *, r_off: int = 7, use_color: bool | None = None
+) -> None:
+ """对比 payload(211B),打印偏移为「全帧内偏移」从 r_off 起,便于与抓包对照。"""
+ if use_color is None:
+ use_color = _use_color()
+ print(
+ f"\n=== 逐字节对比(payload {len(rp)} B,偏移列 = 全帧内字节下标 {r_off}..{r_off + max(len(rp), len(cp)) - 1})==="
+ )
+ n = max(len(rp), len(cp))
+ print(
+ f"图例: {_GREEN}一致{_RESET} | {_RED}参考≠{_RESET} / {_YELLOW}当前≠{_RESET}"
+ if use_color
+ else "图例: 一致无标记 | 不一致时参考(ref)与当前(cur)数值见下列"
+ )
+ width = 16
+ for row in range(0, n, width):
+ parts_ref: list[str] = []
+ parts_cur: list[str] = []
+ for j in range(width):
+ off = row + j
+ if off >= n:
+ break
+ br = rp[off] if off < len(rp) else None
+ bc = cp[off] if off < len(cp) else None
+ if br is not None and bc is not None:
+ sr, sc = color_byte_pair(br, bc, use_color)
+ parts_ref.append(sr)
+ parts_cur.append(sc)
+ elif br is not None:
+ parts_ref.append(f"{br:02X}" if not use_color else f"{_RED}{br:02X}{_RESET}")
+ parts_cur.append("--" if not use_color else f"{_DIM}--{_RESET}")
+ else:
+ parts_ref.append("--" if not use_color else f"{_DIM}--{_RESET}")
+ parts_cur.append(f"{bc:02X}" if not use_color else f"{_YELLOW}{bc:02X}{_RESET}")
+ frame_off = r_off + row
+ pad = f"{frame_off:04X}"
+ print(f"{pad} ref: {' '.join(parts_ref)}")
+ print(f"{pad} cur: {' '.join(parts_cur)}")
+ mismatch = sum(1 for i in range(min(len(rp), len(cp))) if rp[i] != cp[i])
+ print(f"统计(payload): 相异字节数={mismatch}")
+
+
+def tlv_walk(buf: bytes, depth: int = 0, base: int = 0) -> list[tuple[int, int, str]]:
+ """Return list of (depth, offset, description)."""
+ out: list[tuple[int, int, str]] = []
+ i = 0
+ while i < len(buf):
+ t0 = buf[i]
+ if (t0 & 0x1F) == 0x1F and (t0 & 0xE0) != 0:
+ tag = (buf[i] << 8) | buf[i + 1]
+ tl = 2
+ else:
+ tag = t0
+ tl = 1
+ if i + tl > len(buf):
+ break
+ lb = buf[i + tl]
+ if (lb & 0x80) == 0:
+ vlen = lb & 0x7F
+ ll = 1
+ elif lb == 0x81:
+ if i + tl + 1 >= len(buf):
+ break
+ vlen = buf[i + tl + 1]
+ ll = 2
+ else:
+ out.append((depth, base + i, f"unsupported len fmt 0x{lb:02X}"))
+ break
+ tot = tl + ll + vlen
+ if i + tot > len(buf):
+ out.append((depth, base + i, f"tag=0x{tag:04X} TRUNC"))
+ break
+ val = buf[i + tl + ll : i + tot]
+ names = {
+ 0x00: "00-Status",
+ 0x01: "01-APDU",
+ 0x5A: "5A-CardSEID",
+ 0x77: "77-RespTmpl",
+ 0x73: "73-CardAuthCipher",
+ 0x9F05: "9F05-CardInfo1(车钥匙应用自定义数据)",
+ 0x9F36: "9F36-CardATC",
+ 0x9F37: "9F37-ReaderRnd",
+ 0x9F3B: "9F3B-CardID",
+ 0x9F3E: "9F3E-CardRnd",
+ }
+ nm = names.get(tag, f"tag-0x{tag:04X}")
+ out.append((depth, base + i, f"{nm} len={vlen} val={val.hex()}"))
+ if tag == 0x01 and len(val) >= 5:
+ apdu = val
+ if apdu[0] == 0x80 and apdu[4] > 0 and 5 + apdu[4] <= len(apdu):
+ out.extend(
+ tlv_walk(apdu[5 : 5 + apdu[4]], depth + 1, base + i + tl + ll + 5)
+ )
+ elif len(apdu) >= 2 and apdu[0] == 0x77:
+ sw_off = len(apdu) - 2
+ out.append(
+ (
+ depth + 1,
+ base + i + tl + ll + sw_off,
+ f"SW={apdu[sw_off]:02X}{apdu[sw_off + 1]:02X}",
+ )
+ )
+ out.extend(tlv_walk(apdu[:sw_off], depth + 1, base + i + tl + ll))
+ elif tag == 0x77 and vlen > 0:
+ out.extend(tlv_walk(val, depth + 1, base + i + tl + ll))
+ i += tot
+ return out
+
+
+def tlv_read_one(buf: bytes, i: int) -> tuple[int, int, int, bytes] | None:
+ """Parse one TLV at offset i. Returns (tag, header_len, value_len, value) or None."""
+ if i >= len(buf):
+ return None
+ t0 = buf[i]
+ if (t0 & 0x1F) == 0x1F and (t0 & 0xE0) != 0:
+ if i + 2 > len(buf):
+ return None
+ tag = (buf[i] << 8) | buf[i + 1]
+ tl = 2
+ else:
+ tag = t0
+ tl = 1
+ if i + tl >= len(buf):
+ return None
+ lb = buf[i + tl]
+ if (lb & 0x80) == 0:
+ vlen = lb & 0x7F
+ ll = 1
+ elif lb == 0x81:
+ if i + tl + 1 >= len(buf):
+ return None
+ vlen = buf[i + tl + 1]
+ ll = 2
+ else:
+ return None
+ tot = tl + ll + vlen
+ if i + tot > len(buf):
+ return None
+ val = buf[i + tl + ll : i + tot]
+ return tag, tl + ll, vlen, val
+
+
+def extract_get_data_77_fields(payload: bytes) -> dict:
+ """
+ 从完整 payload(message_id/cmd 之后)解析 00(Status) + 01(APDU) → 77 内 5A/9F3B/9F3E/9F05(Card Info1)/73。
+ 用于核对:5A 的 8B SEID 是否与 9F05(Card Info1) 内「约定偏移」内嵌一致(见 bleICCE.c 注释)。
+ """
+ out: dict = {"ok": False, "note": ""}
+ if len(payload) < 7:
+ out["note"] = "payload too short"
+ return out
+ # +0: 00 01 00 | +3: 01 81 CD ...
+ i = 0
+ r = tlv_read_one(payload, i)
+ if r is None or r[0] != 0x00:
+ out["note"] = "expected Tag00 Status first"
+ return out
+ _, h0, _, _ = r
+ i += h0 + r[2] # skip status tlv total
+ r = tlv_read_one(payload, i)
+ if r is None or r[0] != 0x01:
+ out["note"] = "expected Tag01 APDU"
+ return out
+ tag01_total = r[1] + r[2]
+ apdu = payload[i + r[1] : i + tag01_total]
+ if len(apdu) < 2 or apdu[0] != 0x77:
+ out["note"] = "APDU not R-APDU 77"
+ return out
+ r77 = tlv_read_one(apdu, 0)
+ if r77 is None or r77[0] != 0x77:
+ out["note"] = "inner 77 missing"
+ return out
+ inner77 = apdu[r77[1] : r77[1] + r77[2]]
+ seid_5a: bytes | None = None
+ card_id_9f3b: bytes | None = None
+ card_rnd_9f3e: bytes | None = None
+ card_info1_9f05: bytes | None = None
+ cipher73: bytes | None = None
+ p = 0
+ while p < len(inner77):
+ t = tlv_read_one(inner77, p)
+ if t is None:
+ break
+ tag, hl, vl, val = t
+ tot = hl + vl
+ if tag == 0x5A:
+ seid_5a = val
+ elif tag == 0x9F3B:
+ card_id_9f3b = val
+ elif tag == 0x9F3E:
+ card_rnd_9f3e = val
+ elif tag == 0x9F05:
+ card_info1_9f05 = val
+ elif tag == 0x73:
+ cipher73 = val
+ p += tot
+ out["ok"] = True
+ out["5A_CardSEID_8"] = seid_5a
+ out["9F3B_CardID_16"] = card_id_9f3b
+ out["9F3E_CardRnd_8"] = card_rnd_9f3e
+ out["9F05_CardInfo1_123"] = card_info1_9f05
+ out["73_cipher_32"] = cipher73
+ if card_info1_9f05 is not None and len(card_info1_9f05) >= 24:
+ out["9F05_bytes0_15_CardID_dup"] = card_info1_9f05[0:16]
+ out["9F05_bytes16_23_embed_SEID_slot"] = card_info1_9f05[16:24]
+ return out
+
+
+def print_get_data_semantics(label: str, payload: bytes) -> None:
+ d = extract_get_data_77_fields(payload)
+ print(f"\n=== {label}: 77 内字段语义(与 bleICCE 组包一致)===")
+ print(" Tag 9F05 = Card Info1(车钥匙应用自定义数据,规范表)")
+ if not d.get("ok"):
+ print(f" parse fail: {d.get('note', '?')}")
+ return
+ s5a = d.get("5A_CardSEID_8")
+ id3b = d.get("9F3B_CardID_16")
+ id05_0_15 = d.get("9F05_bytes0_15_CardID_dup")
+ em = d.get("9F05_bytes16_23_embed_SEID_slot")
+ print(f" 5A CardSEID (8B): {s5a.hex() if s5a else '—'}")
+ print(f" 9F3B CardID (16B): {id3b.hex() if id3b else '—'}")
+ print(f" 9F05[0..15] 应与 9F3B 相同: ", end="")
+ if id3b is not None and id05_0_15 is not None:
+ print("MATCH" if id3b == id05_0_15 else "MISMATCH")
+ else:
+ print("—")
+ print(f" 9F05[16..23](注释:内嵌 CardSEID 槽位 8B): {em.hex() if em else '—'}")
+ print(f" 5A 与 9F05[16..23] 相同: ", end="")
+ if s5a is not None and em is not None:
+ if s5a == em:
+ print("是(独立 TLV 5A 与 9F05 内嵌 8B 一致)")
+ else:
+ print("否 — 参考抓包常见「9F05 槽位仍为旧 SEID(00..2F88..),而 5A 已为新 SEID(F86F..)」;与实车一致时应改为同一组(见 bleICCE g_icce_auth_card_info1)")
+ else:
+ print("—")
+ ci9 = d.get("9F05_CardInfo1_123")
+ if s5a is not None and ci9 is not None and len(s5a) == 8:
+ idx = ci9.find(s5a)
+ if idx >= 0:
+ print(f" 5A 的 8B SEID 在 9F05 全文中的偏移: {idx}(与 9F05[16..23] 是否对齐: {'是' if idx == 16 else '否'})")
+ else:
+ print(" 5A 的 8B SEID 在 9F05 全文中: 未出现")
+ cr = d.get("9F3E_CardRnd_8")
+ c73 = d.get("73_cipher_32")
+ print(f" 9F3E CardRnd (8B): {cr.hex() if cr else '—'}")
+ print(f" 73 密文 (32B): {c73.hex() if c73 else '—'}")
+
+
+def split_icce_wire(raw: bytes) -> tuple[dict, bytes]:
+ if len(raw) < 7 or raw[0] != 0x5A:
+ raise ValueError("not ICCE frame")
+ ln = (raw[1] << 8) | raw[2]
+ if len(raw) != 3 + ln + 2:
+ raise ValueError(f"len mismatch got {len(raw)} expect {3+ln+2}")
+ ctrl = raw[3]
+ fsn = raw[4]
+ msg = raw[5]
+ cmd = raw[6]
+ crc = (raw[-2] << 8) | raw[-1]
+ payload = raw[7 : 7 + (ln - 4)]
+ info = {
+ "length_field": ln,
+ "control": ctrl,
+ "fsn": fsn,
+ "message_id": msg,
+ "command_id": cmd,
+ "payload_len": len(payload),
+ "crc16": crc,
+ }
+ return info, payload
+
+
+
+def main() -> None:
+ # Reference: BLE_CARKEY[D] Frame TX(220)
+ ref_hex = (
+ "5A003D000001010001000134773004468D11E063B495F993FEC1C21D0486AED4324838AAABFA313C4913E1994159E856C6BD36F7444472A9A3ED91FE66D4900001F7"
+ # "5A00D7000001010001000181CD7781C85A08F86FDE84DE3000009F3B100069DDE0E715EAFC5F6F3ACD849C326A"
+ # "9F3E083696940547DD0F259F057B0069DDE0E715EAFC5F6F3ACD849C326A0000002F88B7C08970A26F2301C3B1DD0219B5"
+ # "204C53354132444B453053413230333233362463303636616433622D346336302D343563612D616430652D32633830376631633863396302D0A3097707EFC21DE3ABC3C1C9DC6BE8C8FB992AD388184A2776E982DA555C8E73203757D1441F086EDAACE0FAB4B618C1D311CB665466CF65CDA277839D899C317B9000705B"
+ )
+# [ICCE][ICCE HEX] AUTH-WIRE +0000: 5A 00 3D 00 01 01 01 00 01 00 01 34 77 30 C4 5A
+# [ICCE][ICCE HEX] AUTH-WIRE +0010: DD 63 ED 80 3E F3 B9 F6 BA 81 8A F5 04 AD C7 CB
+# [ICCE][ICCE HEX] AUTH-WIRE +0020: A0 26 E3 79 BF FC 8D 30 68 69 9F 9F 20 50 C9 F0
+# [ICCE][ICCE HEX] AUTH-WIRE +0030: EE C1 64 70 E4 C2 A7 96 19 92 B4 8A D5 8D 90 00
+# [ICCE][ICCE HEX] AUTH-WIRE +0040: A0 12
+ # 默认「当前」帧:GET-DATA-WIRE 实机 log 去空格拼接(220B;帧头 00 00 01 01…、尾 9000 705B)
+ cur_hex = (
+ "5A003D0000010100010001347730C45ADD63ED803EF3B9F6BA818AF504ADC7CBA026E379BFFC8D3068699F9F2050C9F0EEC16470E4C2A7961992B48AD58D9000A012"
+ # "5A003D0000010100010101347730C45ADD63ED803EF3B9F6BA818AF504ADC7CBA026E379BFFC8D3068699F9F2050C9F0EEC16470E4C2A7961992B48AD58D90008527"
+ # "5A00D7000001010001000181CD7781C85A08F86FDE84DE3000009F3B100069DDE0E715EAFC5F6F3ACD849C326A9F3E083696940547DD0F25"
+ # "9F057B0069DDE0E715EAFC5F6F3ACD849C326A0000002F88B7C08970A26F2301C3B1DD0219B5204C53354132444B453053413230333233362463303636616433622D346336302D343563612D616430652D32633830376631633863396302D0A3097707EFC21DE3ABC3C1C9DC6BE8C8FB992AD388184A2776E982DA555C8E73203757D1441F086EDAACE0FAB4B618C1D311CB665466CF65CDA277839D899C317B9000705B"
+ )
+
+ # 用法: python3 compare_icce_tlv_frames.py [--no-color] [当前帧hex]
+ argv_rest = [a for a in sys.argv[1:] if a != "--no-color"]
+ if argv_rest:
+ cur_hex = argv_rest[0].replace(" ", "").replace("\n", "")
+
+ ref = bytes.fromhex(ref_hex)
+ cur = bytes.fromhex(cur_hex)
+
+ ri, rp = split_icce_wire(ref)
+ ci, cp = split_icce_wire(cur)
+
+ print("=== Frame header ===")
+ for k in ri:
+ rv, cv = ri[k], ci[k]
+ mark = " " if rv == cv else "!!"
+ print(f"{mark} {k}: ref={rv!r} cur={cv!r}")
+
+ print_full_frame_byte_diff(ref, cur, label="参考 vs 当前(完整 ICCE 帧 含 CRC)")
+ print_payload_byte_diff(rp, cp, r_off=7)
+
+ print_get_data_semantics("参考 (BLE_CARKEY ref)", rp)
+ print_get_data_semantics("当前 (GET-DATA / cur)", cp)
+
+ print("\n=== TLV walk (reference payload) ===")
+ for d, off, s in tlv_walk(rp):
+ print(" " * d + f"+{off:04X} {s}")
+ print("\n=== TLV walk (current payload) ===")
+ for d, off, s in tlv_walk(cp):
+ print(" " * d + f"+{off:04X} {s}")
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+#!/usr/bin/env python3
+"""一次性格式化生成固件三 TLV 金样(8B CardSEID,与 bleICCE.c 一致)。用于 icce_auth_payload_selftest.c 内嵌 expected。"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from icce_auth_response_payload_build import ( # noqa: E402
+ tlv_build,
+ TAG_STATUS,
+ TAG_APDU,
+ TAG_77,
+ TAG_5A,
+ TAG_9F3B,
+ TAG_9F3E,
+ TAG_9F05,
+)
+
+if __name__ == "__main__":
+ _out_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "icce_auth_fw_golden.hex")
+ # 与 bleICCE.c g_icce_auth_card_seid 一致(8 字节);勿写成 9 字节
+ seid = bytes.fromhex("0000002f88b7c089")
+ cid = bytes.fromhex("0069dde0e715eafc5f6f3acd849c326a")
+ crnd = bytes(8)
+ info1 = bytes.fromhex(
+ "0069dde0e715eafc5f6f3acd849c326a0000002f88b7c08970a26f2301c3b1dd0219b5204c533541324"
+ "44b453053413230333233362463303636616433622d346336302d343563612d616430652d32633830376631633863396302d0"
+ "a3097707efc21de3abc3c1c9dc6be8c8fb992ad388184a2776e982da555c8e"
+ )
+ ciph = bytes(32)
+
+ inner = bytearray()
+ inner.extend(tlv_build(TAG_5A, seid))
+ inner.extend(tlv_build(TAG_9F3B, cid))
+ inner.extend(tlv_build(TAG_9F3E, crnd))
+ inner.extend(tlv_build(TAG_9F05, info1))
+ inner.extend(tlv_build(0x73, ciph))
+
+ pl = bytearray()
+ pl.extend(tlv_build(TAG_STATUS, bytes([0x00])))
+ pl.extend(tlv_build(TAG_APDU, bytes([0x90, 0x00])))
+ pl.extend(tlv_build(TAG_77, bytes(inner)))
+ out = bytes(pl)
+ print(len(out))
+ print(out.hex())
+ with open(_out_path, "w", encoding="ascii", newline="\n") as f:
+ f.write(out.hex())
+ f.write("\n")
+ print("wrote", _out_path, file=sys.stderr)
+
+ inc_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "icce_auth_fw_golden_data.inc")
+ lines = [out[i : i + 12] for i in range(0, len(out), 12)]
+ with open(inc_path, "w", encoding="utf-8", newline="\n") as f:
+ f.write(f"/* {len(out)} bytes from icce_auth_fw_golden.hex; regen: python3 gen_icce_auth_fw_golden.py */\n")
+ f.write("static const uint8_t k_expected_fw_tlv_auth_payload[] = {\n")
+ for j, chunk in enumerate(lines):
+ suf = "," if j + 1 < len(lines) else ""
+ f.write(" " + ", ".join(f"0x{x:02x}" for x in chunk) + suf + "\n")
+ f.write("};\n")
+ f.write(f"#define K_EXPECTED_FW_TLV_AUTH_PAYLOAD_LEN ((uint16_t){len(out)}u)\n")
+ print("wrote", inc_path, file=sys.stderr)
--- /dev/null
+#ifndef CHANGAN_HTTP_API_H
+#define CHANGAN_HTTP_API_H
+
+#include "errcode.h"
+#include "stdbool.h"
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * 标识一次走 Http worker 的请求来源(与本头文件中对外 HTTP 类接口对应)。
+ * 嵌套 oauth 等内部调用使用 CHANGAN_HTTP_REQ_OAUTH_TOKEN。
+ */
+typedef enum {
+ CHANGAN_HTTP_REQ_UNKNOWN = 0,
+ CHANGAN_HTTP_REQ_GET,
+ CHANGAN_HTTP_REQ_POST,
+ CHANGAN_HTTP_REQ_PUT,
+ CHANGAN_HTTP_REQ_OAUTH_TOKEN,
+ CHANGAN_HTTP_REQ_QRCODE_GENERATE_V1,
+ CHANGAN_HTTP_REQ_QRCODE_STATUS_NO_BACKEND_V1,
+ CHANGAN_HTTP_REQ_GET_CAR_LIST_BY_BRAND,
+ CHANGAN_HTTP_REQ_POST_VRTM_CAR_CONTROL_V2,
+ CHANGAN_HTTP_REQ_GET_DG_CHECK_RESULT_V1,
+ CHANGAN_HTTP_REQ_GET_BDC_CAR_INFO_USE_CAR_ID_V1,
+ CHANGAN_HTTP_REQ_POST_FC_GET_RECEIVER_INFORMATIONS_V2,
+ CHANGAN_HTTP_REQ_DKEY_PUBLIC_KEY_REGISTER,
+ CHANGAN_HTTP_REQ_DKEY_DOWNLOAD_OWNER_KEY,
+} changan_http_req_type_e;
+
+#ifndef CHANGAN_HTTP_GENERIC_RESP_CAP
+#define CHANGAN_HTTP_GENERIC_RESP_CAP 8192u
+#endif
+#ifndef CHANGAN_HTTP_CTRL_RESP_CAP
+#define CHANGAN_HTTP_CTRL_RESP_CAP (64u * 1024u)
+#endif
+#ifndef CHANGAN_HTTP_QR_RESP_CAP
+#define CHANGAN_HTTP_QR_RESP_CAP (64u * 1024u)
+#endif
+#ifndef CHANGAN_HTTP_QR_STATUS_RESP_CAP
+#define CHANGAN_HTTP_QR_STATUS_RESP_CAP 4096u
+#endif
+#ifndef CHANGAN_HTTP_OAUTH_RESP_CAP
+#define CHANGAN_HTTP_OAUTH_RESP_CAP 4096u
+#endif
+#ifndef CHANGAN_HTTP_QRCODE_ID_MAX
+#define CHANGAN_HTTP_QRCODE_ID_MAX 160u
+#endif
+#ifndef CHANGAN_HTTP_PUBLIC_KEY_ID_MAX
+#define CHANGAN_HTTP_PUBLIC_KEY_ID_MAX 64u
+#endif
+
+#ifndef CHANGAN_HTTP_OAUTH_STORE_ACCESS_TOKEN_MAX
+#define CHANGAN_HTTP_OAUTH_STORE_ACCESS_TOKEN_MAX 512u
+#endif
+#ifndef CHANGAN_HTTP_OAUTH_STORE_SECRET_KEY_MAX
+#define CHANGAN_HTTP_OAUTH_STORE_SECRET_KEY_MAX 128u
+#endif
+#ifndef CHANGAN_HTTP_OAUTH_STORE_TOKEN_TYPE_MAX
+#define CHANGAN_HTTP_OAUTH_STORE_TOKEN_TYPE_MAX 32u
+#endif
+#ifndef CHANGAN_HTTP_OAUTH_STORE_SCOPE_MAX
+#define CHANGAN_HTTP_OAUTH_STORE_SCOPE_MAX 128u
+#endif
+#ifndef CHANGAN_HTTP_OAUTH_STORE_UID_MAX
+#define CHANGAN_HTTP_OAUTH_STORE_UID_MAX 64u
+#endif
+#ifndef CHANGAN_HTTP_OAUTH_STORE_DEVICE_TYPE_MAX
+#define CHANGAN_HTTP_OAUTH_STORE_DEVICE_TYPE_MAX 64u
+#endif
+#ifndef CHANGAN_HTTP_OAUTH_STORE_PRE_OAUTH_MAX
+#define CHANGAN_HTTP_OAUTH_STORE_PRE_OAUTH_MAX 768u
+#endif
+
+/**
+ * vrtm 控车 impl / 签名字段:分阶段 printf(多为整数,少打长串减轻 UART 压力)。
+ * 默认 0;定位死机时编译加 -DCHANGAN_HTTP_DEBUG_VRTM_TRACE=1。
+ */
+#ifndef CHANGAN_HTTP_DEBUG_VRTM_TRACE
+#define CHANGAN_HTTP_DEBUG_VRTM_TRACE 1
+#endif
+
+/**
+ * 最近一次 HTTP 200 /oauth/token 响应体 JSON 解析后的字段缓存(与 changan_http_oauth_token_request 成功解析同步更新)。
+ * access_token 缺省不覆盖旧值;secret_key 仅当 JSON 为字符串时更新;oauth_refresh_token / pre_oauth_token 等按本次 JSON 写入;
+ * 缺省或 null 则置空串;expires_in 非数字则 expires_in_present 为 false。
+ */
+typedef struct changan_http_oauth_last_token {
+ char access_token[CHANGAN_HTTP_OAUTH_STORE_ACCESS_TOKEN_MAX];
+ char secret_key[CHANGAN_HTTP_OAUTH_STORE_SECRET_KEY_MAX];
+ char token_type[CHANGAN_HTTP_OAUTH_STORE_TOKEN_TYPE_MAX];
+ char scope[CHANGAN_HTTP_OAUTH_STORE_SCOPE_MAX];
+ char uid[CHANGAN_HTTP_OAUTH_STORE_UID_MAX];
+ char device_type[CHANGAN_HTTP_OAUTH_STORE_DEVICE_TYPE_MAX];
+ char pre_oauth_token[CHANGAN_HTTP_OAUTH_STORE_PRE_OAUTH_MAX];
+ /** 最近一次响应 JSON 中 refresh_token;无该字段时由解析逻辑用 access_token 填充,供 grant_type=refresh_token 且未显式传参时使用 */
+ char oauth_refresh_token[CHANGAN_HTTP_OAUTH_STORE_PRE_OAUTH_MAX];
+ int32_t expires_in;
+ bool expires_in_present;
+} changan_http_oauth_last_token_t;
+
+extern changan_http_oauth_last_token_t g_changan_http_oauth_last_token;
+
+/** 持久化 access_token / secret_key 路径(单行文本,无结尾换行亦可);可在编译前 #undef 后重定义 */
+#ifndef CHANGAN_HTTP_OAUTH_CACHE_ACCESS_TOKEN_PATH
+#define CHANGAN_HTTP_OAUTH_CACHE_ACCESS_TOKEN_PATH "/user/changan_oauth_access_token.txt"
+#endif
+#ifndef CHANGAN_HTTP_OAUTH_CACHE_SECRET_KEY_PATH
+#define CHANGAN_HTTP_OAUTH_CACHE_SECRET_KEY_PATH "/user/changan_oauth_secret_key.txt"
+#endif
+
+/**
+ * 单次 HTTP 完成后的统一结果(由实现分配,回调返回后由实现释放;回调内勿长期持有 body 指针)。
+ * body:文本 JSON 或二进制(见 body_is_binary);body_len 为有效字节数。
+ * qrcode_id:仅 CHANGAN_HTTP_REQ_QRCODE_GENERATE_V1 且响应头可解析时非空。
+ * public_key_id:仅 DKEY 注册类成功解析时非空。
+ */
+typedef struct changan_http_result {
+ changan_http_req_type_e type;
+ int http_code;
+ uint8_t *body;
+ uint32_t body_len;
+ bool body_is_binary;
+ char qrcode_id[CHANGAN_HTTP_QRCODE_ID_MAX];
+ char public_key_id[CHANGAN_HTTP_PUBLIC_KEY_ID_MAX];
+} changan_http_result_t;
+
+void changan_http_result_destroy(changan_http_result_t *res);
+
+/**
+ * 单次请求完成回调。入队异步执行时在工作线程 Http 完成后调用;内联(嵌套 oauth 等)在调用方上下文调用。
+ * 调用顺序:changan_http_register_global_notify → 本回调 → 内部默认日志处理。
+ */
+typedef void (*changan_http_result_cb_t)(void *user_data, const changan_http_result_t *result);
+
+/** 全局通知:任意经 worker 完成的请求均会调用(先于 per-request 回调)。传 NULL 取消注册 */
+void changan_http_register_global_notify(changan_http_result_cb_t cb, void *user_data);
+void changan_http_unregister_global_notify(void);
+
+#define CHANGAN_HTTP_CLIENT_ID "b0637f0a66f54f95a410c51f5a2186ad"
+#define CHANGAN_HTTP_CLIENT_SECRET "YbYwUsnVXZsb61pTpMy4zg=="
+
+#define CHANGAN_HTTP_SERVER "https://open.iov.changan.com.cn"
+#define CHANGAN_HTTP_INCALL_API_HOST "https://INCALL_API_HOST"
+
+#define CHANGAN_HTTP_API_QRCODE_GENERATE CHANGAN_HTTP_SERVER "/oauth/api/qrcode/generate"
+#define CHANGAN_HTTP_API_QRCODE_GET_STATUS CHANGAN_HTTP_SERVER "/oauth/api/qrcode/getQrcodeStatus"
+#define CHANGAN_HTTP_API_QRCODE_GET_STATUS_NO_BACKEND CHANGAN_HTTP_SERVER "/oauth/api/qrcode/getQrcodeStatusNoBackend"
+
+/* 与 py/qrcode_generate_v1_test.py 默认一致(可与 oauth 所用 client_id 不同) */
+#define CHANGAN_HTTP_QRCODE_DEFAULT_CLIENT_ID "b0637f0a66f54f95a410c51f5a2186ad"
+#define CHANGAN_HTTP_QRCODE_DEFAULT_APP_KEY "YbYwUsnVXZsb61pTpMy4zg=="
+#define CHANGAN_HTTP_QRCODE_DEFAULT_APP_CODE "usercenter"
+#define CHANGAN_HTTP_API_TOKEN CHANGAN_HTTP_SERVER "/oauth/token"
+
+#define CHANGAN_HTTP_API_USER_INFO CHANGAN_HTTP_INCALL_API_HOST "/open/api/v1.0/user/getUserInfo"
+#define CHANGAN_HTTP_API_CAR_LIST CHANGAN_HTTP_INCALL_API_HOST "/open/api/v1.0/car/getList"
+#define CHANGAN_HTTP_API_CAR_INFO CHANGAN_HTTP_INCALL_API_HOST "/openc-apigw/bdc/api/v1/car/get-carInfo-use-carId"
+
+
+
+/* getCarListByBrandCode(ControlCarSign),路径与 py 中 Constans.api_getcarList 一致 */
+#define CHANGAN_HTTP_API_PATH_GET_CAR_LIST_BY_BRAND "/openc-apigw/baseMeta/api/v1/car/getCarListByBrandCode"
+
+/* dg 检测结果 GET(对齐 http/py/openc_dg_check_result_v1_test.py) */
+#define CHANGAN_HTTP_API_PATH_DG_CHECK_RESULT_V1 "/openc-apigw/dg/api/v1/check/result"
+/* bdc 通过 carId 获取车辆信息 GET(对齐 http/py/openc_car_get_car_info_use_carId_bdc_v1_test.py) */
+#define CHANGAN_HTTP_API_PATH_BDC_GET_CAR_INFO_USE_CAR_ID_V1 "/openc-apigw/bdc/api/v1/car/get-carInfo-use-carId"
+/* fc 消息推送信息查询 POST + Query、空 Body(对齐 http/py/openc_fc_get_receiver_informations_v2_test.py) */
+#define CHANGAN_HTTP_API_PATH_FC_GET_RECEIVER_INFORMATIONS_V2 \
+ "/openc-apigw/fc/api/v2/open/information/getReceiverInformations"
+
+/* vrtm 控车 POST 路径前缀(对齐 http/py/openc_car_control_v2_test.py CAR_CONTROL_PATH_PREFIX) */
+#define CHANGAN_HTTP_API_PATH_VRTM_CAR_CONTROL_PREFIX "/openc-apigw/vrtm-agent/api/v2/open/car-control/"
+
+/* 解锁车门:请使用 changan_http_post_vrtm_car_control_v2 + CHANGAN_VRTM_CAR_CTRL_UNLOCK_DOOR(路径段 unLockDoor) */
+#define CHANGAN_HTTP_API_PATH_UNLOCK_DOOR CHANGAN_HTTP_API_PATH_VRTM_CAR_CONTROL_PREFIX "unLockDoor"
+
+/* dkey 2.0(对齐 http/py/openc_dkey_register_and_download_owner_key_control_car_test.py) */
+#define CHANGAN_HTTP_API_PATH_DKEY_PUBLIC_KEY_REGISTER \
+ "/openc-apigw/dkey/api/v1/secret-key/public-key-register"
+#define CHANGAN_HTTP_API_PATH_DKEY_DOWNLOAD_OWNER_KEY \
+ "/openc-apigw/dkey/api/v1/key/download-owner-key"
+#define CHANGAN_HTTP_DKEY_DEFAULT_DEVICE_ID "8c046d6f4ed0ec77"
+#define CHANGAN_HTTP_DKEY_DEFAULT_APP_ID "cn.com.changan_1234.cvim"
+
+// temperature: 20 //空调度数
+// airModel: 1 //空调的模式
+// windPower: 1 //空调的等级,
+
+typedef enum {
+ CHANGAN_OAUTH_GRANT_CLIENT_CREDENTIALS = 0,
+ CHANGAN_OAUTH_GRANT_AUTHORIZATION_CODE,
+ CHANGAN_OAUTH_GRANT_REFRESH_TOKEN,
+} changan_oauth_grant_type_e;
+
+/** POST https://open.iov.changan.com.cn/oauth/token(对齐 http/py/openc_oauth_token_test.py) */
+typedef struct {
+ const char *client_id;
+ const char *client_secret;
+ changan_oauth_grant_type_e grant_type;
+ const char *code; /* authorization_code;grant 为该类型时必填 */
+ const char *redirect_uri;
+ /** refresh_token:grant 为该类型时可为 NULL/空,此时依次使用内存缓存 access_token、oauth_refresh_token、pre_oauth_token */
+ const char *refresh_token;
+} changan_oauth_token_params_t;
+
+/** GET …/car/getCarListByBrandCode(对齐 http/py/openc_car_getCarListByBrandCode_control_car_test.py) */
+typedef struct {
+ const char *access_token; /* NULL 或空串:使用 changan_http_oauth_token_request 成功后的缓存 */
+ const char *secret_key; /* NULL 或空串:同上缓存 secret_key,作 HMAC 密钥 */
+ const char *brand_code; /* NULL → "CHANGAN" */
+ const char *timestamp_sec; /* NULL → 当前秒级时间戳字符串 */
+ const char *nonce; /* NULL → "WYYL" */
+ const char *api_path; /* NULL → CHANGAN_HTTP_API_PATH_GET_CAR_LIST_BY_BRAND */
+ /** 未显式传 access_token/secret_key 且缓存不足时,先 POST /oauth/token(对齐 py 无 --access-token 时 fetch_user_access_token) */
+ const changan_oauth_token_params_t *oauth_bootstrap;
+ /**
+ * true:在 changan_control_car_build_authorization 中打印完整控车签名步骤
+ *(对齐 http/py/openc_car_getCarListByBrandCode_control_car_test.py 的 _print_sign_debug_annotated)。
+ * changan_http_get_car_list_by_brand_code_control_car 内会强制置 true。
+ */
+ bool print_control_car_sign_debug;
+} changan_get_car_list_by_brand_params_t;
+
+/**
+ * vrtm-agent 控车指令(与 http/py 下 openc_car_control_v2_test.py / openc_car_control_v2_test copy.py 中 VRTM_CAR_COMMANDS 一致)。
+ * URL = CHANGAN_HTTP_API_PATH_VRTM_CAR_CONTROL_PREFIX + 路径段;Body.cmd 见各枚举默认说明。
+ * Python --command 名与枚举对应:close_air / close_window / flash_light / lock_door / open_air /
+ * remote_search_car / unlock_door / window_slit / up_car_condition。
+ * 解锁车门请使用 command=CHANGAN_VRTM_CAR_CTRL_UNLOCK_DOOR(对齐原 unLockDoor 专用接口)。
+ */
+typedef enum {
+ CHANGAN_VRTM_CAR_CTRL_CLOSE_AIR = 0,
+ CHANGAN_VRTM_CAR_CTRL_CLOSE_WINDOW,
+ CHANGAN_VRTM_CAR_CTRL_FLASH_LIGHT,
+ CHANGAN_VRTM_CAR_CTRL_LOCK_DOOR,
+ CHANGAN_VRTM_CAR_CTRL_OPEN_AIR,
+ CHANGAN_VRTM_CAR_CTRL_REMOTE_SEARCH_CAR,
+ CHANGAN_VRTM_CAR_CTRL_UNLOCK_DOOR,
+ CHANGAN_VRTM_CAR_CTRL_WINDOW_SLIT,
+ CHANGAN_VRTM_CAR_CTRL_UP_CAR_CONDITION,
+ CHANGAN_VRTM_CAR_CTRL_COUNT
+} changan_vrtm_car_control_command_e;
+
+/**
+ * POST …/vrtm-agent/api/v2/open/car-control/<segment>(对齐 http/py/openc_car_control_v2_test.py 与 copy 版)
+ * Body:mapArgsJson、senderType、cmd、carId;ControlCarSign(含解锁 unLockDoor)。
+ * map_args_json:与 py --map-args-json 相同 UTF-8 文本;开空调等可传 JSON,如 {\"temperature\":20,\"airModel\":1,\"windPower\":1}。
+ */
+typedef struct {
+ const char *access_token;
+ const char *secret_key;
+ const changan_oauth_token_params_t *oauth_bootstrap;
+ const char *car_id;
+ const char *map_args_json; /* NULL 或 "" → "{}";勿含未转义双引号(与 AT 分参限制一致) */
+ const char *sender_type; /* NULL 或 "" → "APP" */
+ bool timestamp_ms;
+ const char *timestamp;
+ const char *nonce;
+ /** NULL:使用 PATH_PREFIX + command 对应路径段;非空则整段路径(与 py --api-path) */
+ const char *api_path;
+ changan_vrtm_car_control_command_e command;
+ /** NULL:使用 command 默认 body.cmd;非空则覆盖(与 py --body-cmd) */
+ const char *body_cmd_override;
+} changan_vrtm_car_control_v2_params_t;
+
+/**
+ * 仅异步非阻塞:@return 0 已入队;负数:-100 cb 为空,-101 内存,-102 队列满;
+ * 正数:仅在内联路径(如 worker 内嵌套 oauth)表示 HTTP 状态码。
+ * 响应体、qrcode_id、public_key_id 均在 changan_http_result_t 中于回调解析。
+ * 经 changan_http_submit_job 异步入队的各接口在入队时会对 params 及通用 GET/POST/PUT 的 url、post 体做堆拷贝,
+ * 回调返回后调用方栈上的 params 与缓冲区可失效;若某结构体仍含未深拷贝的嵌套指针,以各接口注释为准。
+ */
+int changan_http_get(char *post_buf, char *url, changan_http_result_cb_t cb, void *user_data);
+int changan_http_post(char *post_buf, char *url, changan_http_result_cb_t cb, void *user_data);
+int changan_http_put(char *post_buf, char *url, changan_http_result_cb_t cb, void *user_data);
+
+/**
+ * POST /oauth/api/qrcode/generate(v1 表单签名,对齐 py/qrcode_generate_v1_test.py)
+ * 表单字段 device_id 由实现统一填 Cat1 IMEI,与签名一致。
+ */
+typedef struct {
+ const char *client_id;
+ const char *nonce;
+ const char *size;
+ const char *state;
+ const char *timestamp_ms; /* NULL 则使用当前毫秒时间戳字符串 */
+ const char *app_key;
+ const char *app_code;
+ bool exclude_app_code_from_sign; /* true:签名不含 appCode,与 Python --exclude-appCode 一致 */
+} changan_qrcode_generate_v1_params_t;
+
+/**
+ * GET /oauth/api/qrcode/getQrcodeStatusNoBackend(对齐 py/qrcode_status_no_backend_v1_test.py)
+ * timestamp 为秒级 UNIX 时间字符串;no_app_key 为 true 时不参与签名与查询参数。
+ */
+typedef struct {
+ const char *nonce;
+ const char *timestamp_sec; /* NULL 则使用当前秒级时间戳 */
+ const char *qrcode_id;
+ const char *app_key;
+ bool no_app_key;
+} changan_qrcode_status_no_backend_v1_params_t;
+
+int changan_http_qrcode_generate_v1(const changan_qrcode_generate_v1_params_t *params,
+ changan_http_result_cb_t cb, void *user_data);
+int changan_http_qrcode_status_no_backend_v1(const changan_qrcode_status_no_backend_v1_params_t *params,
+ changan_http_result_cb_t cb, void *user_data);
+
+/** grant_type=authorization_code 时 code 必填;=refresh_token 时 refresh_token 可空(依次用缓存 access_token、oauth_refresh_token、pre_oauth_token),皆无则返回 -1 */
+int changan_http_oauth_token_request(const changan_oauth_token_params_t *params,
+ changan_http_result_cb_t cb, void *user_data);
+bool changan_http_oauth_parse_access_token(const char *json_resp, char *token_out, uint32_t token_cap);
+
+/**
+ * 写入 OAuth 内存缓存(控车缺省凭证);可选与 /oauth/token 成功解析后相同路径落盘。
+ * access_token、secret_key 为 NULL 表示不修改该项;二者均为 NULL 返回 -1。
+ * 非 NULL 时允许空串以清空该项;超长返回 -2(access)或 -3(secret),且不修改任何字段。
+ * @return 0 成功
+ */
+int changan_http_oauth_set_cached_credentials(const char *access_token, const char *secret_key, bool persist_to_disk);
+
+/** 将当前内存中的 access_token 拷入 out(含尾 \\0);cap 不足返回 false。不读盘;须已由 OAuth/set_cached 或控车 resolve 等路径填充 g_changan_http_oauth_last_token */
+bool changan_http_oauth_get_stored_access_token(char *out, uint32_t cap);
+/** 将当前内存中的 secret_key 拷入 out;规则同上 */
+bool changan_http_oauth_get_stored_secret_key(char *out, uint32_t cap);
+/** 最近一次解析含数字 expires_in 时返回 true 并写入秒数;否则 false */
+bool changan_http_oauth_get_stored_expires_in(int32_t *expires_out);
+
+int changan_http_get_car_list_by_brand_code_control_car(const changan_get_car_list_by_brand_params_t *params,
+ changan_http_result_cb_t cb, void *user_data);
+
+/**
+ * GET dg/api/v1/check/result?carId=…(ControlCarSign;对齐 openc_dg_check_result_v1_test.py)。
+ * api_path 为 NULL 时使用 CHANGAN_HTTP_API_PATH_DG_CHECK_RESULT_V1;请求头带 Content-Type: application/x-www-form-urlencoded。
+ */
+typedef struct {
+ const char *access_token;
+ const char *secret_key;
+ const changan_oauth_token_params_t *oauth_bootstrap;
+ bool timestamp_ms;
+ const char *timestamp;
+ const char *nonce; /* NULL 或空:随机 4 位十六进制 X-VCS-Nonce */
+ const char *api_path;
+ const char *car_id;
+} changan_openc_car_id_get_params_t;
+
+/**
+ * GET bdc/.../get-carInfo-use-carId?carId=…(ControlCarSign;对齐 openc_car_get_car_info_use_carId_bdc_v1_test.py)。
+ * api_path 为 NULL 时使用 CHANGAN_HTTP_API_PATH_BDC_GET_CAR_INFO_USE_CAR_ID_V1。
+ */
+int changan_http_get_dg_check_result_v1(const changan_openc_car_id_get_params_t *params,
+ changan_http_result_cb_t cb, void *user_data);
+int changan_http_get_bdc_car_info_use_car_id_v1(const changan_openc_car_id_get_params_t *params,
+ changan_http_result_cb_t cb, void *user_data);
+
+/**
+ * POST fc/.../getReceiverInformations?<Query>,Body 空串,Content-Type: application/x-www-form-urlencoded
+ *(对齐 openc_fc_get_receiver_informations_v2_test.py;Query 键顺序 actionType、trackUserId、可选 realReceiverId、trunkFullPath、page、limit)。
+ */
+typedef struct {
+ const char *access_token;
+ const char *secret_key;
+ const changan_oauth_token_params_t *oauth_bootstrap;
+ bool timestamp_ms;
+ const char *timestamp;
+ const char *nonce;
+ const char *api_path;
+ const char *track_user_id;
+ const char *action_type; /* NULL 或空 → "1" */
+ const char *real_receiver_id;
+ const char *trunk_full_path;
+ const char *page;
+ const char *limit;
+} changan_fc_get_receiver_informations_v2_params_t;
+
+int changan_http_post_fc_get_receiver_informations_v2(const changan_fc_get_receiver_informations_v2_params_t *params,
+ changan_http_result_cb_t cb, void *user_data);
+
+/**
+ * vrtm-agent 控车综合 POST(对齐 http/py/openc_car_control_v2_test.py 与 openc_car_control_v2_test copy.py)。
+ * 仅异步非阻塞:返回值与其它 changan_http_* 异步入队接口一致;入队时已深拷贝 params 内各字符串(含嵌套 oauth_bootstrap)。
+ *
+ * 默认 verifySign 的 httpUrl 为单段前缀 CHANGAN_HTTP_API_PATH_VRTM_CAR_CONTROL_PREFIX + 路径段;若网关要求双前缀
+ * /openc-apigw/openc-apigw/...,请设 params->api_path 为完整路径(与 py --api-path)。
+ *
+ * params->command 与 Python CLI --command、URL 路径段、默认 Body.cmd 对应(括号内:路径段 / cmd):
+ * - CHANGAN_VRTM_CAR_CTRL_CLOSE_AIR — close_air:关闭空调(closeAir / closeAir)
+ * - CHANGAN_VRTM_CAR_CTRL_CLOSE_WINDOW — close_window:关闭车窗(closeWindow / CloseWindow)
+ * - CHANGAN_VRTM_CAR_CTRL_FLASH_LIGHT — flash_light:闪灯(flashLight / flashLight)
+ * - CHANGAN_VRTM_CAR_CTRL_LOCK_DOOR — lock_door:锁定车门(lockDoor / LockDoor)
+ * - CHANGAN_VRTM_CAR_CTRL_OPEN_AIR — open_air:打开空调(openAir / openAir)
+ * - CHANGAN_VRTM_CAR_CTRL_REMOTE_SEARCH_CAR — remote_search_car:闪灯鸣笛/远程寻车(remoteSearchCar / remoteSearchCar)
+ * - CHANGAN_VRTM_CAR_CTRL_UNLOCK_DOOR — unlock_door:解锁车门(unLockDoor / UnLockDoor)
+ * - CHANGAN_VRTM_CAR_CTRL_WINDOW_SLIT — window_slit:车窗留缝(windowSlit / windowSlit)
+ * - CHANGAN_VRTM_CAR_CTRL_UP_CAR_CONDITION — up_car_condition:车辆上报车况(upCarCondition / upCarCondition)
+ * 独立脚本对照见 py 脚本 epilog(如 unlock_door → openc_car_unlockDoor_v2_test.py)。
+ * params->api_path / params->body_cmd_override 可覆盖默认路径与 Body.cmd(与 py --api-path / --body-cmd)。
+ */
+int changan_http_post_vrtm_car_control_v2(const changan_vrtm_car_control_v2_params_t *params,
+ changan_http_result_cb_t cb, void *user_data);
+
+/** ControlCarSign.verifySign 通用入参(GET/POST;POST 时 body_for_sign 为参与 SHA256 的 JSON 原文) */
+typedef struct {
+ const char *access_token;
+ const char *secret_key;
+ const char *timestamp; /* NULL → 当前时间;timestamp_ms 决定秒/毫秒 */
+ bool timestamp_ms;
+ const char *nonce;
+ const char *http_method;
+ const char *http_url;
+ const char *query_wire; /* NULL 或空串 → 无 query(canonical 中 url 后空一行) */
+ const char *body_for_sign;
+} changan_control_car_auth_params_t;
+
+/** POST …/secret-key/public-key-register(deviceId 由实现填 Cat1 IMEI) */
+typedef struct {
+ const char *access_token;
+ const char *secret_key;
+ const changan_oauth_token_params_t *oauth_bootstrap;
+ bool timestamp_ms;
+ const char *timestamp;
+ const char *header_nonce;
+ const char *api_path;
+ const char *user_id;
+ const char *app_id;
+ const char *algorithm;
+ /** NULL 或空:从本机密钥仓加载 SPKI Base64(与 changan_http_dkey_generate_rsa2048_keypair 落盘一致) */
+ const char *public_key_spki_b64;
+} changan_dkey_public_key_register_params_t;
+
+/** POST …/key/download-owner-key(public_key_id 由 public-key-register 成功回调解析 body 得到后再填) */
+typedef struct {
+ const char *access_token;
+ const char *secret_key;
+ const changan_oauth_token_params_t *oauth_bootstrap;
+ bool timestamp_ms;
+ const char *timestamp;
+ const char *header_nonce;
+ const char *api_path;
+ const char *user_id;
+ const char *car_id;
+ const char *public_key_id;
+ const char *body_nonce; /* NULL → 随机 16 位十六进制 */
+ int protocol_type;
+ bool private_sign_exclude_protocol_type;
+ bool protocol_type_json_number;
+ /** NULL 或空:从本机密钥仓加载 RSA 私钥 PEM(与 generate 落盘一致) */
+ const char *rsa_private_key_pem;
+} changan_dkey_download_owner_key_params_t;
+
+#ifndef CHANGAN_HTTP_DKEY_ENSURE_ERR_MISSING_OAUTH
+/* changan_http_dkey_ensure_owner_key_for_vehicle:内存/落盘 OAuth 缓存中无 access_token 或 secret_key */
+#define CHANGAN_HTTP_DKEY_ENSURE_ERR_MISSING_OAUTH (-105)
+#endif
+
+/**
+ * 按车拉齐数字钥匙:先 ble_icce_changan_auth_card_identity_ready(vehicle_car_id);若钥匙不存在则检查本机 SPKI
+ *(CHANGAN_DKEY_STORE_SPKI_B64_PATH),缺失则 changan_http_dkey_generate_rsa2048_keypair 落盘后再
+ * changan_http_dkey_public_key_register。
+ * 控车 access_token / secret_key 必须从 OAuth 缓存读取(changan_http_oauth_get_stored_* / 落盘文件);调用方
+ * 不得在参数里再传凭据;若缓存中二者缺一,直接返回 CHANGAN_HTTP_DKEY_ENSURE_ERR_MISSING_OAUTH,不发起 oauth。
+ * user_id 缺省使用最近一次 /oauth/token 解析得到的 uid(须非空)。
+ * 若本机 SPKI、私钥 PEM 齐全且 changan_http_dkey_load_stored_public_key_register 表明公钥已向服务端注册成功
+ *(见 CHANGAN_DKEY_STORE_PUBLIC_KEY_REGISTER_PATH),则跳过注册,直接用落盘的 public_key_id 发起
+ * changan_http_dkey_download_owner_key。否则在公钥注册完成后由 changan_http_default_result_handler 根据
+ * public_key_id 自动发起 download-owner-key。
+ * @param download_done_cb download-owner-key 完成回调,可为 NULL(内部空回调);download_user_data 一并传入。
+ * @return 0 本车钥匙已就绪,或已提交注册/下载(异步完成后 default 内自动解密等);-1 参数非法(含 user 不可解析);CHANGAN_HTTP_DKEY_ENSURE_ERR_MISSING_OAUTH 无 OAuth 凭据;-101 密钥生成缓冲分配失败;-103 上一笔 ensure 链未完成;-104 本机生成 RSA 失败;其它与 public_key_register / download_owner_key 入队失败码一致;同步失败时返回 HTTP 状态码。
+ */
+typedef struct {
+ const char *vehicle_car_id;
+ /** NULL 或空:使用 OAuth 缓存 g_changan_http_oauth_last_token.uid */
+ const char *user_id;
+ /** download-owner-key body nonce;NULL 表示随机 16 位十六进制 */
+ const char *body_nonce;
+ /** 0 表示默认 1 */
+ int protocol_type;
+ bool private_sign_exclude_protocol_type;
+ bool protocol_type_json_number;
+ /** NULL 或空:默认 CHANGAN_HTTP_API_PATH_DKEY_PUBLIC_KEY_REGISTER */
+ const char *api_path_register;
+ /** NULL 或空:默认 CHANGAN_HTTP_API_PATH_DKEY_DOWNLOAD_OWNER_KEY */
+ const char *api_path_download;
+} changan_http_dkey_ensure_owner_key_params_t;
+
+int changan_http_dkey_ensure_owner_key_for_vehicle(const changan_http_dkey_ensure_owner_key_params_t *params,
+ changan_http_result_cb_t download_done_cb, void *download_user_data);
+
+int changan_http_dkey_public_key_register(const changan_dkey_public_key_register_params_t *params,
+ changan_http_result_cb_t cb, void *user_data);
+
+int changan_http_dkey_download_owner_key(const changan_dkey_download_owner_key_params_t *params,
+ changan_http_result_cb_t cb, void *user_data);
+
+/**
+ * 解密 download-owner-key 响应 data 中 cardInfoEnc / dkeyEnc(RSA/ECB/PKCS1Padding,与 Java Cipher 默认一致;
+ * 线格式可为标准 Base64,或「仅十六进制 ASCII、偶数长度」且字节数为 RSA 块长整数倍(与部分网关返回一致);
+ * 密文可为多块 RSA 输出拼接后再编码)。
+ * download_resp_json 可为完整响应 JSON,或仅 data 对象;card_info_out / dkey_out 至少提供其一及对应 cap(二者皆提供时写 ICCE 最完整)。
+ * 私钥默认优先从本机密钥仓 PEM 文件读取(与 DKEY_GEN 落盘一致);文件缺失或无效时回退使用 rsa_private_key_pem(可为 NULL)。
+ * 解密成功(ret==0)后:16B 主密钥 dkey 与 card_info 一并经 ble_icce_changan_set_auth_card_identity 注入;SessionKey 派生所用 9F0C 仍来自 BLE 线侧缓存,不注入独立 CardIV;
+ * card_info 按长安规范:前 16B 为 CardID;其后为 KPRE/IRR/时间/VIN/USERID 等(无独立「CardSEID」明文字段)。整段作 9F05 CardInfo1;JSON 含 bleMac 时写入落盘文件头中的车端蓝牙地址;
+ * car_id_opt 非空时优先作车辆 id;否则尝试从 JSON data 读取 carId / car_id;若仍无则使用本机设备号
+ *(changan_http_effective_device_id:Cat1 IMEI,无效时 CHANGAN_HTTP_DKEY_DEFAULT_DEVICE_ID),与公钥注册 deviceId 一致,供 ICCE 一车一钥落盘路径。
+ * 异步 changan_http_dkey_download_owner_key 在 per-request 回调之后,由 changan_http_default_result_handler 对 http=200 的 JSON 自动调用本函数(与手动再调等价,ICCE/BLE 侧效果一致)。
+ * @return 0 成功;-1 参数/JSON/解密失败
+ */
+int changan_http_dkey_decrypt_download_owner_key_response(const char *download_resp_json,
+ const char *rsa_private_key_pem,
+ char *card_info_out, uint32_t card_info_cap, uint32_t *card_info_len_out,
+ uint8_t *dkey_out, uint32_t dkey_cap, uint32_t *dkey_len_out, const char *car_id_opt);
+
+/** 仅将 RSA 私钥 PEM 写入 DKEY 落盘路径(与 generate 写入的私钥文件一致)。 */
+int changan_http_dkey_store_private_pem_file(const char *pem);
+
+/**
+ * 读取本机落盘的公钥注册状态(与 public-key-register 成功时写入的 CHANGAN_DKEY_STORE_PUBLIC_KEY_REGISTER_PATH
+ * 一致:首行 1/0,次行为 public_key_id)。
+ * @return 0 文件合法;-1 参数非法;-2 文件缺失或格式无效(此时 *registered_ok_out 为 false,id 清空)
+ */
+int changan_http_dkey_load_stored_public_key_register(bool *registered_ok_out, char *public_key_id_out,
+ uint32_t public_key_id_cap);
+
+/**
+ * 本地 RSA-2048 密钥对(changan_dkey_generate_rsa2048_keypair);成功后将 PEM 与 SPKI Base64
+ * 写入默认路径(见 changan_http_common.c 中 CHANGAN_DKEY_STORE_*),供注册/下载自动加载。
+ */
+int changan_http_dkey_generate_rsa2048_keypair(char *private_pem_out, uint32_t private_pem_cap,
+ char *public_spki_b64_out, uint32_t public_spki_b64_cap);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CHANGAN_HTTP_API_H */
+
+/* 接口定义: */
+/* API-1 第三方应用获取业务二维码 */
+// 功能描述:第三方应用通过该接口可以获取业务二维码
+// 接口地址:https://SERVER/oauth/api/qrcode/generate
+// 请求方式:POST
+
+
+
+// API-2 第三方应用获取业务二维码状态
+// 功能描述:第三方应用通过该接口可以获取业务二维码状态
+// 接口地址:https://SERVER/oauth/api/qrcode/getQrcodeStatus
+// 请求方式:POST
+
+
+
+
+// API-3 获取accessToken
+// 功能描述:使用用户授权的授权码获取(access_Token)
+// 接口地址:https://SERVER/oauth/token
+// 请求方式:POST/GET
+
+
+
+
+// API-4 获取用户信息
+// 功能描述:获取当前用户信息
+// 接口地址:https://INCALL_API_HOST/open/api/v1.0/user/getUserInfo
+// 请求方式:POST
+
+// API-6 获取车辆列表
+// 功能描述:分页查询用户车辆的基础信息列表
+// 接口地址:https://INCALL_API_HOST/open/api/v1.0/car/getList
+// 请求方式:POST
+
+
+// API-7 获取车辆信息
+// 功能描述:通过carid获取车辆详细信息
+// 接口地址:https://INCALL_API_HOST/openc-apigw/bdc/api/v1/car/get-carInfo-use-carId
+// 请求方式:GET
--- /dev/null
+
+#include "httpclient.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include "cJSON.h"
+#include "changan_http_api.h"
+#include "changan_http_sign.h"
+#include "bleICCE.h"
+#include "stdbool.h"
+#include <time.h>
+#include "cmsis_os2.h"
+#include "custom_utils.h"
+#ifndef USE_EXTEND_MEM
+#define USE_EXTEND_MEM 1
+#endif
+/*
+ * ChangAn 业务 HTTP 封装,接口风格参考 dmp_http.c:
+ * changan_http_post / put / get:JSON
+ * changan_http_oauth_token_request:/oauth/token
+ * changan_http_get_car_list_by_brand_code_control_car:控车签名 GET
+ * changan_http_get_dg_check_result_v1 / get_bdc_car_info_use_car_id_v1 / post_fc_get_receiver_informations_v2:
+ * dg / bdc / fc(ControlCarSign)
+ * changan_http_post_vrtm_car_control_v2:vrtm 控车综合 POST(含解锁 unLockDoor,对齐 py/openc_car_control_v2_test.py)
+ * changan_http_dkey_*:数字钥匙 public-key-register / download-owner-key(分步异步)、本地密钥生成、响应解密
+ * changan_http_qrcode_*:二维码 openC v1
+ * 对外仅非阻塞:返回 0 表示已入队;负数见 changan_http_api.h。响应在 changan_http_result_t 中经回调交付。
+ *
+ * HttpClient 在独立 worker 线程执行;请求均先入队(或队列不可用时同线程内联执行一次 job),支持连续多任务排队。
+ * 完成顺序:全局 notify → per-request 回调 → default(含 download-owner-key http=200 时自动解密)→ 日志 → 释放 result/job 缓冲。
+ */
+
+ #ifdef __cplusplus
+ extern "C" {
+ #endif
+
+/* ---------- HttpClient 工作线程(参考 uarttest_http.c) ---------- */
+
+#define CHANGAN_HTTP_JOB_QUEUE_DEPTH 8U
+
+typedef enum {
+ CHANGAN_HTTP_JK_COMMON = 0,
+ CHANGAN_HTTP_JK_OAUTH,
+ CHANGAN_HTTP_JK_CARLIST,
+ CHANGAN_HTTP_JK_CC_POST,
+ CHANGAN_HTTP_JK_VRTM,
+ CHANGAN_HTTP_JK_QR_GEN,
+ CHANGAN_HTTP_JK_QR_ST,
+ CHANGAN_HTTP_JK_DKEY_REG,
+ CHANGAN_HTTP_JK_DKEY_DL,
+ CHANGAN_HTTP_JK_OPENC_CARID_GET,
+ CHANGAN_HTTP_JK_FC_RECEIVER_INFO,
+} changan_http_job_kind_e;
+
+typedef struct changan_http_job {
+ changan_http_job_kind_e kind;
+ changan_http_req_type_e req_type;
+ changan_http_result_cb_t done_cb;
+ void *done_ud;
+ union {
+ struct {
+ char tag[16];
+ char *post_buf;
+ bool owns_post_buf;
+ char *url;
+ bool owns_url;
+ char *content_type;
+ bool owns_ctype;
+ uint8_t *resp_heap;
+ uint32_t resp_cap;
+ } co;
+ struct {
+ const changan_oauth_token_params_t *params;
+ uint8_t *resp_heap;
+ uint32_t resp_cap;
+ } oauth;
+ struct {
+ const changan_get_car_list_by_brand_params_t *params;
+ uint8_t *resp_heap;
+ uint32_t resp_cap;
+ } carlist;
+ struct {
+ char *url;
+ char *req_hdr;
+ char *body;
+ uint8_t *resp_heap;
+ uint32_t resp_cap;
+ } cc;
+ struct {
+ const changan_vrtm_car_control_v2_params_t *params;
+ uint8_t *resp_heap;
+ uint32_t resp_cap;
+ } vrtm;
+ struct {
+ const changan_qrcode_generate_v1_params_t *params;
+ uint8_t *resp_heap;
+ uint32_t resp_cap;
+ uint32_t out_body_len;
+ char qrcode_id_buf[CHANGAN_HTTP_QRCODE_ID_MAX];
+ } qr_gen;
+ struct {
+ const changan_qrcode_status_no_backend_v1_params_t *params;
+ uint8_t *resp_heap;
+ uint32_t resp_cap;
+ } qr_st;
+ struct {
+ const changan_dkey_public_key_register_params_t *p;
+ uint8_t *resp_heap;
+ uint32_t resp_cap;
+ char public_key_id_buf[CHANGAN_HTTP_PUBLIC_KEY_ID_MAX];
+ } dreg;
+ struct {
+ const changan_dkey_download_owner_key_params_t *p;
+ uint8_t *resp_heap;
+ uint32_t resp_cap;
+ } dld;
+ struct {
+ const changan_openc_car_id_get_params_t *params;
+ const char *path_if_api_null;
+ uint8_t get_hdr_form_urlencoded;
+ uint8_t *resp_heap;
+ uint32_t resp_cap;
+ } openc_cid;
+ struct {
+ const changan_fc_get_receiver_informations_v2_params_t *params;
+ uint8_t *resp_heap;
+ uint32_t resp_cap;
+ } fc_rcv;
+ } u;
+} changan_http_job_t;
+
+static osMessageQueueId_t g_changan_httpw_mq;
+static uint32_t g_changan_httpw_tid;
+static uint8_t g_changan_httpw_inited;
+static uint8_t g_changan_httpw_thread_create_failed;
+
+static changan_http_result_cb_t g_changan_http_global_notify;
+static void *g_changan_http_global_notify_ud;
+
+void changan_http_register_global_notify(changan_http_result_cb_t cb, void *user_data)
+{
+ g_changan_http_global_notify = cb;
+ g_changan_http_global_notify_ud = user_data;
+}
+
+void changan_http_unregister_global_notify(void)
+{
+ g_changan_http_global_notify = NULL;
+ g_changan_http_global_notify_ud = NULL;
+}
+
+static int changan_http_common_do_sync(const char *tag,
+ char *post_buf, char *url, char *put_buf, uint32_t max_len, char *content_type);
+static int changan_http_oauth_token_request_do_sync(const changan_oauth_token_params_t *p, char *resp_buf, uint32_t resp_cap);
+static void changan_http_oauth_parse_token_response_json(const char *json_resp);
+static void changan_oauth_try_load_from_disk(void);
+static int changan_http_get_car_list_by_brand_code_control_car_do_sync(const changan_get_car_list_by_brand_params_t *p,
+ char *resp_buf, uint32_t resp_cap);
+static int changan_http_control_car_post_json_do_sync(const char *url, const char *req_hdr, const char *body,
+ char *resp_buf, uint32_t resp_cap);
+static int changan_http_control_car_post_json(const char *url, const char *req_hdr, const char *body,
+ char *resp_buf, uint32_t resp_cap);
+static int changan_http_qrcode_generate_v1_do_sync(const changan_qrcode_generate_v1_params_t *params,
+ uint8_t *resp_buf, uint32_t resp_cap, uint32_t *out_body_len, char *qrcode_id_out, uint32_t qrcode_id_cap);
+static int changan_http_qrcode_status_no_backend_v1_do_sync(const changan_qrcode_status_no_backend_v1_params_t *params,
+ char *resp_buf, uint32_t resp_cap);
+
+static int changan_http_common_with_cb(const char *tag, char *post_buf, char *url, const char *content_type,
+ changan_http_req_type_e req_type, changan_http_result_cb_t cb, void *user_data);
+
+static int changan_http_dkey_public_key_register_impl(const changan_dkey_public_key_register_params_t *p,
+ char *resp_buf, uint32_t resp_cap, char *public_key_id_out, uint32_t public_key_id_cap,
+ changan_http_req_type_e req_http_type);
+static int changan_http_dkey_download_owner_key_impl(const changan_dkey_download_owner_key_params_t *p,
+ char *resp_buf, uint32_t resp_cap, changan_http_req_type_e req_http_type);
+static int changan_http_post_vrtm_car_control_v2_impl(const changan_vrtm_car_control_v2_params_t *p, char *resp_buf,
+ uint32_t resp_cap, changan_http_req_type_e req_type);
+
+static void changan_dkey_random_nonce4(char out[5]);
+static int changan_http_openc_car_id_get_do_sync(const changan_openc_car_id_get_params_t *p, const char *path_default,
+ bool with_form_content_type, char *resp_buf, uint32_t resp_cap);
+static int changan_http_fc_get_receiver_informations_v2_do_sync(
+ const changan_fc_get_receiver_informations_v2_params_t *p, char *resp_buf, uint32_t resp_cap);
+
+static uint32_t changan_http_cd_response_text_len(HttpClientData *cd, uint32_t resp_cap);
+static void changan_http_apply_cd_body_to_resp(HttpClientData *cd, char *resp_buf, uint32_t resp_cap);
+static uint32_t changan_http_heap_text_content_len(const uint8_t *heap, uint32_t cap);
+
+static int changan_http_worker_init(void);
+static int changan_http_job_dispatch(changan_http_job_t *job);
+
+static bool changan_dkey_file_read_trimmed(const char *path, char *out, uint32_t cap);
+
+void changan_http_result_destroy(changan_http_result_t *res)
+{
+ if (res == NULL) {
+ return;
+ }
+ free(res->body);
+ res->body = NULL;
+ free(res);
+}
+
+static void changan_oauth_token_params_heap_free(changan_oauth_token_params_t *p);
+static void changan_carlist_params_heap_free(changan_get_car_list_by_brand_params_t *p);
+static void changan_openc_car_id_get_params_heap_free(changan_openc_car_id_get_params_t *p);
+static void changan_fc_rcv_params_heap_free(changan_fc_get_receiver_informations_v2_params_t *p);
+static void changan_qr_gen_params_heap_free(changan_qrcode_generate_v1_params_t *p);
+static void changan_qr_st_params_heap_free(changan_qrcode_status_no_backend_v1_params_t *p);
+static void changan_dkey_reg_params_heap_free(changan_dkey_public_key_register_params_t *p);
+static void changan_dkey_dl_params_heap_free(changan_dkey_download_owner_key_params_t *p);
+static void changan_http_vrtm_params_heap_free(changan_vrtm_car_control_v2_params_t *p);
+
+static char *changan_http_strdup_nonnull(const char *s)
+{
+ size_t n;
+ char *d;
+
+ if (s == NULL) {
+ return NULL;
+ }
+ n = strlen(s) + 1U;
+ d = (char *)malloc(n);
+ if (d == NULL) {
+ return NULL;
+ }
+ (void)memcpy(d, s, n);
+ return d;
+}
+
+static changan_oauth_token_params_t *changan_oauth_token_params_heap_clone(const changan_oauth_token_params_t *p)
+{
+ changan_oauth_token_params_t *q;
+
+ if (p == NULL) {
+ return NULL;
+ }
+ q = (changan_oauth_token_params_t *)calloc(1, sizeof(*q));
+ if (q == NULL) {
+ return NULL;
+ }
+ q->grant_type = p->grant_type;
+ q->client_id = changan_http_strdup_nonnull(p->client_id);
+ q->client_secret = changan_http_strdup_nonnull(p->client_secret);
+ q->code = changan_http_strdup_nonnull(p->code);
+ q->redirect_uri = changan_http_strdup_nonnull(p->redirect_uri);
+ q->refresh_token = changan_http_strdup_nonnull(p->refresh_token);
+ return q;
+}
+
+static void changan_oauth_token_params_heap_free(changan_oauth_token_params_t *p)
+{
+ if (p == NULL) {
+ return;
+ }
+ free((void *)p->client_id);
+ free((void *)p->client_secret);
+ free((void *)p->code);
+ free((void *)p->redirect_uri);
+ free((void *)p->refresh_token);
+ free(p);
+}
+
+static changan_get_car_list_by_brand_params_t *changan_carlist_params_heap_clone(const changan_get_car_list_by_brand_params_t *p)
+{
+ changan_get_car_list_by_brand_params_t *q;
+
+ if (p == NULL) {
+ return NULL;
+ }
+ q = (changan_get_car_list_by_brand_params_t *)calloc(1, sizeof(*q));
+ if (q == NULL) {
+ return NULL;
+ }
+ q->print_control_car_sign_debug = p->print_control_car_sign_debug;
+ if (p->oauth_bootstrap != NULL) {
+ q->oauth_bootstrap = changan_oauth_token_params_heap_clone(p->oauth_bootstrap);
+ if (q->oauth_bootstrap == NULL) {
+ free(q);
+ return NULL;
+ }
+ }
+ if (p->access_token != NULL) {
+ q->access_token = changan_http_strdup_nonnull(p->access_token);
+ if (q->access_token == NULL) {
+ goto fail;
+ }
+ }
+ if (p->secret_key != NULL) {
+ q->secret_key = changan_http_strdup_nonnull(p->secret_key);
+ if (q->secret_key == NULL) {
+ goto fail;
+ }
+ }
+ if (p->brand_code != NULL) {
+ q->brand_code = changan_http_strdup_nonnull(p->brand_code);
+ if (q->brand_code == NULL) {
+ goto fail;
+ }
+ }
+ if (p->timestamp_sec != NULL) {
+ q->timestamp_sec = changan_http_strdup_nonnull(p->timestamp_sec);
+ if (q->timestamp_sec == NULL) {
+ goto fail;
+ }
+ }
+ if (p->nonce != NULL) {
+ q->nonce = changan_http_strdup_nonnull(p->nonce);
+ if (q->nonce == NULL) {
+ goto fail;
+ }
+ }
+ if (p->api_path != NULL) {
+ q->api_path = changan_http_strdup_nonnull(p->api_path);
+ if (q->api_path == NULL) {
+ goto fail;
+ }
+ }
+ return q;
+fail:
+ changan_carlist_params_heap_free(q);
+ return NULL;
+}
+
+static void changan_carlist_params_heap_free(changan_get_car_list_by_brand_params_t *p)
+{
+ if (p == NULL) {
+ return;
+ }
+ if (p->oauth_bootstrap != NULL) {
+ changan_oauth_token_params_heap_free((changan_oauth_token_params_t *)p->oauth_bootstrap);
+ }
+ free((void *)p->access_token);
+ free((void *)p->secret_key);
+ free((void *)p->brand_code);
+ free((void *)p->timestamp_sec);
+ free((void *)p->nonce);
+ free((void *)p->api_path);
+ free(p);
+}
+
+static changan_openc_car_id_get_params_t *changan_openc_car_id_get_params_heap_clone(const changan_openc_car_id_get_params_t *p)
+{
+ changan_openc_car_id_get_params_t *q;
+
+ if (p == NULL || p->car_id == NULL || p->car_id[0] == '\0') {
+ return NULL;
+ }
+ q = (changan_openc_car_id_get_params_t *)calloc(1, sizeof(*q));
+ if (q == NULL) {
+ return NULL;
+ }
+ q->timestamp_ms = p->timestamp_ms;
+ if (p->oauth_bootstrap != NULL) {
+ q->oauth_bootstrap = changan_oauth_token_params_heap_clone(p->oauth_bootstrap);
+ if (q->oauth_bootstrap == NULL) {
+ free(q);
+ return NULL;
+ }
+ }
+ q->car_id = changan_http_strdup_nonnull(p->car_id);
+ if (q->car_id == NULL) {
+ goto fail;
+ }
+ if (p->access_token != NULL) {
+ q->access_token = changan_http_strdup_nonnull(p->access_token);
+ if (q->access_token == NULL) {
+ goto fail;
+ }
+ }
+ if (p->secret_key != NULL) {
+ q->secret_key = changan_http_strdup_nonnull(p->secret_key);
+ if (q->secret_key == NULL) {
+ goto fail;
+ }
+ }
+ if (p->timestamp != NULL) {
+ q->timestamp = changan_http_strdup_nonnull(p->timestamp);
+ if (q->timestamp == NULL) {
+ goto fail;
+ }
+ }
+ if (p->nonce != NULL) {
+ q->nonce = changan_http_strdup_nonnull(p->nonce);
+ if (q->nonce == NULL) {
+ goto fail;
+ }
+ }
+ if (p->api_path != NULL) {
+ q->api_path = changan_http_strdup_nonnull(p->api_path);
+ if (q->api_path == NULL) {
+ goto fail;
+ }
+ }
+ return q;
+fail:
+ changan_openc_car_id_get_params_heap_free(q);
+ return NULL;
+}
+
+static void changan_openc_car_id_get_params_heap_free(changan_openc_car_id_get_params_t *p)
+{
+ if (p == NULL) {
+ return;
+ }
+ if (p->oauth_bootstrap != NULL) {
+ changan_oauth_token_params_heap_free((changan_oauth_token_params_t *)p->oauth_bootstrap);
+ }
+ free((void *)p->car_id);
+ free((void *)p->access_token);
+ free((void *)p->secret_key);
+ free((void *)p->timestamp);
+ free((void *)p->nonce);
+ free((void *)p->api_path);
+ free(p);
+}
+
+static changan_fc_get_receiver_informations_v2_params_t *changan_fc_rcv_params_heap_clone(
+ const changan_fc_get_receiver_informations_v2_params_t *p)
+{
+ changan_fc_get_receiver_informations_v2_params_t *q;
+
+ if (p == NULL || p->track_user_id == NULL || p->track_user_id[0] == '\0') {
+ return NULL;
+ }
+ q = (changan_fc_get_receiver_informations_v2_params_t *)calloc(1, sizeof(*q));
+ if (q == NULL) {
+ return NULL;
+ }
+ q->timestamp_ms = p->timestamp_ms;
+ if (p->oauth_bootstrap != NULL) {
+ q->oauth_bootstrap = changan_oauth_token_params_heap_clone(p->oauth_bootstrap);
+ if (q->oauth_bootstrap == NULL) {
+ free(q);
+ return NULL;
+ }
+ }
+#define CHANGAN_HTTP_SDUP_FC(f) \
+ do { \
+ if (p->f != NULL) { \
+ q->f = changan_http_strdup_nonnull(p->f); \
+ if (q->f == NULL) { \
+ goto fc_fail; \
+ } \
+ } \
+ } while (0)
+ CHANGAN_HTTP_SDUP_FC(access_token);
+ CHANGAN_HTTP_SDUP_FC(secret_key);
+ CHANGAN_HTTP_SDUP_FC(timestamp);
+ CHANGAN_HTTP_SDUP_FC(nonce);
+ CHANGAN_HTTP_SDUP_FC(api_path);
+ CHANGAN_HTTP_SDUP_FC(track_user_id);
+ CHANGAN_HTTP_SDUP_FC(action_type);
+ CHANGAN_HTTP_SDUP_FC(real_receiver_id);
+ CHANGAN_HTTP_SDUP_FC(trunk_full_path);
+ CHANGAN_HTTP_SDUP_FC(page);
+ CHANGAN_HTTP_SDUP_FC(limit);
+#undef CHANGAN_HTTP_SDUP_FC
+ return q;
+fc_fail:
+ changan_fc_rcv_params_heap_free(q);
+ return NULL;
+}
+
+static void changan_fc_rcv_params_heap_free(changan_fc_get_receiver_informations_v2_params_t *p)
+{
+ if (p == NULL) {
+ return;
+ }
+ if (p->oauth_bootstrap != NULL) {
+ changan_oauth_token_params_heap_free((changan_oauth_token_params_t *)p->oauth_bootstrap);
+ }
+ free((void *)p->access_token);
+ free((void *)p->secret_key);
+ free((void *)p->timestamp);
+ free((void *)p->nonce);
+ free((void *)p->api_path);
+ free((void *)p->track_user_id);
+ free((void *)p->action_type);
+ free((void *)p->real_receiver_id);
+ free((void *)p->trunk_full_path);
+ free((void *)p->page);
+ free((void *)p->limit);
+ free(p);
+}
+
+static changan_qrcode_generate_v1_params_t *changan_qr_gen_params_heap_clone(const changan_qrcode_generate_v1_params_t *p)
+{
+ changan_qrcode_generate_v1_params_t *q;
+
+ if (p == NULL) {
+ return NULL;
+ }
+ q = (changan_qrcode_generate_v1_params_t *)calloc(1, sizeof(*q));
+ if (q == NULL) {
+ return NULL;
+ }
+ q->exclude_app_code_from_sign = p->exclude_app_code_from_sign;
+#define CHANGAN_HTTP_SDUP_QRG(f) \
+ do { \
+ if (p->f != NULL) { \
+ q->f = changan_http_strdup_nonnull(p->f); \
+ if (q->f == NULL) { \
+ goto qrg_fail; \
+ } \
+ } \
+ } while (0)
+ CHANGAN_HTTP_SDUP_QRG(client_id);
+ CHANGAN_HTTP_SDUP_QRG(nonce);
+ CHANGAN_HTTP_SDUP_QRG(size);
+ CHANGAN_HTTP_SDUP_QRG(state);
+ CHANGAN_HTTP_SDUP_QRG(timestamp_ms);
+ CHANGAN_HTTP_SDUP_QRG(app_key);
+ CHANGAN_HTTP_SDUP_QRG(app_code);
+#undef CHANGAN_HTTP_SDUP_QRG
+ return q;
+qrg_fail:
+ changan_qr_gen_params_heap_free(q);
+ return NULL;
+}
+
+static void changan_qr_gen_params_heap_free(changan_qrcode_generate_v1_params_t *p)
+{
+ if (p == NULL) {
+ return;
+ }
+ free((void *)p->client_id);
+ free((void *)p->nonce);
+ free((void *)p->size);
+ free((void *)p->state);
+ free((void *)p->timestamp_ms);
+ free((void *)p->app_key);
+ free((void *)p->app_code);
+ free(p);
+}
+
+static changan_qrcode_status_no_backend_v1_params_t *changan_qr_st_params_heap_clone(
+ const changan_qrcode_status_no_backend_v1_params_t *p)
+{
+ changan_qrcode_status_no_backend_v1_params_t *q;
+
+ if (p == NULL) {
+ return NULL;
+ }
+ q = (changan_qrcode_status_no_backend_v1_params_t *)calloc(1, sizeof(*q));
+ if (q == NULL) {
+ return NULL;
+ }
+ q->no_app_key = p->no_app_key;
+ q->nonce = changan_http_strdup_nonnull(p->nonce);
+ q->timestamp_sec = changan_http_strdup_nonnull(p->timestamp_sec);
+ q->qrcode_id = changan_http_strdup_nonnull(p->qrcode_id);
+ q->app_key = changan_http_strdup_nonnull(p->app_key);
+ if (q->nonce == NULL || q->qrcode_id == NULL) {
+ goto qrs_fail;
+ }
+ return q;
+qrs_fail:
+ changan_qr_st_params_heap_free(q);
+ return NULL;
+}
+
+static void changan_qr_st_params_heap_free(changan_qrcode_status_no_backend_v1_params_t *p)
+{
+ if (p == NULL) {
+ return;
+ }
+ free((void *)p->nonce);
+ free((void *)p->timestamp_sec);
+ free((void *)p->qrcode_id);
+ free((void *)p->app_key);
+ free(p);
+}
+
+static changan_dkey_public_key_register_params_t *changan_dkey_reg_params_heap_clone(const changan_dkey_public_key_register_params_t *p)
+{
+ changan_dkey_public_key_register_params_t *q;
+
+ if (p == NULL) {
+ return NULL;
+ }
+ q = (changan_dkey_public_key_register_params_t *)calloc(1, sizeof(*q));
+ if (q == NULL) {
+ return NULL;
+ }
+ q->timestamp_ms = p->timestamp_ms;
+ if (p->oauth_bootstrap != NULL) {
+ q->oauth_bootstrap = changan_oauth_token_params_heap_clone(p->oauth_bootstrap);
+ if (q->oauth_bootstrap == NULL) {
+ free(q);
+ return NULL;
+ }
+ }
+#define CHANGAN_HTTP_SDUP_DREG(f) \
+ do { \
+ if (p->f != NULL) { \
+ q->f = changan_http_strdup_nonnull(p->f); \
+ if (q->f == NULL) { \
+ goto dreg_fail; \
+ } \
+ } \
+ } while (0)
+ CHANGAN_HTTP_SDUP_DREG(access_token);
+ CHANGAN_HTTP_SDUP_DREG(secret_key);
+ CHANGAN_HTTP_SDUP_DREG(timestamp);
+ CHANGAN_HTTP_SDUP_DREG(header_nonce);
+ CHANGAN_HTTP_SDUP_DREG(api_path);
+ CHANGAN_HTTP_SDUP_DREG(user_id);
+ CHANGAN_HTTP_SDUP_DREG(app_id);
+ CHANGAN_HTTP_SDUP_DREG(algorithm);
+ CHANGAN_HTTP_SDUP_DREG(public_key_spki_b64);
+#undef CHANGAN_HTTP_SDUP_DREG
+ return q;
+dreg_fail:
+ changan_dkey_reg_params_heap_free(q);
+ return NULL;
+}
+
+static void changan_dkey_reg_params_heap_free(changan_dkey_public_key_register_params_t *p)
+{
+ if (p == NULL) {
+ return;
+ }
+ if (p->oauth_bootstrap != NULL) {
+ changan_oauth_token_params_heap_free((changan_oauth_token_params_t *)p->oauth_bootstrap);
+ }
+ free((void *)p->access_token);
+ free((void *)p->secret_key);
+ free((void *)p->timestamp);
+ free((void *)p->header_nonce);
+ free((void *)p->api_path);
+ free((void *)p->user_id);
+ free((void *)p->app_id);
+ free((void *)p->algorithm);
+ free((void *)p->public_key_spki_b64);
+ free(p);
+}
+
+static changan_dkey_download_owner_key_params_t *changan_dkey_dl_params_heap_clone(const changan_dkey_download_owner_key_params_t *p)
+{
+ changan_dkey_download_owner_key_params_t *q;
+
+ if (p == NULL) {
+ return NULL;
+ }
+ q = (changan_dkey_download_owner_key_params_t *)calloc(1, sizeof(*q));
+ if (q == NULL) {
+ return NULL;
+ }
+ q->timestamp_ms = p->timestamp_ms;
+ q->protocol_type = p->protocol_type;
+ q->private_sign_exclude_protocol_type = p->private_sign_exclude_protocol_type;
+ q->protocol_type_json_number = p->protocol_type_json_number;
+ if (p->oauth_bootstrap != NULL) {
+ q->oauth_bootstrap = changan_oauth_token_params_heap_clone(p->oauth_bootstrap);
+ if (q->oauth_bootstrap == NULL) {
+ free(q);
+ return NULL;
+ }
+ }
+#define CHANGAN_HTTP_SDUP_DLD(f) \
+ do { \
+ if (p->f != NULL) { \
+ q->f = changan_http_strdup_nonnull(p->f); \
+ if (q->f == NULL) { \
+ goto dld_fail; \
+ } \
+ } \
+ } while (0)
+ CHANGAN_HTTP_SDUP_DLD(access_token);
+ CHANGAN_HTTP_SDUP_DLD(secret_key);
+ CHANGAN_HTTP_SDUP_DLD(timestamp);
+ CHANGAN_HTTP_SDUP_DLD(header_nonce);
+ CHANGAN_HTTP_SDUP_DLD(api_path);
+ CHANGAN_HTTP_SDUP_DLD(user_id);
+ CHANGAN_HTTP_SDUP_DLD(car_id);
+ CHANGAN_HTTP_SDUP_DLD(public_key_id);
+ CHANGAN_HTTP_SDUP_DLD(body_nonce);
+ CHANGAN_HTTP_SDUP_DLD(rsa_private_key_pem);
+#undef CHANGAN_HTTP_SDUP_DLD
+ return q;
+dld_fail:
+ changan_dkey_dl_params_heap_free(q);
+ return NULL;
+}
+
+static void changan_dkey_dl_params_heap_free(changan_dkey_download_owner_key_params_t *p)
+{
+ if (p == NULL) {
+ return;
+ }
+ if (p->oauth_bootstrap != NULL) {
+ changan_oauth_token_params_heap_free((changan_oauth_token_params_t *)p->oauth_bootstrap);
+ }
+ free((void *)p->access_token);
+ free((void *)p->secret_key);
+ free((void *)p->timestamp);
+ free((void *)p->header_nonce);
+ free((void *)p->api_path);
+ free((void *)p->user_id);
+ free((void *)p->car_id);
+ free((void *)p->public_key_id);
+ free((void *)p->body_nonce);
+ free((void *)p->rsa_private_key_pem);
+ free(p);
+}
+
+static void changan_http_vrtm_params_heap_free(changan_vrtm_car_control_v2_params_t *p)
+{
+ if (p == NULL) {
+ return;
+ }
+ if (p->oauth_bootstrap != NULL) {
+ changan_oauth_token_params_heap_free((changan_oauth_token_params_t *)p->oauth_bootstrap);
+ }
+ free((void *)p->car_id);
+ free((void *)p->map_args_json);
+ free((void *)p->sender_type);
+ free((void *)p->access_token);
+ free((void *)p->secret_key);
+ free((void *)p->timestamp);
+ free((void *)p->nonce);
+ free((void *)p->api_path);
+ free((void *)p->body_cmd_override);
+}
+
+static changan_vrtm_car_control_v2_params_t *changan_http_vrtm_params_heap_clone(const changan_vrtm_car_control_v2_params_t *p)
+{
+ changan_vrtm_car_control_v2_params_t *q;
+ const char *map_u;
+ const char *snd_u;
+
+ if (p == NULL || p->car_id == NULL || p->car_id[0] == '\0') {
+ return NULL;
+ }
+ q = (changan_vrtm_car_control_v2_params_t *)calloc(1, sizeof(*q));
+ if (q == NULL) {
+ return NULL;
+ }
+ q->timestamp_ms = p->timestamp_ms;
+ q->command = p->command;
+ if (p->oauth_bootstrap != NULL) {
+ q->oauth_bootstrap = changan_oauth_token_params_heap_clone(p->oauth_bootstrap);
+ if (q->oauth_bootstrap == NULL) {
+ free(q);
+ return NULL;
+ }
+ } else {
+ q->oauth_bootstrap = NULL;
+ }
+
+ map_u = (p->map_args_json != NULL && p->map_args_json[0] != '\0') ? p->map_args_json : "{}";
+ snd_u = (p->sender_type != NULL && p->sender_type[0] != '\0') ? p->sender_type : "APP";
+
+ q->car_id = changan_http_strdup_nonnull(p->car_id);
+ q->map_args_json = changan_http_strdup_nonnull(map_u);
+ q->sender_type = changan_http_strdup_nonnull(snd_u);
+ if (q->car_id == NULL || q->map_args_json == NULL || q->sender_type == NULL) {
+ changan_http_vrtm_params_heap_free(q);
+ free(q);
+ return NULL;
+ }
+
+ if (p->access_token != NULL && p->access_token[0] != '\0') {
+ q->access_token = changan_http_strdup_nonnull(p->access_token);
+ if (q->access_token == NULL) {
+ changan_http_vrtm_params_heap_free(q);
+ free(q);
+ return NULL;
+ }
+ }
+ if (p->secret_key != NULL && p->secret_key[0] != '\0') {
+ q->secret_key = changan_http_strdup_nonnull(p->secret_key);
+ if (q->secret_key == NULL) {
+ changan_http_vrtm_params_heap_free(q);
+ free(q);
+ return NULL;
+ }
+ }
+ if (p->timestamp != NULL && p->timestamp[0] != '\0') {
+ q->timestamp = changan_http_strdup_nonnull(p->timestamp);
+ if (q->timestamp == NULL) {
+ changan_http_vrtm_params_heap_free(q);
+ free(q);
+ return NULL;
+ }
+ }
+ if (p->nonce != NULL && p->nonce[0] != '\0') {
+ q->nonce = changan_http_strdup_nonnull(p->nonce);
+ if (q->nonce == NULL) {
+ changan_http_vrtm_params_heap_free(q);
+ free(q);
+ return NULL;
+ }
+ }
+ if (p->api_path != NULL && p->api_path[0] != '\0') {
+ q->api_path = changan_http_strdup_nonnull(p->api_path);
+ if (q->api_path == NULL) {
+ changan_http_vrtm_params_heap_free(q);
+ free(q);
+ return NULL;
+ }
+ }
+ if (p->body_cmd_override != NULL && p->body_cmd_override[0] != '\0') {
+ q->body_cmd_override = changan_http_strdup_nonnull(p->body_cmd_override);
+ if (q->body_cmd_override == NULL) {
+ changan_http_vrtm_params_heap_free(q);
+ free(q);
+ return NULL;
+ }
+ }
+ return q;
+}
+
+static void changan_http_job_free_buffers(changan_http_job_t *job)
+{
+ if (job == NULL) {
+ return;
+ }
+ switch (job->kind) {
+ case CHANGAN_HTTP_JK_COMMON:
+ free(job->u.co.resp_heap);
+ if (job->u.co.owns_url) {
+ free(job->u.co.url);
+ }
+ if (job->u.co.owns_ctype) {
+ free(job->u.co.content_type);
+ }
+ if (job->u.co.owns_post_buf != 0) {
+ free(job->u.co.post_buf);
+ }
+ break;
+ case CHANGAN_HTTP_JK_OAUTH:
+ if (job->u.oauth.params != NULL) {
+ changan_oauth_token_params_heap_free((changan_oauth_token_params_t *)job->u.oauth.params);
+ free((void *)job->u.oauth.params);
+ job->u.oauth.params = NULL;
+ }
+ free(job->u.oauth.resp_heap);
+ break;
+ case CHANGAN_HTTP_JK_CARLIST:
+ if (job->u.carlist.params != NULL) {
+ changan_carlist_params_heap_free((changan_get_car_list_by_brand_params_t *)job->u.carlist.params);
+ free((void *)job->u.carlist.params);
+ job->u.carlist.params = NULL;
+ }
+ free(job->u.carlist.resp_heap);
+ break;
+ case CHANGAN_HTTP_JK_CC_POST:
+ free(job->u.cc.url);
+ free(job->u.cc.req_hdr);
+ free(job->u.cc.body);
+ free(job->u.cc.resp_heap);
+ break;
+ case CHANGAN_HTTP_JK_VRTM:
+ if (job->u.vrtm.params != NULL) {
+ changan_http_vrtm_params_heap_free((changan_vrtm_car_control_v2_params_t *)job->u.vrtm.params);
+ free((void *)job->u.vrtm.params);
+ job->u.vrtm.params = NULL;
+ }
+ free(job->u.vrtm.resp_heap);
+ break;
+ case CHANGAN_HTTP_JK_QR_GEN:
+ if (job->u.qr_gen.params != NULL) {
+ changan_qr_gen_params_heap_free((changan_qrcode_generate_v1_params_t *)job->u.qr_gen.params);
+ free((void *)job->u.qr_gen.params);
+ job->u.qr_gen.params = NULL;
+ }
+ free(job->u.qr_gen.resp_heap);
+ break;
+ case CHANGAN_HTTP_JK_QR_ST:
+ if (job->u.qr_st.params != NULL) {
+ changan_qr_st_params_heap_free((changan_qrcode_status_no_backend_v1_params_t *)job->u.qr_st.params);
+ free((void *)job->u.qr_st.params);
+ job->u.qr_st.params = NULL;
+ }
+ free(job->u.qr_st.resp_heap);
+ break;
+ case CHANGAN_HTTP_JK_DKEY_REG:
+ if (job->u.dreg.p != NULL) {
+ changan_dkey_reg_params_heap_free((changan_dkey_public_key_register_params_t *)job->u.dreg.p);
+ free((void *)job->u.dreg.p);
+ job->u.dreg.p = NULL;
+ }
+ free(job->u.dreg.resp_heap);
+ break;
+ case CHANGAN_HTTP_JK_DKEY_DL:
+ if (job->u.dld.p != NULL) {
+ changan_dkey_dl_params_heap_free((changan_dkey_download_owner_key_params_t *)job->u.dld.p);
+ free((void *)job->u.dld.p);
+ job->u.dld.p = NULL;
+ }
+ free(job->u.dld.resp_heap);
+ break;
+ case CHANGAN_HTTP_JK_OPENC_CARID_GET:
+ if (job->u.openc_cid.params != NULL) {
+ changan_openc_car_id_get_params_heap_free((changan_openc_car_id_get_params_t *)job->u.openc_cid.params);
+ free((void *)job->u.openc_cid.params);
+ job->u.openc_cid.params = NULL;
+ }
+ free(job->u.openc_cid.resp_heap);
+ break;
+ case CHANGAN_HTTP_JK_FC_RECEIVER_INFO:
+ if (job->u.fc_rcv.params != NULL) {
+ changan_fc_rcv_params_heap_free((changan_fc_get_receiver_informations_v2_params_t *)job->u.fc_rcv.params);
+ free((void *)job->u.fc_rcv.params);
+ job->u.fc_rcv.params = NULL;
+ }
+ free(job->u.fc_rcv.resp_heap);
+ break;
+ default:
+ break;
+ }
+}
+
+static int changan_http_result_copy_body(changan_http_result_t *res, const void *src, uint32_t len, bool is_binary)
+{
+ uint32_t alloc = len + (is_binary ? 0U : 1U);
+
+ if (res == NULL || (len > 0U && src == NULL)) {
+ return -1;
+ }
+ res->body = NULL;
+ res->body_len = len;
+ res->body_is_binary = is_binary;
+ if (len == 0U) {
+ return 0;
+ }
+ res->body = (uint8_t *)malloc((size_t)alloc);
+ if (res->body == NULL) {
+ return -1;
+ }
+ if (memcpy_s(res->body, (size_t)alloc, src, (size_t)len) != 0) {
+ free(res->body);
+ res->body = NULL;
+ return -1;
+ }
+ if (!is_binary) {
+ res->body[len] = '\0';
+ }
+ return 0;
+}
+
+/** job->resp_heap 文本正文长度:遇 NUL 则不含尾零;整缓冲无 NUL 时按 JSON 尾 '}' 截断,避免 malloc 未清零尾部进入 build_result */
+static uint32_t changan_http_heap_text_content_len(const uint8_t *heap, uint32_t cap)
+{
+ uint32_t n;
+
+ if (heap == NULL || cap == 0U) {
+ return 0U;
+ }
+ n = (uint32_t)strnlen((const char *)heap, (size_t)cap);
+ if (n < cap) {
+ return n;
+ }
+ for (uint32_t i = cap; i > 0U; i--) {
+ if (heap[i - 1U] == (uint8_t)'}') {
+ return i;
+ }
+ }
+ return 0U;
+}
+
+static changan_http_result_t *changan_http_build_result_from_job(const changan_http_job_t *job, int http_code)
+{
+ changan_http_result_t *res = (changan_http_result_t *)calloc(1, sizeof(changan_http_result_t));
+
+ if (res == NULL || job == NULL) {
+ return NULL;
+ }
+ res->type = job->req_type;
+ res->http_code = http_code;
+ switch (job->kind) {
+ case CHANGAN_HTTP_JK_COMMON:
+ if (job->u.co.resp_heap != NULL && job->u.co.resp_cap > 0U) {
+ uint32_t n = changan_http_heap_text_content_len(job->u.co.resp_heap, job->u.co.resp_cap);
+
+ if (n > 0U) {
+ (void)changan_http_result_copy_body(res, job->u.co.resp_heap, n, false);
+ }
+ }
+ break;
+ case CHANGAN_HTTP_JK_OAUTH:
+ if (job->u.oauth.resp_heap != NULL && job->u.oauth.resp_cap > 0U) {
+ uint32_t n = changan_http_heap_text_content_len(job->u.oauth.resp_heap, job->u.oauth.resp_cap);
+
+ if (n > 0U) {
+ (void)changan_http_result_copy_body(res, job->u.oauth.resp_heap, n, false);
+ }
+ }
+ break;
+ case CHANGAN_HTTP_JK_CARLIST:
+ if (job->u.carlist.resp_heap != NULL && job->u.carlist.resp_cap > 0U) {
+ uint32_t n = changan_http_heap_text_content_len(job->u.carlist.resp_heap, job->u.carlist.resp_cap);
+
+ if (n > 0U) {
+ (void)changan_http_result_copy_body(res, job->u.carlist.resp_heap, n, false);
+ }
+ }
+ break;
+ case CHANGAN_HTTP_JK_CC_POST:
+ if (job->u.cc.resp_heap != NULL && job->u.cc.resp_cap > 0U) {
+ uint32_t n = changan_http_heap_text_content_len(job->u.cc.resp_heap, job->u.cc.resp_cap);
+
+ if (n > 0U) {
+ (void)changan_http_result_copy_body(res, job->u.cc.resp_heap, n, false);
+ }
+ }
+ break;
+ case CHANGAN_HTTP_JK_VRTM:
+ if (job->u.vrtm.resp_heap != NULL && job->u.vrtm.resp_cap > 0U) {
+ uint32_t n = changan_http_heap_text_content_len(job->u.vrtm.resp_heap, job->u.vrtm.resp_cap);
+
+ if (n > 0U) {
+ (void)changan_http_result_copy_body(res, job->u.vrtm.resp_heap, n, false);
+ }
+ }
+ break;
+ case CHANGAN_HTTP_JK_QR_GEN:
+ if (job->u.qr_gen.resp_heap != NULL && job->u.qr_gen.out_body_len > 0U) {
+ bool is_png = job->u.qr_gen.out_body_len >= 8U && job->u.qr_gen.resp_heap[0] == 0x89U &&
+ job->u.qr_gen.resp_heap[1] == 'P' && job->u.qr_gen.resp_heap[2] == 'N' && job->u.qr_gen.resp_heap[3] == 'G';
+
+ (void)changan_http_result_copy_body(res, job->u.qr_gen.resp_heap, job->u.qr_gen.out_body_len, is_png);
+ }
+ if (job->u.qr_gen.qrcode_id_buf[0] != '\0') {
+ size_t idl = strnlen(job->u.qr_gen.qrcode_id_buf, sizeof(job->u.qr_gen.qrcode_id_buf));
+
+ if (idl >= sizeof(res->qrcode_id)) {
+ idl = sizeof(res->qrcode_id) - 1U;
+ }
+ (void)memcpy_s(res->qrcode_id, sizeof(res->qrcode_id), job->u.qr_gen.qrcode_id_buf, idl);
+ res->qrcode_id[idl] = '\0';
+ }
+ break;
+ case CHANGAN_HTTP_JK_QR_ST:
+ if (job->u.qr_st.resp_heap != NULL && job->u.qr_st.resp_cap > 0U) {
+ uint32_t n = changan_http_heap_text_content_len(job->u.qr_st.resp_heap, job->u.qr_st.resp_cap);
+
+ if (n > 0U) {
+ (void)changan_http_result_copy_body(res, job->u.qr_st.resp_heap, n, false);
+ }
+ }
+ break;
+ case CHANGAN_HTTP_JK_DKEY_REG:
+ if (job->u.dreg.resp_heap != NULL && job->u.dreg.resp_cap > 0U) {
+ uint32_t n = changan_http_heap_text_content_len(job->u.dreg.resp_heap, job->u.dreg.resp_cap);
+
+ if (n > 0U) {
+ (void)changan_http_result_copy_body(res, job->u.dreg.resp_heap, n, false);
+ }
+ }
+ if (job->u.dreg.public_key_id_buf[0] != '\0') {
+ size_t idl = strnlen(job->u.dreg.public_key_id_buf, sizeof(job->u.dreg.public_key_id_buf));
+
+ if (idl >= sizeof(res->public_key_id)) {
+ idl = sizeof(res->public_key_id) - 1U;
+ }
+ (void)memcpy_s(res->public_key_id, sizeof(res->public_key_id), job->u.dreg.public_key_id_buf, idl);
+ res->public_key_id[idl] = '\0';
+ }
+ break;
+ case CHANGAN_HTTP_JK_DKEY_DL:
+ if (job->u.dld.resp_heap != NULL && job->u.dld.resp_cap > 0U) {
+ uint32_t n = changan_http_heap_text_content_len(job->u.dld.resp_heap, job->u.dld.resp_cap);
+
+ if (n > 0U) {
+ (void)changan_http_result_copy_body(res, job->u.dld.resp_heap, n, false);
+ }
+ }
+ break;
+ case CHANGAN_HTTP_JK_OPENC_CARID_GET:
+ if (job->u.openc_cid.resp_heap != NULL && job->u.openc_cid.resp_cap > 0U) {
+ uint32_t n = changan_http_heap_text_content_len(job->u.openc_cid.resp_heap, job->u.openc_cid.resp_cap);
+
+ if (n > 0U) {
+ (void)changan_http_result_copy_body(res, job->u.openc_cid.resp_heap, n, false);
+ }
+ }
+ break;
+ case CHANGAN_HTTP_JK_FC_RECEIVER_INFO:
+ if (job->u.fc_rcv.resp_heap != NULL && job->u.fc_rcv.resp_cap > 0U) {
+ uint32_t n = changan_http_heap_text_content_len(job->u.fc_rcv.resp_heap, job->u.fc_rcv.resp_cap);
+
+ if (n > 0U) {
+ (void)changan_http_result_copy_body(res, job->u.fc_rcv.resp_heap, n, false);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+
+ /* 从 job 缓冲组装的 changan_http_result_t,便于与 [default] 对照排障 */
+ printf("[changan_http][build_result] kind=%d type=%d http=%d body_len=%u bin=%d\r\n", (int)job->kind,
+ (int)res->type, res->http_code, (unsigned)res->body_len, res->body_is_binary ? 1 : 0);
+ if (res->qrcode_id[0] != '\0') {
+ printf("[changan_http][build_result] qrcode_id=%s\r\n", res->qrcode_id);
+ }
+ if (res->public_key_id[0] != '\0') {
+ printf("[changan_http][build_result] public_key_id=%s\r\n", res->public_key_id);
+ }
+ if (res->body != NULL && res->body_len > 0U) {
+ if (res->body_is_binary) {
+ printf("[changan_http][build_result] body: binary first8=%02x%02x%02x%02x%02x%02x%02x%02x\r\n",
+ res->body_len >= 1U ? res->body[0] : 0U, res->body_len >= 2U ? res->body[1] : 0U,
+ res->body_len >= 3U ? res->body[2] : 0U, res->body_len >= 4U ? res->body[3] : 0U,
+ res->body_len >= 5U ? res->body[4] : 0U, res->body_len >= 6U ? res->body[5] : 0U,
+ res->body_len >= 7U ? res->body[6] : 0U, res->body_len >= 8U ? res->body[7] : 0U);
+ } else {
+ const char *txt = (const char *)(const void *)res->body;
+ uint32_t preview = res->body_len;
+
+ if (preview > 512U) {
+ preview = 512U;
+ }
+ printf("[changan_http][build_result] body(text) len=%u preview: %.*s%s\r\n", (unsigned)res->body_len,
+ (int)preview, txt, res->body_len > preview ? "..." : "");
+ }
+ }
+
+ return res;
+}
+
+/* ---------- DKEY:按车 ensure(注册 → default 内链式 download) ---------- */
+
+#ifndef CHANGAN_HTTP_DKEY_CAR_ID_CAP
+#define CHANGAN_HTTP_DKEY_CAR_ID_CAP 80U
+#endif
+#ifndef CHANGAN_HTTP_DKEY_ENSURE_USER_ID_CAP
+#define CHANGAN_HTTP_DKEY_ENSURE_USER_ID_CAP 96U
+#endif
+#ifndef CHANGAN_DKEY_STORE_PRIVATE_PEM_PATH
+#define CHANGAN_DKEY_STORE_PRIVATE_PEM_PATH "/user/changan_dkey_private.pem"
+#endif
+#ifndef CHANGAN_DKEY_STORE_SPKI_B64_PATH
+#define CHANGAN_DKEY_STORE_SPKI_B64_PATH "/user/changan_dkey_spki.b64"
+#endif
+
+static changan_dkey_download_owner_key_params_t g_changan_dkey_ensure_dl;
+static changan_dkey_public_key_register_params_t g_changan_dkey_ensure_reg_params;
+static char g_changan_dkey_ensure_oauth_access[CHANGAN_HTTP_OAUTH_STORE_ACCESS_TOKEN_MAX];
+static char g_changan_dkey_ensure_oauth_secret[CHANGAN_HTTP_OAUTH_STORE_SECRET_KEY_MAX];
+static char g_changan_dkey_ensure_car_id[CHANGAN_HTTP_DKEY_CAR_ID_CAP];
+static char g_changan_dkey_ensure_user_id[CHANGAN_HTTP_DKEY_ENSURE_USER_ID_CAP];
+static char g_changan_dkey_ensure_public_key_id[CHANGAN_HTTP_PUBLIC_KEY_ID_MAX];
+static char g_changan_dkey_ensure_body_nonce[32];
+static char g_changan_dkey_ensure_api_path_reg[384];
+static char g_changan_dkey_ensure_api_path_dl[384];
+static volatile uint8_t g_changan_dkey_ensure_pending;
+static volatile uint8_t g_changan_dkey_ensure_decrypt_use_car_id;
+static changan_http_result_cb_t g_changan_dkey_ensure_dl_done_cb;
+static void *g_changan_dkey_ensure_dl_done_ud;
+
+static void changan_dkey_ensure_download_noop_cb(void *ud, const changan_http_result_t *r)
+{
+ (void)ud;
+ (void)r;
+}
+
+static bool changan_dkey_local_spki_b64_file_nonempty(void)
+{
+ char buf[128];
+
+ return changan_dkey_file_read_trimmed(CHANGAN_DKEY_STORE_SPKI_B64_PATH, buf, (uint32_t)sizeof(buf));
+}
+
+static bool changan_dkey_local_private_pem_file_nonempty(void)
+{
+ char buf[256];
+
+ return changan_dkey_file_read_trimmed(CHANGAN_DKEY_STORE_PRIVATE_PEM_PATH, buf, (uint32_t)sizeof(buf));
+}
+
+static int changan_dkey_ensure_prepare_from_params(const changan_http_dkey_ensure_owner_key_params_t *params)
+{
+ int nc;
+ int nu;
+ int proto;
+ const char *uid_eff;
+ const char *reg_use;
+ const char *dl_use;
+
+ if (params == NULL || params->vehicle_car_id == NULL || params->vehicle_car_id[0] == '\0') {
+ return -1;
+ }
+ changan_oauth_try_load_from_disk();
+ if (!changan_http_oauth_get_stored_access_token(g_changan_dkey_ensure_oauth_access,
+ (uint32_t)sizeof(g_changan_dkey_ensure_oauth_access)) ||
+ !changan_http_oauth_get_stored_secret_key(g_changan_dkey_ensure_oauth_secret,
+ (uint32_t)sizeof(g_changan_dkey_ensure_oauth_secret))) {
+ printf("[changan_http][dkey_ensure] oauth cache missing access_token or secret_key\r\n");
+ return CHANGAN_HTTP_DKEY_ENSURE_ERR_MISSING_OAUTH;
+ }
+ uid_eff = (params->user_id != NULL && params->user_id[0] != '\0') ? params->user_id :
+ g_changan_http_oauth_last_token.uid;
+ if (uid_eff == NULL || uid_eff[0] == '\0') {
+ printf("[changan_http][dkey_ensure] user_id missing (param empty and oauth uid empty)\r\n");
+ return -1;
+ }
+ nc = snprintf(g_changan_dkey_ensure_car_id, sizeof(g_changan_dkey_ensure_car_id), "%s", params->vehicle_car_id);
+ nu = snprintf(g_changan_dkey_ensure_user_id, sizeof(g_changan_dkey_ensure_user_id), "%s", uid_eff);
+ if (nc <= 0 || nu <= 0 || (size_t)nc >= sizeof(g_changan_dkey_ensure_car_id) ||
+ (size_t)nu >= sizeof(g_changan_dkey_ensure_user_id)) {
+ return -1;
+ }
+ g_changan_dkey_ensure_public_key_id[0] = '\0';
+ proto = (params->protocol_type != 0) ? params->protocol_type : 1;
+ reg_use = NULL;
+ dl_use = NULL;
+ if (params->api_path_register != NULL && params->api_path_register[0] != '\0') {
+ int nr = snprintf(g_changan_dkey_ensure_api_path_reg, sizeof(g_changan_dkey_ensure_api_path_reg), "%s",
+ params->api_path_register);
+
+ if (nr <= 0 || (size_t)nr >= sizeof(g_changan_dkey_ensure_api_path_reg)) {
+ return -1;
+ }
+ reg_use = g_changan_dkey_ensure_api_path_reg;
+ }
+ if (params->api_path_download != NULL && params->api_path_download[0] != '\0') {
+ int nd = snprintf(g_changan_dkey_ensure_api_path_dl, sizeof(g_changan_dkey_ensure_api_path_dl), "%s",
+ params->api_path_download);
+
+ if (nd <= 0 || (size_t)nd >= sizeof(g_changan_dkey_ensure_api_path_dl)) {
+ return -1;
+ }
+ dl_use = g_changan_dkey_ensure_api_path_dl;
+ }
+
+ (void)memset(&g_changan_dkey_ensure_dl, 0, sizeof(g_changan_dkey_ensure_dl));
+ g_changan_dkey_ensure_dl.access_token = g_changan_dkey_ensure_oauth_access;
+ g_changan_dkey_ensure_dl.secret_key = g_changan_dkey_ensure_oauth_secret;
+ g_changan_dkey_ensure_dl.oauth_bootstrap = NULL;
+ g_changan_dkey_ensure_dl.timestamp_ms = false;
+ g_changan_dkey_ensure_dl.timestamp = NULL;
+ g_changan_dkey_ensure_dl.header_nonce = NULL;
+ g_changan_dkey_ensure_dl.api_path = dl_use;
+ g_changan_dkey_ensure_dl.user_id = g_changan_dkey_ensure_user_id;
+ g_changan_dkey_ensure_dl.car_id = g_changan_dkey_ensure_car_id;
+ g_changan_dkey_ensure_dl.public_key_id = g_changan_dkey_ensure_public_key_id;
+ if (params->body_nonce != NULL && params->body_nonce[0] != '\0') {
+ int nb = snprintf(g_changan_dkey_ensure_body_nonce, sizeof(g_changan_dkey_ensure_body_nonce), "%s",
+ params->body_nonce);
+
+ if (nb <= 0 || (size_t)nb >= sizeof(g_changan_dkey_ensure_body_nonce)) {
+ return -1;
+ }
+ g_changan_dkey_ensure_dl.body_nonce = g_changan_dkey_ensure_body_nonce;
+ } else {
+ g_changan_dkey_ensure_dl.body_nonce = NULL;
+ }
+ g_changan_dkey_ensure_dl.protocol_type = proto;
+ g_changan_dkey_ensure_dl.private_sign_exclude_protocol_type = params->private_sign_exclude_protocol_type;
+ g_changan_dkey_ensure_dl.protocol_type_json_number = params->protocol_type_json_number;
+ g_changan_dkey_ensure_dl.rsa_private_key_pem = NULL;
+
+ (void)memset(&g_changan_dkey_ensure_reg_params, 0, sizeof(g_changan_dkey_ensure_reg_params));
+ g_changan_dkey_ensure_reg_params.access_token = g_changan_dkey_ensure_oauth_access;
+ g_changan_dkey_ensure_reg_params.secret_key = g_changan_dkey_ensure_oauth_secret;
+ g_changan_dkey_ensure_reg_params.oauth_bootstrap = NULL;
+ g_changan_dkey_ensure_reg_params.timestamp_ms = false;
+ g_changan_dkey_ensure_reg_params.timestamp = NULL;
+ g_changan_dkey_ensure_reg_params.header_nonce = NULL;
+ g_changan_dkey_ensure_reg_params.api_path = reg_use;
+ g_changan_dkey_ensure_reg_params.user_id = g_changan_dkey_ensure_user_id;
+ g_changan_dkey_ensure_reg_params.app_id = NULL;
+ g_changan_dkey_ensure_reg_params.algorithm = NULL;
+ g_changan_dkey_ensure_reg_params.public_key_spki_b64 = NULL;
+ return 0;
+}
+
+/**
+ * dkey ensure 链路上:public_key_register 失败或 download 入队失败时仍须通知 changan_http_dkey_ensure_owner_key_for_vehicle
+ * 传入的 download_done_cb,否则 App 侧一直认为「HTTP pending」无法重试。
+ */
+static void changan_dkey_ensure_invoke_app_done(const changan_http_result_t *r, int synthetic_http_if_r_null)
+{
+ if (g_changan_dkey_ensure_dl_done_cb == NULL) {
+ return;
+ }
+ if (r != NULL) {
+ g_changan_dkey_ensure_dl_done_cb(g_changan_dkey_ensure_dl_done_ud, r);
+ return;
+ }
+ {
+ changan_http_result_t syn;
+ (void)memset(&syn, 0, sizeof(syn));
+ syn.type = CHANGAN_HTTP_REQ_DKEY_DOWNLOAD_OWNER_KEY;
+ syn.http_code = synthetic_http_if_r_null;
+ g_changan_dkey_ensure_dl_done_cb(g_changan_dkey_ensure_dl_done_ud, &syn);
+ }
+}
+
+/**
+ * ensure 链:public_key_register 的 per-job 回调(先于 changan_http_default_result_handler)。
+ * 与 download_owner_key 共用 g_changan_dkey_ensure_dl_done_cb:失败或非预期成功(无 public_key_id)在此返回;
+ * 注册成功且可继续下载的仅走 default_result_handler 入队 download,最终仍由同一回调收到 download 结果。
+ */
+static void changan_dkey_ensure_unified_register_cb(void *ud, const changan_http_result_t *r)
+{
+ (void)ud;
+ if (r == NULL || g_changan_dkey_ensure_dl_done_cb == NULL) {
+ return;
+ }
+ if (r->type != CHANGAN_HTTP_REQ_DKEY_PUBLIC_KEY_REGISTER) {
+ return;
+ }
+ if (r->http_code == 200 && r->public_key_id[0] != '\0') {
+ return;
+ }
+ if (r->http_code == 200 && r->public_key_id[0] == '\0') {
+ printf("[changan_http][dkey_ensure] register http=200 but public_key_id empty, notify app\r\n");
+ changan_dkey_ensure_invoke_app_done(NULL, 0);
+ return;
+ }
+ g_changan_dkey_ensure_dl_done_cb(g_changan_dkey_ensure_dl_done_ud, r);
+}
+
+static void changan_http_default_result_handler(const changan_http_result_t *r)
+{
+ if (r == NULL) {
+ return;
+ }
+ printf("[changan_http][default] type=%d http=%d body_len=%u bin=%d\r\n", (int)r->type, r->http_code,
+ (unsigned)r->body_len, r->body_is_binary ? 1 : 0);
+
+ if (r->type == CHANGAN_HTTP_REQ_OAUTH_TOKEN) {
+ if (r->http_code == 200 && r->body != NULL && r->body_len > 0U && !r->body_is_binary) {
+ changan_http_oauth_parse_token_response_json((const char *)(const void *)r->body);
+ }
+ }
+
+ if (r->type == CHANGAN_HTTP_REQ_DKEY_PUBLIC_KEY_REGISTER) {
+ if (g_changan_dkey_ensure_pending != 0U && r->http_code == 200 && r->public_key_id[0] != '\0') {
+ size_t idl;
+
+ g_changan_dkey_ensure_pending = 0U;
+ idl = strnlen(r->public_key_id, sizeof(r->public_key_id));
+ if (idl >= sizeof(g_changan_dkey_ensure_public_key_id)) {
+ idl = sizeof(g_changan_dkey_ensure_public_key_id) - 1U;
+ }
+ if (memcpy_s(g_changan_dkey_ensure_public_key_id, sizeof(g_changan_dkey_ensure_public_key_id),
+ r->public_key_id, idl) != 0) {
+ printf("[changan_http][dkey_ensure] copy public_key_id failed\r\n");
+ changan_dkey_ensure_invoke_app_done(NULL, 0);
+ } else {
+ g_changan_dkey_ensure_public_key_id[idl] = '\0';
+ g_changan_dkey_ensure_dl.public_key_id = g_changan_dkey_ensure_public_key_id;
+ g_changan_dkey_ensure_decrypt_use_car_id = 1U;
+ if (changan_http_dkey_download_owner_key(&g_changan_dkey_ensure_dl, g_changan_dkey_ensure_dl_done_cb,
+ g_changan_dkey_ensure_dl_done_ud) != 0) {
+ g_changan_dkey_ensure_decrypt_use_car_id = 0U;
+ printf("[changan_http][dkey_ensure] download_owner_key submit failed\r\n");
+ changan_dkey_ensure_invoke_app_done(NULL, 0);
+ }
+ }
+ } else if (g_changan_dkey_ensure_pending != 0U) {
+ g_changan_dkey_ensure_pending = 0U;
+ printf("[changan_http][dkey_ensure] public_key_register failed http=%d\r\n", r->http_code);
+ /* 失败已由 changan_dkey_ensure_unified_register_cb 通知 App,此处不重复回调 */
+ }
+ }
+
+ if (r->type == CHANGAN_HTTP_REQ_DKEY_DOWNLOAD_OWNER_KEY) {
+ if (r->http_code == 200 && r->body != NULL && r->body_len > 0U && !r->body_is_binary) {
+ enum { k_dkey_cb_card_cap = 4096 };
+ char *card_buf = (char *)malloc((size_t)k_dkey_cb_card_cap);
+ uint8_t dkey_buf[64];
+ uint32_t card_len = 0U;
+ uint32_t dkey_len = 0U;
+ int dec = -101;
+ const char *car_id_pass =
+ (g_changan_dkey_ensure_decrypt_use_car_id != 0U && g_changan_dkey_ensure_car_id[0] != '\0') ?
+ g_changan_dkey_ensure_car_id :
+ NULL;
+
+ if (card_buf != NULL) {
+ (void)memset(card_buf, 0, (size_t)k_dkey_cb_card_cap);
+ dec = changan_http_dkey_decrypt_download_owner_key_response((const char *)(const void *)r->body, NULL,
+ card_buf, (uint32_t)k_dkey_cb_card_cap, &card_len, dkey_buf, (uint32_t)sizeof(dkey_buf), &dkey_len,
+ car_id_pass);
+ } else {
+ printf("[changan_http][default] dkey_dl auto decrypt card buf malloc failed\r\n");
+ }
+ free(card_buf);
+ if (g_changan_dkey_ensure_decrypt_use_car_id != 0U) {
+ g_changan_dkey_ensure_decrypt_use_car_id = 0U;
+ }
+ if (dec != 0) {
+ printf("[changan_http][default] dkey_dl auto decrypt failed ret=%d\r\n", dec);
+ } else {
+ printf("[changan_http][default] dkey_dl auto decrypt ok card_len=%u dkey_len=%u\r\n",
+ (unsigned)card_len, (unsigned)dkey_len);
+ }
+ } else if (g_changan_dkey_ensure_decrypt_use_car_id != 0U) {
+ g_changan_dkey_ensure_decrypt_use_car_id = 0U;
+ }
+ }
+}
+
+static void changan_http_deliver_job_result(changan_http_job_t *job, int http_code)
+{
+ changan_http_result_t *res = changan_http_build_result_from_job(job, http_code);
+
+ if (res == NULL) {
+ changan_http_job_free_buffers(job);
+ return;
+ }
+ if (g_changan_http_global_notify != NULL) {
+ g_changan_http_global_notify(g_changan_http_global_notify_ud, res);
+ }
+ if (job->done_cb != NULL) {
+ job->done_cb(job->done_ud, res);
+ }
+ changan_http_default_result_handler(res);
+ changan_http_result_destroy(res);
+ changan_http_job_free_buffers(job);
+ free(job);
+}
+
+static void changan_http_notify_simple(changan_http_req_type_e req_type, int http_code,
+ changan_http_result_cb_t done_cb, void *done_ud, const void *body_src, uint32_t body_len, bool body_is_binary,
+ const char *qrcode_id_opt, const char *public_key_id_opt)
+{
+ changan_http_result_t *res = (changan_http_result_t *)calloc(1, sizeof(changan_http_result_t));
+
+ if (res == NULL) {
+ return;
+ }
+ res->type = req_type;
+ res->http_code = http_code;
+ if (body_src != NULL && body_len > 0U) {
+ (void)changan_http_result_copy_body(res, body_src, body_len, body_is_binary);
+ }
+ if (qrcode_id_opt != NULL && qrcode_id_opt[0] != '\0') {
+ size_t idl = strnlen(qrcode_id_opt, sizeof(res->qrcode_id));
+
+ if (idl >= sizeof(res->qrcode_id)) {
+ idl = sizeof(res->qrcode_id) - 1U;
+ }
+ (void)memcpy_s(res->qrcode_id, sizeof(res->qrcode_id), qrcode_id_opt, idl);
+ res->qrcode_id[idl] = '\0';
+ }
+ if (public_key_id_opt != NULL && public_key_id_opt[0] != '\0') {
+ size_t idl = strnlen(public_key_id_opt, sizeof(res->public_key_id));
+
+ if (idl >= sizeof(res->public_key_id)) {
+ idl = sizeof(res->public_key_id) - 1U;
+ }
+ (void)memcpy_s(res->public_key_id, sizeof(res->public_key_id), public_key_id_opt, idl);
+ res->public_key_id[idl] = '\0';
+ }
+ if (g_changan_http_global_notify != NULL) {
+ g_changan_http_global_notify(g_changan_http_global_notify_ud, res);
+ }
+ if (done_cb != NULL) {
+ done_cb(done_ud, res);
+ }
+ changan_http_default_result_handler(res);
+ changan_http_result_destroy(res);
+}
+
+static int changan_http_worker_run_inline_job(changan_http_job_t *job);
+
+/** 入队失败:-101 内存;-102 队列满。worker 不可用时在同线程执行 do_sync。 */
+static int changan_http_submit_job(changan_http_job_t *job)
+{
+ changan_http_job_t *slot = job;
+
+ if (job == NULL) {
+ return -101;
+ }
+ if (g_changan_httpw_thread_create_failed != 0U) {
+ return changan_http_worker_run_inline_job(job);
+ }
+ if (changan_http_worker_init() != 0) {
+ return changan_http_worker_run_inline_job(job);
+ }
+ if (g_changan_httpw_mq == NULL) {
+ return changan_http_worker_run_inline_job(job);
+ }
+ if (osMessageQueuePut(g_changan_httpw_mq, &slot, 0U, 0U) != osOK) {
+ printf("[changan_http][worker] queue full\r\n");
+ changan_http_job_free_buffers(job);
+ free(job);
+ return -102;
+ }
+ return 0;
+}
+
+static void changan_httpw_thread(void *argument)
+{
+ (void)argument;
+ for (;;) {
+ changan_http_job_t *job = NULL;
+
+ if (g_changan_httpw_mq == NULL) {
+ (void)osDelay(100U);
+ continue;
+ }
+ if (osMessageQueueGet(g_changan_httpw_mq, &job, NULL, osWaitForever) != osOK || job == NULL) {
+ continue;
+ }
+ {
+ int code = changan_http_job_dispatch(job);
+
+ changan_http_deliver_job_result(job, code);
+ }
+ }
+}
+
+static int changan_http_worker_init(void)
+{
+ if (g_changan_httpw_inited != 0U) {
+ return (g_changan_httpw_thread_create_failed != 0U) ? -1 : 0;
+ }
+ g_changan_httpw_mq = osMessageQueueNew(CHANGAN_HTTP_JOB_QUEUE_DEPTH, sizeof(changan_http_job_t *), NULL);
+ if (g_changan_httpw_mq == NULL) {
+ printf("[changan_http][worker] osMessageQueueNew failed\r\n");
+ g_changan_httpw_thread_create_failed = 1U;
+ g_changan_httpw_inited = 1U;
+ return -1;
+ }
+
+ {
+ app_task_definition_ext_t task_cfg = {
+ .attr = {
+ .name = "changan_http",
+ .stack_size = 0x3000,
+ .priority = osPriorityNormal,
+ },
+ .func = (osThreadFunc_t)changan_httpw_thread,
+ .task_handle = &g_changan_httpw_tid,
+ .create_queue_handle = NULL,
+ .use_mem = USE_EXTEND_MEM,
+ .inst_args = NULL,
+ };
+
+ if (uapi_create_osThread_custom_with_args(&task_cfg) != ERRCODE_SUCC) {
+ printf("[changan_http][worker] uapi_create_osThread_custom_with_args failed\r\n");
+ g_changan_httpw_thread_create_failed = 1U;
+ g_changan_httpw_inited = 1U;
+ return -1;
+ }
+ }
+ g_changan_httpw_inited = 1U;
+ return 0;
+}
+
+static int changan_http_job_dispatch(changan_http_job_t *job)
+{
+ if (job == NULL) {
+ return -1;
+ }
+ switch (job->kind) {
+ case CHANGAN_HTTP_JK_COMMON:
+ return changan_http_common_do_sync(job->u.co.tag, job->u.co.post_buf, job->u.co.url,
+ (char *)job->u.co.resp_heap, job->u.co.resp_cap, job->u.co.content_type);
+ case CHANGAN_HTTP_JK_OAUTH:
+ return changan_http_oauth_token_request_do_sync(job->u.oauth.params, (char *)job->u.oauth.resp_heap,
+ job->u.oauth.resp_cap);
+ case CHANGAN_HTTP_JK_CARLIST:
+ return changan_http_get_car_list_by_brand_code_control_car_do_sync(job->u.carlist.params,
+ (char *)job->u.carlist.resp_heap, job->u.carlist.resp_cap);
+ case CHANGAN_HTTP_JK_CC_POST:
+ return changan_http_control_car_post_json_do_sync(job->u.cc.url, job->u.cc.req_hdr, job->u.cc.body,
+ (char *)job->u.cc.resp_heap, job->u.cc.resp_cap);
+ case CHANGAN_HTTP_JK_VRTM:
+ return changan_http_post_vrtm_car_control_v2_impl(job->u.vrtm.params, (char *)job->u.vrtm.resp_heap,
+ job->u.vrtm.resp_cap, job->req_type);
+ case CHANGAN_HTTP_JK_QR_GEN:
+ return changan_http_qrcode_generate_v1_do_sync(job->u.qr_gen.params, job->u.qr_gen.resp_heap,
+ job->u.qr_gen.resp_cap, &job->u.qr_gen.out_body_len, job->u.qr_gen.qrcode_id_buf,
+ (uint32_t)sizeof(job->u.qr_gen.qrcode_id_buf));
+ case CHANGAN_HTTP_JK_QR_ST:
+ return changan_http_qrcode_status_no_backend_v1_do_sync(job->u.qr_st.params,
+ (char *)job->u.qr_st.resp_heap, job->u.qr_st.resp_cap);
+ case CHANGAN_HTTP_JK_DKEY_REG:
+ return changan_http_dkey_public_key_register_impl(job->u.dreg.p, (char *)job->u.dreg.resp_heap,
+ job->u.dreg.resp_cap, job->u.dreg.public_key_id_buf, (uint32_t)sizeof(job->u.dreg.public_key_id_buf),
+ job->req_type);
+ case CHANGAN_HTTP_JK_DKEY_DL:
+ return changan_http_dkey_download_owner_key_impl(job->u.dld.p, (char *)job->u.dld.resp_heap,
+ job->u.dld.resp_cap, job->req_type);
+ case CHANGAN_HTTP_JK_OPENC_CARID_GET:
+ return changan_http_openc_car_id_get_do_sync(job->u.openc_cid.params, job->u.openc_cid.path_if_api_null,
+ job->u.openc_cid.get_hdr_form_urlencoded != 0U, (char *)job->u.openc_cid.resp_heap,
+ job->u.openc_cid.resp_cap);
+ case CHANGAN_HTTP_JK_FC_RECEIVER_INFO:
+ return changan_http_fc_get_receiver_informations_v2_do_sync(job->u.fc_rcv.params,
+ (char *)job->u.fc_rcv.resp_heap, job->u.fc_rcv.resp_cap);
+ default:
+ return -1;
+ }
+}
+
+static int changan_http_worker_run_inline_job(changan_http_job_t *job)
+{
+ int code;
+
+ code = changan_http_job_dispatch(job);
+ changan_http_deliver_job_result(job, code);
+ return code;
+}
+
+static int changan_http_common_do_sync(const char *tag,
+ char *post_buf, char *url, char *put_buf,uint32_t max_len,char *content_type)
+{
+ HttpClient client = (HttpClient){0};
+ HttpClientData client_data = (HttpClientData){0};
+ int ret = -1;
+
+ if (url == NULL) {
+ printf("[changan_http][%s] url is NULL\r\n", tag);
+ return -1;
+ }
+
+ /* httpclient 要求 headerBuf/responseBuf 不小于 2048 */
+ char *req_buf = (char *)malloc(2048);
+ char *rsp_buf = (char *)malloc(2048);
+ if (req_buf == NULL || rsp_buf == NULL) {
+ printf("[changan_http][%s] malloc failed\r\n", tag);
+ goto EXIT;
+ }
+
+ memset(req_buf, 0, 2048);
+ client_data.headerBuf = req_buf;
+ client_data.headerBufLen = 2048;
+
+ memset(rsp_buf, 0, 2048);
+ client_data.responseBuf = rsp_buf;
+ client_data.responseBufLen = 2048;
+
+ printf("[changan_http][%s] url: %s\r\n", tag, url);
+
+ if (post_buf != NULL) {
+ client_data.postBuf = post_buf;
+ client_data.postBufLen = (int)strlen(post_buf);
+ } else {
+ client_data.postBuf = NULL;
+ client_data.postBufLen = 0;
+ }
+
+ /* ChangAn 接口默认都是 JSON */
+ client.header = content_type;
+
+ if(strcmp(tag, "POST") == 0)
+ {
+ ret = HttpClientPostRequest(&client, url, &client_data);
+ }
+ else if(strcmp(tag, "PUT") == 0)
+ {
+ ret = HttpClientPutRequest(&client, url, &client_data);
+ }
+ else if(strcmp(tag, "GET") == 0)
+ {
+ ret = HttpClientGetRequest(&client, url, &client_data);
+ }
+
+ char create_time_str[32] = {0};
+ time_t now = time(NULL);
+ struct tm tm_now;
+ (void)localtime_r(&now, &tm_now);
+ (void)strftime(create_time_str, sizeof(create_time_str), "%Y-%m-%d %H:%M:%S", &tm_now);
+ printf("create_time_str: %s\r\n", create_time_str);
+ printf("[changan_http][%s] Post_buf: %s\r\n", tag, post_buf);
+ printf("[changan_http][%s] url: %s\r\n", tag, url);
+
+ if (ret >= 0 && client.responseCode == 200) {
+ printf("[changan_http][%s] resp: %s\r\n", tag, client_data.responseBuf);
+ // printf("[changan_http][%s] header: %s\r\n", tag, client_data.headerBuf);
+ printf("[changan_http][%s] code: %d\r\n", tag, client.responseCode);
+ if (put_buf != NULL && client_data.responseBuf != NULL) {
+ uint32_t n = changan_http_cd_response_text_len(&client_data, max_len);
+
+ if (n >= max_len) {
+ n = max_len - 1U;
+ }
+ if (memcpy_s(put_buf, max_len, client_data.responseBuf, n) != 0) {
+ ret = -1;
+ } else {
+ put_buf[n] = '\0';
+ }
+ }
+ if (ret >= 0) {
+ ret = 0;
+ }
+ } else {
+ printf("[changan_http][%s] failed, code=%d ret=0x%x\r\n",
+ tag, client.responseCode, ret);
+ printf("[changan_http][%s] header: %s\r\n", tag, client_data.headerBuf);
+ printf("[changan_http][%s] response: %s\r\n", tag, client_data.responseBuf);
+ printf("[changan_http][%s] code: %d\r\n", tag, client.responseCode);
+ }
+
+EXIT:
+ if (req_buf != NULL) {
+ free(req_buf);
+ }
+ if (rsp_buf != NULL) {
+ free(rsp_buf);
+ }
+ return client.responseCode;
+}
+
+static int changan_http_common_with_cb(const char *tag, char *post_buf, char *url, const char *content_type,
+ changan_http_req_type_e req_type, changan_http_result_cb_t cb, void *user_data)
+{
+ changan_http_job_t *job;
+
+ if (cb == NULL) {
+ return -100;
+ }
+ if (url == NULL) {
+ return -1;
+ }
+ job = (changan_http_job_t *)calloc(1, sizeof(changan_http_job_t));
+ if (job == NULL) {
+ return -101;
+ }
+ job->kind = CHANGAN_HTTP_JK_COMMON;
+ job->req_type = req_type;
+ job->done_cb = cb;
+ job->done_ud = user_data;
+ (void)snprintf(job->u.co.tag, sizeof(job->u.co.tag), "%s", tag != NULL ? tag : "");
+ job->u.co.content_type = (char *)(uintptr_t)content_type;
+ job->u.co.owns_ctype = false;
+ job->u.co.resp_heap = (uint8_t *)malloc((size_t)CHANGAN_HTTP_GENERIC_RESP_CAP);
+ if (job->u.co.resp_heap == NULL) {
+ free(job);
+ return -101;
+ }
+ job->u.co.resp_cap = CHANGAN_HTTP_GENERIC_RESP_CAP;
+ {
+ char *url_heap = changan_http_strdup_nonnull(url);
+
+ if (url_heap == NULL) {
+ free(job->u.co.resp_heap);
+ free(job);
+ return -101;
+ }
+ job->u.co.url = url_heap;
+ job->u.co.owns_url = true;
+ }
+ if (post_buf != NULL) {
+ char *post_heap = changan_http_strdup_nonnull(post_buf);
+
+ if (post_heap == NULL) {
+ free(job->u.co.url);
+ free(job->u.co.resp_heap);
+ free(job);
+ return -101;
+ }
+ job->u.co.post_buf = post_heap;
+ job->u.co.owns_post_buf = true;
+ } else {
+ job->u.co.post_buf = NULL;
+ job->u.co.owns_post_buf = false;
+ }
+ return changan_http_submit_job(job);
+}
+
+int changan_http_put(char *post_buf, char *url, changan_http_result_cb_t cb, void *user_data)
+{
+ return changan_http_common_with_cb("PUT", post_buf, url, "Content-Type: application/json\r\n",
+ CHANGAN_HTTP_REQ_PUT, cb, user_data);
+}
+
+int changan_http_post(char *post_buf, char *url, changan_http_result_cb_t cb, void *user_data)
+{
+ return changan_http_common_with_cb("POST", post_buf, url, "Content-Type: application/json\r\n",
+ CHANGAN_HTTP_REQ_POST, cb, user_data);
+}
+
+int changan_http_get(char *post_buf, char *url, changan_http_result_cb_t cb, void *user_data)
+{
+ return changan_http_common_with_cb("GET", post_buf, url, "Content-Type: application/json\r\n",
+ CHANGAN_HTTP_REQ_GET, cb, user_data);
+}
+
+/* ---------- openC /oauth/token 扩展(http/py/openc_oauth_token_test.py) ---------- */
+
+#define CHANGAN_OAUTH_POST_MAX 1536U
+#define CHANGAN_OAUTH_HDR_SZ 2048
+
+changan_http_oauth_last_token_t g_changan_http_oauth_last_token;
+
+static void changan_oauth_trim_tail_ws(char *s)
+{
+ size_t n;
+
+ if (s == NULL) {
+ return;
+ }
+ n = strlen(s);
+ while (n > 0U && (s[n - 1U] == '\n' || s[n - 1U] == '\r' || s[n - 1U] == ' ' || s[n - 1U] == '\t')) {
+ s[--n] = '\0';
+ }
+}
+
+static bool changan_oauth_write_text_file(const char *path, const char *text)
+{
+ FILE *fp = NULL;
+ size_t n;
+
+ if (path == NULL || text == NULL) {
+ return false;
+ }
+ n = strlen(text);
+ if (n == 0U) {
+ return false;
+ }
+ fp = fopen(path, "wb");
+ if (fp == NULL) {
+ return false;
+ }
+ if (fwrite(text, 1U, n, fp) != n) {
+ (void)fclose(fp);
+ return false;
+ }
+ (void)fclose(fp);
+ return true;
+}
+
+static bool changan_oauth_read_one_line_file(const char *path, char *out, size_t cap)
+{
+ FILE *fp = NULL;
+
+ if (path == NULL || out == NULL || cap == 0U) {
+ return false;
+ }
+ out[0] = '\0';
+ fp = fopen(path, "rb");
+ if (fp == NULL) {
+ return false;
+ }
+ if (fgets(out, (int)cap, fp) == NULL) {
+ (void)fclose(fp);
+ out[0] = '\0';
+ return false;
+ }
+ (void)fclose(fp);
+ changan_oauth_trim_tail_ws(out);
+ return out[0] != '\0';
+}
+
+/** 从文件回填access/secret,供控车解析与 getter 默认使用 */
+static void changan_oauth_try_load_from_disk(void)
+{
+ memset_s(g_changan_http_oauth_last_token.access_token, sizeof(g_changan_http_oauth_last_token.access_token), 0, sizeof(g_changan_http_oauth_last_token.access_token));
+ memset_s(g_changan_http_oauth_last_token.secret_key, sizeof(g_changan_http_oauth_last_token.secret_key), 0, sizeof(g_changan_http_oauth_last_token.secret_key));
+ if (g_changan_http_oauth_last_token.access_token[0] == '\0') {
+ (void)changan_oauth_read_one_line_file(CHANGAN_HTTP_OAUTH_CACHE_ACCESS_TOKEN_PATH,
+ g_changan_http_oauth_last_token.access_token, sizeof(g_changan_http_oauth_last_token.access_token));
+#if CHANGAN_HTTP_DEBUG_CTRL_RESOLVE
+ printf("[changan_http][ctrl_resolve] disk access_token len=%u\r\n",
+ (unsigned)strnlen(g_changan_http_oauth_last_token.access_token, sizeof(g_changan_http_oauth_last_token.access_token)));
+#endif
+ }
+ if (g_changan_http_oauth_last_token.secret_key[0] == '\0') {
+ (void)changan_oauth_read_one_line_file(CHANGAN_HTTP_OAUTH_CACHE_SECRET_KEY_PATH,
+ g_changan_http_oauth_last_token.secret_key, sizeof(g_changan_http_oauth_last_token.secret_key));
+#if CHANGAN_HTTP_DEBUG_CTRL_RESOLVE
+ printf("[changan_http][ctrl_resolve] disk secret_key len=%u\r\n",
+ (unsigned)strnlen(g_changan_http_oauth_last_token.secret_key, sizeof(g_changan_http_oauth_last_token.secret_key)));
+#endif
+ }
+}
+
+static void changan_oauth_set_optional_str_from_json(cJSON *root, const char *key, char *dst, size_t dst_cap)
+{
+ cJSON *it = NULL;
+ size_t n;
+
+ if (root == NULL || key == NULL || dst == NULL || dst_cap == 0U) {
+ return;
+ }
+ dst[0] = '\0';
+ it = cJSON_GetObjectItem(root, key);
+ if (it == NULL) {
+ return;
+ }
+ if (it->type == cJSON_NULL) {
+ return;
+ }
+ if (it->type != cJSON_String || it->valuestring == NULL) {
+ return;
+ }
+ n = strnlen(it->valuestring, dst_cap - 1U);
+ if (memcpy_s(dst, dst_cap, it->valuestring, n) != 0) {
+ dst[0] = '\0';
+ return;
+ }
+ dst[n] = '\0';
+}
+
+/**
+ * 解析 /oauth/token JSON 更新 g_changan_http_oauth_last_token。
+ * 无 refresh_token 字段(或为空)时,用本响应 access_token 写入 oauth_refresh_token,供 grant_type=refresh_token 默认使用。
+ * access_token 有字符串才更新;secret_key 同原逻辑;access/secret 更新后落盘。
+ */
+static void changan_oauth_store_tokens_from_json(const char *json_resp)
+{
+ cJSON *root = NULL;
+ cJSON *at = NULL;
+ cJSON *sk = NULL;
+ cJSON *ex = NULL;
+ bool persist_access = false;
+ bool persist_secret = false;
+
+ if (json_resp == NULL || json_resp[0] == '\0') {
+ return;
+ }
+ root = cJSON_Parse(json_resp);
+ if (root == NULL) {
+ return;
+ }
+
+ changan_oauth_set_optional_str_from_json(root, "token_type", g_changan_http_oauth_last_token.token_type,
+ sizeof(g_changan_http_oauth_last_token.token_type));
+ changan_oauth_set_optional_str_from_json(root, "scope", g_changan_http_oauth_last_token.scope,
+ sizeof(g_changan_http_oauth_last_token.scope));
+ changan_oauth_set_optional_str_from_json(root, "uid", g_changan_http_oauth_last_token.uid,
+ sizeof(g_changan_http_oauth_last_token.uid));
+ changan_oauth_set_optional_str_from_json(root, "deviceType", g_changan_http_oauth_last_token.device_type,
+ sizeof(g_changan_http_oauth_last_token.device_type));
+ changan_oauth_set_optional_str_from_json(root, "pre_oauth_token", g_changan_http_oauth_last_token.pre_oauth_token,
+ sizeof(g_changan_http_oauth_last_token.pre_oauth_token));
+ changan_oauth_set_optional_str_from_json(root, "refresh_token", g_changan_http_oauth_last_token.oauth_refresh_token,
+ sizeof(g_changan_http_oauth_last_token.oauth_refresh_token));
+
+ ex = cJSON_GetObjectItem(root, "expires_in");
+ if (ex != NULL && cJSON_IsNumber(ex)) {
+ g_changan_http_oauth_last_token.expires_in_present = true;
+ g_changan_http_oauth_last_token.expires_in = (int32_t)ex->valuedouble;
+ } else {
+ g_changan_http_oauth_last_token.expires_in_present = false;
+ g_changan_http_oauth_last_token.expires_in = 0;
+ }
+
+ at = cJSON_GetObjectItem(root, "access_token");
+ if (at != NULL && at->type == cJSON_String && at->valuestring != NULL) {
+ size_t n = strlen(at->valuestring);
+
+ if (n + 1U <= sizeof(g_changan_http_oauth_last_token.access_token)) {
+ (void)memcpy_s(g_changan_http_oauth_last_token.access_token,
+ sizeof(g_changan_http_oauth_last_token.access_token), at->valuestring, n + 1U);
+ persist_access = true;
+ }
+ }
+
+ /* 响应无 refresh_token 字段时,用本响应 access_token 作为后续 refresh 默认凭证(长安部分返回仅有 pre_oauth_token) */
+ if (g_changan_http_oauth_last_token.oauth_refresh_token[0] == '\0' &&
+ g_changan_http_oauth_last_token.access_token[0] != '\0') {
+ size_t na = strnlen(g_changan_http_oauth_last_token.access_token,
+ sizeof(g_changan_http_oauth_last_token.access_token));
+
+ if (na + 1U <= sizeof(g_changan_http_oauth_last_token.oauth_refresh_token)) {
+ (void)memcpy_s(g_changan_http_oauth_last_token.oauth_refresh_token,
+ sizeof(g_changan_http_oauth_last_token.oauth_refresh_token),
+ g_changan_http_oauth_last_token.access_token, na + 1U);
+ }
+ }
+
+ sk = cJSON_GetObjectItem(root, "secret_key");
+ if (sk != NULL && sk->type == cJSON_String && sk->valuestring != NULL) {
+ size_t n = strlen(sk->valuestring);
+
+ if (n + 1U <= sizeof(g_changan_http_oauth_last_token.secret_key)) {
+ (void)memcpy_s(g_changan_http_oauth_last_token.secret_key,
+ sizeof(g_changan_http_oauth_last_token.secret_key), sk->valuestring, n + 1U);
+ persist_secret = true;
+ }
+ }
+
+ cJSON_Delete(root);
+
+ if (persist_access && g_changan_http_oauth_last_token.access_token[0] != '\0') {
+ (void)changan_oauth_write_text_file(CHANGAN_HTTP_OAUTH_CACHE_ACCESS_TOKEN_PATH,
+ g_changan_http_oauth_last_token.access_token);
+ }
+ if (persist_secret && g_changan_http_oauth_last_token.secret_key[0] != '\0') {
+ (void)changan_oauth_write_text_file(CHANGAN_HTTP_OAUTH_CACHE_SECRET_KEY_PATH,
+ g_changan_http_oauth_last_token.secret_key);
+ }
+}
+
+/** /oauth/token 成功 JSON 的统一解析入口(由 default_result_handler 与不经回调链的内部 bootstrap 调用) */
+static void changan_http_oauth_parse_token_response_json(const char *json_resp)
+{
+ if (json_resp == NULL || json_resp[0] == '\0') {
+ return;
+ }
+ changan_oauth_store_tokens_from_json(json_resp);
+}
+
+static bool changan_oauth_truncate_file(const char *path)
+{
+ FILE *fp;
+
+ if (path == NULL) {
+ return false;
+ }
+ fp = fopen(path, "wb");
+ if (fp == NULL) {
+ return false;
+ }
+ (void)fclose(fp);
+ return true;
+}
+
+int changan_http_oauth_set_cached_credentials(const char *access_token, const char *secret_key, bool persist_to_disk)
+{
+ size_t na = 0U;
+ size_t ns = 0U;
+ size_t cap_a = sizeof(g_changan_http_oauth_last_token.access_token);
+ size_t cap_s = sizeof(g_changan_http_oauth_last_token.secret_key);
+ bool touch_a = false;
+ bool touch_s = false;
+
+ if (access_token == NULL && secret_key == NULL) {
+ return -1;
+ }
+ if (access_token != NULL) {
+ na = strnlen(access_token, cap_a);
+ if (na >= cap_a) {
+ return -2;
+ }
+ touch_a = true;
+ }
+ if (secret_key != NULL) {
+ ns = strnlen(secret_key, cap_s);
+ if (ns >= cap_s) {
+ return -3;
+ }
+ touch_s = true;
+ }
+ if (touch_a) {
+ if (memcpy_s(g_changan_http_oauth_last_token.access_token, cap_a, access_token, na + 1U) != 0) {
+ return -2;
+ }
+ }
+ if (touch_s) {
+ if (memcpy_s(g_changan_http_oauth_last_token.secret_key, cap_s, secret_key, ns + 1U) != 0) {
+ return -3;
+ }
+ }
+ if (persist_to_disk) {
+ if (touch_a) {
+ if (g_changan_http_oauth_last_token.access_token[0] != '\0') {
+ (void)changan_oauth_write_text_file(CHANGAN_HTTP_OAUTH_CACHE_ACCESS_TOKEN_PATH,
+ g_changan_http_oauth_last_token.access_token);
+ } else {
+ (void)changan_oauth_truncate_file(CHANGAN_HTTP_OAUTH_CACHE_ACCESS_TOKEN_PATH);
+ }
+ }
+ if (touch_s) {
+ if (g_changan_http_oauth_last_token.secret_key[0] != '\0') {
+ (void)changan_oauth_write_text_file(CHANGAN_HTTP_OAUTH_CACHE_SECRET_KEY_PATH,
+ g_changan_http_oauth_last_token.secret_key);
+ } else {
+ (void)changan_oauth_truncate_file(CHANGAN_HTTP_OAUTH_CACHE_SECRET_KEY_PATH);
+ }
+ }
+ }
+ return 0;
+}
+
+bool changan_http_oauth_get_stored_access_token(char *out, uint32_t cap)
+{
+ size_t n;
+
+ if (out == NULL || cap == 0U) {
+ return false;
+ }
+ n = strnlen(g_changan_http_oauth_last_token.access_token,
+ sizeof(g_changan_http_oauth_last_token.access_token));
+ if (n >= sizeof(g_changan_http_oauth_last_token.access_token)) {
+ return false;
+ }
+ if (n + 1U > (size_t)cap) {
+ return false;
+ }
+ return memcpy_s(out, cap, g_changan_http_oauth_last_token.access_token, n + 1U) == 0;
+}
+
+bool changan_http_oauth_get_stored_secret_key(char *out, uint32_t cap)
+{
+ size_t n;
+
+ if (out == NULL || cap == 0U) {
+ return false;
+ }
+ n = strnlen(g_changan_http_oauth_last_token.secret_key,
+ sizeof(g_changan_http_oauth_last_token.secret_key));
+ if (n >= sizeof(g_changan_http_oauth_last_token.secret_key)) {
+ return false;
+ }
+ if (n + 1U > (size_t)cap) {
+ return false;
+ }
+ return memcpy_s(out, cap, g_changan_http_oauth_last_token.secret_key, n + 1U) == 0;
+}
+
+bool changan_http_oauth_get_stored_expires_in(int32_t *expires_out)
+{
+ if (expires_out == NULL) {
+ return false;
+ }
+ if (!g_changan_http_oauth_last_token.expires_in_present) {
+ return false;
+ }
+ *expires_out = g_changan_http_oauth_last_token.expires_in;
+ return true;
+}
+
+static bool changan_oauth_urlencode_val(const char *in, char *out, size_t out_sz)
+{
+ size_t j = 0;
+
+ if (out_sz == 0U) {
+ return false;
+ }
+ if (in == NULL) {
+ in = "";
+ }
+ for (size_t i = 0; in[i] != '\0'; i++) {
+ unsigned char c = (unsigned char)in[i];
+
+ if (c == ' ') {
+ if (j + 1U >= out_sz) {
+ return false;
+ }
+ out[j++] = '+';
+ } else if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
+ (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == '*') {
+ if (j + 1U >= out_sz) {
+ return false;
+ }
+ out[j++] = (char)c;
+ } else {
+ static const char H[] = "0123456789ABCDEF";
+
+ if (j + 3U >= out_sz) {
+ return false;
+ }
+ out[j++] = '%';
+ out[j++] = H[(c >> 4) & 0xFU];
+ out[j++] = H[c & 0xFU];
+ }
+ }
+ if (j >= out_sz) {
+ return false;
+ }
+ out[j] = '\0';
+ return true;
+}
+
+static int changan_oauth_append_field(char *buf, uint32_t cap, uint32_t *pos, const char *key, const char *val, bool with_amp)
+{
+ char enc[512];
+
+ if (!changan_oauth_urlencode_val(val, enc, sizeof(enc))) {
+ return -1;
+ }
+ if (cap <= *pos) {
+ return -1;
+ }
+ const char *fmt = with_amp ? "%s=%s&" : "%s=%s";
+ int w = snprintf(buf + *pos, (size_t)(cap - *pos), fmt, key, enc);
+
+ if (w < 0 || (uint32_t)w >= cap - *pos) {
+ return -1;
+ }
+ *pos += (uint32_t)w;
+ return 0;
+}
+
+static const char *changan_oauth_grant_str(changan_oauth_grant_type_e g)
+{
+ switch (g) {
+ case CHANGAN_OAUTH_GRANT_AUTHORIZATION_CODE:
+ return "authorization_code";
+ case CHANGAN_OAUTH_GRANT_REFRESH_TOKEN:
+ return "refresh_token";
+ case CHANGAN_OAUTH_GRANT_CLIENT_CREDENTIALS:
+ default:
+ return "client_credentials";
+ }
+}
+
+static int changan_http_oauth_token_request_do_sync(const changan_oauth_token_params_t *p, char *resp_buf, uint32_t resp_cap)
+{
+ char post_buf[CHANGAN_OAUTH_POST_MAX];
+ uint32_t pos = 0;
+
+ if (p == NULL || resp_buf == NULL || resp_cap == 0U) {
+ return -1;
+ }
+ if (p->client_id == NULL || p->client_secret == NULL) {
+ printf("[changan_http][oauth] invalid params\r\n");
+ return -1;
+ }
+
+ resp_buf[0] = '\0';
+
+ const char *grant = changan_oauth_grant_str(p->grant_type);
+ const char *refresh_wire = NULL;
+
+ if (p->grant_type == CHANGAN_OAUTH_GRANT_AUTHORIZATION_CODE &&
+ (p->code == NULL || p->code[0] == '\0')) {
+ printf("[changan_http][oauth] authorization_code requires code\r\n");
+ return -1;
+ }
+ if (p->grant_type == CHANGAN_OAUTH_GRANT_REFRESH_TOKEN) {
+ refresh_wire = p->refresh_token;
+ if (refresh_wire == NULL || refresh_wire[0] == '\0') {
+ changan_oauth_try_load_from_disk();
+ if (g_changan_http_oauth_last_token.access_token[0] != '\0') {
+ refresh_wire = g_changan_http_oauth_last_token.access_token;
+ } else if (g_changan_http_oauth_last_token.oauth_refresh_token[0] != '\0') {
+ refresh_wire = g_changan_http_oauth_last_token.oauth_refresh_token;
+ } else if (g_changan_http_oauth_last_token.pre_oauth_token[0] != '\0') {
+ refresh_wire = g_changan_http_oauth_last_token.pre_oauth_token;
+ } else {
+ printf("[changan_http][oauth] refresh_token grant needs param or cached access_token/oauth_refresh_token/pre_oauth_token\r\n");
+ return -1;
+ }
+ }
+ }
+
+ if (changan_oauth_append_field(post_buf, CHANGAN_OAUTH_POST_MAX, &pos, "client_id", p->client_id, true) != 0) {
+ return -1;
+ }
+ if (changan_oauth_append_field(post_buf, CHANGAN_OAUTH_POST_MAX, &pos, "client_secret", p->client_secret, true) != 0) {
+ return -1;
+ }
+
+ if (p->grant_type == CHANGAN_OAUTH_GRANT_AUTHORIZATION_CODE) {
+ if (changan_oauth_append_field(post_buf, CHANGAN_OAUTH_POST_MAX, &pos, "grant_type", grant, true) != 0) {
+ return -1;
+ }
+ if (changan_oauth_append_field(post_buf, CHANGAN_OAUTH_POST_MAX, &pos, "code", p->code,
+ (p->redirect_uri != NULL && p->redirect_uri[0] != '\0')) != 0) {
+ return -1;
+ }
+ if (p->redirect_uri != NULL && p->redirect_uri[0] != '\0') {
+ if (changan_oauth_append_field(post_buf, CHANGAN_OAUTH_POST_MAX, &pos, "redirect_uri", p->redirect_uri, false) != 0) {
+ return -1;
+ }
+ }
+ } else if (p->grant_type == CHANGAN_OAUTH_GRANT_REFRESH_TOKEN) {
+ if (changan_oauth_append_field(post_buf, CHANGAN_OAUTH_POST_MAX, &pos, "grant_type", grant, true) != 0) {
+ return -1;
+ }
+ if (changan_oauth_append_field(post_buf, CHANGAN_OAUTH_POST_MAX, &pos, "refresh_token", refresh_wire, false) != 0) {
+ return -1;
+ }
+ } else {
+ if (changan_oauth_append_field(post_buf, CHANGAN_OAUTH_POST_MAX, &pos, "grant_type", grant, false) != 0) {
+ return -1;
+ }
+ }
+
+ HttpClient client = (HttpClient){0};
+ HttpClientData cd = (HttpClientData){0};
+ int http_code = -1;
+
+ if (HttpClientPrepare(&cd, CHANGAN_OAUTH_HDR_SZ, (int)resp_cap) != HTTP_SUCCESS) {
+ printf("[changan_http][oauth] HttpClientPrepare failed\r\n");
+ return -1;
+ }
+
+ cd.postBuf = post_buf;
+ cd.postBufLen = (int)strlen(post_buf);
+ client.header = "Content-Type: application/x-www-form-urlencoded\r\n";
+
+ HTTPC_RESULT hr = HttpClientPostRequest(&client, CHANGAN_HTTP_API_TOKEN, &cd);
+
+ http_code = client.responseCode;
+
+ if (hr == HTTP_SUCCESS && cd.responseBuf != NULL) {
+ changan_http_apply_cd_body_to_resp(&cd, resp_buf, resp_cap);
+ }
+
+ HttpClientUnprepare(&cd);
+ printf("[changan_http][oauth] http=%d\r\n", http_code);
+ return http_code;
+}
+
+int changan_http_oauth_token_request(const changan_oauth_token_params_t *p, changan_http_result_cb_t cb,
+ void *user_data)
+{
+ changan_http_job_t *job;
+
+ if (cb == NULL) {
+ return -100;
+ }
+ if (p == NULL) {
+ return -1;
+ }
+ if (p->grant_type == CHANGAN_OAUTH_GRANT_AUTHORIZATION_CODE) {
+ if (p->code == NULL || p->code[0] == '\0') {
+ printf("[changan_http][oauth] authorization_code requires non-empty code\r\n");
+ return -1;
+ }
+ }
+ if (p->grant_type == CHANGAN_OAUTH_GRANT_REFRESH_TOKEN) {
+ if (p->refresh_token == NULL || p->refresh_token[0] == '\0') {
+ changan_oauth_try_load_from_disk();
+ if (g_changan_http_oauth_last_token.access_token[0] == '\0' &&
+ g_changan_http_oauth_last_token.oauth_refresh_token[0] == '\0' &&
+ g_changan_http_oauth_last_token.pre_oauth_token[0] == '\0') {
+ printf("[changan_http][oauth] refresh_token grant requires param or cached access_token/oauth_refresh_token/pre_oauth_token\r\n");
+ return -1;
+ }
+ }
+ }
+ job = (changan_http_job_t *)calloc(1, sizeof(changan_http_job_t));
+ if (job == NULL) {
+ return -101;
+ }
+ job->kind = CHANGAN_HTTP_JK_OAUTH;
+ job->req_type = CHANGAN_HTTP_REQ_OAUTH_TOKEN;
+ job->done_cb = cb;
+ job->done_ud = user_data;
+ job->u.oauth.params = (const changan_oauth_token_params_t *)changan_oauth_token_params_heap_clone(p);
+ if (job->u.oauth.params == NULL) {
+ free(job);
+ return -101;
+ }
+ job->u.oauth.resp_heap = (uint8_t *)malloc((size_t)CHANGAN_HTTP_OAUTH_RESP_CAP);
+ if (job->u.oauth.resp_heap == NULL) {
+ changan_oauth_token_params_heap_free((changan_oauth_token_params_t *)job->u.oauth.params);
+ free((void *)job->u.oauth.params);
+ free(job);
+ return -101;
+ }
+ job->u.oauth.resp_cap = CHANGAN_HTTP_OAUTH_RESP_CAP;
+ return changan_http_submit_job(job);
+}
+
+bool changan_http_oauth_parse_access_token(const char *json_resp, char *token_out, uint32_t token_cap)
+{
+ if (json_resp == NULL || token_out == NULL || token_cap == 0U) {
+ return false;
+ }
+ token_out[0] = '\0';
+ cJSON *root = cJSON_Parse(json_resp);
+ if (root == NULL) {
+ return false;
+ }
+ cJSON *tok = cJSON_GetObjectItem(root, "access_token");
+ if (tok == NULL || tok->type != cJSON_String || tok->valuestring == NULL) {
+ cJSON_Delete(root);
+ return false;
+ }
+ if (strlen(tok->valuestring) >= token_cap) {
+ cJSON_Delete(root);
+ return false;
+ }
+ if (memcpy_s(token_out, token_cap, tok->valuestring, strlen(tok->valuestring) + 1U) != 0) {
+ cJSON_Delete(root);
+ return false;
+ }
+ cJSON_Delete(root);
+ return true;
+}
+
+/* ---------- ControlCar getCarListByBrandCode(http/py/openc_car_getCarListByBrandCode_control_car_test.py) ---------- */
+
+#define CHANGAN_CTRL_HDR_SZ 4096
+#define CHANGAN_CTRL_CANON_MAX 8192
+#define CHANGAN_CTRL_HTTP_PREP_RSP_CAP_LIMIT 65536
+#define CHANGAN_CTRL_OAUTH_BOOT_RESP 2048U
+/* dkey / unlock POST body 上限;须在 changan_http_control_car_post_json 之前可见 */
+#define CHANGAN_DKEY_BODY_MAX 8192U
+
+/**
+ * 控车凭证解析过程调试:仅打印整数状态,不打印 token。默认 0,避免在 Http worker 内同步
+ * oauth 时 UART printf 阻塞或与回调重入叠加导致疑似死机;联调时在编译选项中置 1。
+ */
+#ifndef CHANGAN_HTTP_DEBUG_CTRL_RESOLVE
+#define CHANGAN_HTTP_DEBUG_CTRL_RESOLVE 0
+#endif
+
+extern char *cat1_api_runtime_get_cat1_imei(void);
+
+/** 二维码 device_id、公钥注册 deviceId 等统一使用 Cat1 IMEI;无效时回退 CHANGAN_HTTP_DKEY_DEFAULT_DEVICE_ID */
+static const char *changan_http_effective_device_id(void)
+{
+ char *imei = cat1_api_runtime_get_cat1_imei();
+
+ if (imei != NULL && imei[0] != '\0') {
+ return imei;
+ }
+ return CHANGAN_HTTP_DKEY_DEFAULT_DEVICE_ID;
+}
+
+static bool changan_ctrl_car_resolve_credentials(const char *access_token, const char *secret_key,
+ const changan_oauth_token_params_t *oauth_bootstrap,
+ char *access_buf, uint32_t access_cap, char *secret_buf, uint32_t secret_cap,
+ const char **access_eff, const char **secret_eff)
+{
+ bool need_access = true;
+ bool need_secret = true;
+ int oauth_bootstrap_http = -1;
+
+ if (access_eff == NULL || secret_eff == NULL) {
+ return false;
+ }
+ *access_eff = NULL;
+ *secret_eff = NULL;
+
+ /* 先用入参或内存全局缓存;仍缺再从落盘单行文件补入 g_changan_http_oauth_last_token 后重试 get_stored */
+ if (access_token != NULL && access_token[0] != '\0') {
+ *access_eff = access_token;
+ need_access = false;
+ } else if (changan_http_oauth_get_stored_access_token(access_buf, access_cap) && access_buf[0] != '\0') {
+ *access_eff = access_buf;
+ need_access = false;
+ }
+
+ if (secret_key != NULL && secret_key[0] != '\0') {
+ *secret_eff = secret_key;
+ need_secret = false;
+ } else if (changan_http_oauth_get_stored_secret_key(secret_buf, secret_cap) && secret_buf[0] != '\0') {
+ *secret_eff = secret_buf;
+ need_secret = false;
+ }
+
+ if (need_access || need_secret) {
+#if CHANGAN_HTTP_DEBUG_CTRL_RESOLVE
+ printf("[changan_http][ctrl_resolve] need_access=%d need_secret=%d\r\n", need_access ? 1 : 0, need_secret ? 1 : 0);
+#endif
+ changan_oauth_try_load_from_disk();
+#if CHANGAN_HTTP_DEBUG_CTRL_RESOLVE
+ printf("[changan_http][ctrl_resolve] after_try_load_from_disk\r\n");
+#endif
+ if (need_access && (access_token == NULL || access_token[0] == '\0')) {
+ if (changan_http_oauth_get_stored_access_token(access_buf, access_cap) && access_buf[0] != '\0') {
+ *access_eff = access_buf;
+ need_access = false;
+ }
+ }
+ if (need_secret && (secret_key == NULL || secret_key[0] == '\0')) {
+ if (changan_http_oauth_get_stored_secret_key(secret_buf, secret_cap) && secret_buf[0] != '\0') {
+ *secret_eff = secret_buf;
+ need_secret = false;
+ }
+ }
+ }
+
+ if ((need_access || need_secret) && oauth_bootstrap != NULL) {
+ char boot[CHANGAN_CTRL_OAUTH_BOOT_RESP];
+
+ boot[0] = '\0';
+ oauth_bootstrap_http = changan_http_oauth_token_request_do_sync(oauth_bootstrap, boot, (uint32_t)sizeof(boot));
+ if (oauth_bootstrap_http == 200) {
+ changan_http_oauth_parse_token_response_json(boot);
+ if ((need_access && g_changan_http_oauth_last_token.access_token[0] == '\0') ||
+ (need_secret && g_changan_http_oauth_last_token.secret_key[0] == '\0')) {
+ changan_oauth_try_load_from_disk();
+ }
+ if (need_access && changan_http_oauth_get_stored_access_token(access_buf, access_cap) &&
+ access_buf[0] != '\0') {
+ *access_eff = access_buf;
+ need_access = false;
+ }
+ if (need_secret && changan_http_oauth_get_stored_secret_key(secret_buf, secret_cap) &&
+ secret_buf[0] != '\0') {
+ *secret_eff = secret_buf;
+ need_secret = false;
+ }
+ }
+ }
+
+ {
+ bool ok = !need_access && !need_secret && *access_eff != NULL && (*access_eff)[0] != '\0' &&
+ *secret_eff != NULL && (*secret_eff)[0] != '\0';
+
+#if CHANGAN_HTTP_DEBUG_CTRL_RESOLVE
+ printf("[changan_http][ctrl_resolve] ok=%d need_a=%d need_s=%d oauth_http=%d\r\n", ok ? 1 : 0,
+ need_access ? 1 : 0, need_secret ? 1 : 0, oauth_bootstrap_http);
+#else
+ (void)oauth_bootstrap_http;
+#endif
+ return ok;
+ }
+}
+
+static int changan_http_get_car_list_by_brand_code_control_car_do_sync(const changan_get_car_list_by_brand_params_t *p,
+ char *resp_buf, uint32_t resp_cap)
+{
+ char ts_buf[24] = {0};
+ char query_wire[128];
+ char authorization[160];
+ char access_buf[CHANGAN_HTTP_OAUTH_STORE_ACCESS_TOKEN_MAX];
+ char secret_buf[CHANGAN_HTTP_OAUTH_STORE_SECRET_KEY_MAX];
+ changan_get_car_list_by_brand_params_t eff;
+ const char *access_eff = NULL;
+ const char *secret_eff = NULL;
+ char *req_hdr = NULL;
+ char *full_url = NULL;
+ int http_code = -1;
+
+ if (p == NULL || resp_buf == NULL || resp_cap == 0U) {
+ return -1;
+ }
+
+ resp_buf[0] = '\0';
+
+ if (!changan_ctrl_car_resolve_credentials(p->access_token, p->secret_key, p->oauth_bootstrap,
+ access_buf, (uint32_t)sizeof(access_buf), secret_buf, (uint32_t)sizeof(secret_buf), &access_eff,
+ &secret_eff)) {
+ printf("[changan_http][ctrl_car] access_token/secret_key missing; oauth token first or set oauth_bootstrap\r\n");
+ return -1;
+ }
+
+ eff = *p;
+ eff.access_token = access_eff;
+ eff.secret_key = secret_eff;
+ eff.print_control_car_sign_debug = true;
+
+ if (changan_control_car_build_authorization(&eff, ts_buf, (uint32_t)sizeof(ts_buf),
+ query_wire, (uint32_t)sizeof(query_wire), authorization, (uint32_t)sizeof(authorization)) != 0) {
+ return -1;
+ }
+
+ const char *path = (eff.api_path != NULL && eff.api_path[0] != '\0') ?
+ eff.api_path : CHANGAN_HTTP_API_PATH_GET_CAR_LIST_BY_BRAND;
+ const char *nonce = (eff.nonce != NULL && eff.nonce[0] != '\0') ? eff.nonce : "WYYL";
+
+ req_hdr = (char *)malloc((size_t)CHANGAN_CTRL_HDR_SZ);
+ full_url = (char *)malloc((size_t)CHANGAN_CTRL_CANON_MAX);
+ if (req_hdr == NULL || full_url == NULL) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+
+ if (snprintf(req_hdr, CHANGAN_CTRL_HDR_SZ,
+ "Accept: application/json, text/plain, */*\r\n"
+ "X-VCS-User-Access-Token: %s\r\n"
+ "X-VCS-Token: %s\r\n"
+ "X-VCS-Timestamp: %s\r\n"
+ "X-VCS-Nonce: %s\r\n"
+ "Authorization: %s\r\n",
+ eff.access_token, eff.access_token, ts_buf, nonce, authorization) >= CHANGAN_CTRL_HDR_SZ) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+
+ if (snprintf(full_url, CHANGAN_CTRL_CANON_MAX, "%s%s?%s",
+ CHANGAN_HTTP_SERVER, path, query_wire) >= (int)CHANGAN_CTRL_CANON_MAX) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+
+ HttpClient client = (HttpClient){0};
+ HttpClientData cd = (HttpClientData){0};
+ int prep_rsp = (int)resp_cap;
+
+ if (prep_rsp > CHANGAN_CTRL_HTTP_PREP_RSP_CAP_LIMIT) {
+ prep_rsp = CHANGAN_CTRL_HTTP_PREP_RSP_CAP_LIMIT;
+ }
+
+ if (HttpClientPrepare(&cd, CHANGAN_CTRL_HDR_SZ, prep_rsp) != HTTP_SUCCESS) {
+ free(req_hdr);
+ free(full_url);
+ printf("[changan_http][ctrl_car] HttpClientPrepare failed\r\n");
+ return -1;
+ }
+
+ cd.postBuf = NULL;
+ cd.postBufLen = 0;
+ client.header = req_hdr;
+
+ HTTPC_RESULT hr = HttpClientGetRequest(&client, full_url, &cd);
+
+ http_code = client.responseCode;
+
+ if (hr == HTTP_SUCCESS && cd.responseBuf != NULL) {
+ changan_http_apply_cd_body_to_resp(&cd, resp_buf, resp_cap);
+ }
+
+ HttpClientUnprepare(&cd);
+ free(req_hdr);
+ free(full_url);
+
+ printf("[changan_http][ctrl_car] http=%d\r\n", http_code);
+ return http_code;
+}
+
+int changan_http_get_car_list_by_brand_code_control_car(const changan_get_car_list_by_brand_params_t *p,
+ changan_http_result_cb_t cb, void *user_data)
+{
+ changan_http_job_t *job;
+
+ if (cb == NULL) {
+ return -100;
+ }
+ if (p == NULL) {
+ return -1;
+ }
+ job = (changan_http_job_t *)calloc(1, sizeof(changan_http_job_t));
+ if (job == NULL) {
+ return -101;
+ }
+ job->kind = CHANGAN_HTTP_JK_CARLIST;
+ job->req_type = CHANGAN_HTTP_REQ_GET_CAR_LIST_BY_BRAND;
+ job->done_cb = cb;
+ job->done_ud = user_data;
+ job->u.carlist.params = (const changan_get_car_list_by_brand_params_t *)changan_carlist_params_heap_clone(p);
+ if (job->u.carlist.params == NULL) {
+ free(job);
+ return -101;
+ }
+ job->u.carlist.resp_heap = (uint8_t *)malloc((size_t)CHANGAN_HTTP_CTRL_RESP_CAP);
+ if (job->u.carlist.resp_heap == NULL) {
+ changan_carlist_params_heap_free((changan_get_car_list_by_brand_params_t *)job->u.carlist.params);
+ free((void *)job->u.carlist.params);
+ free(job);
+ return -101;
+ }
+ job->u.carlist.resp_cap = CHANGAN_HTTP_CTRL_RESP_CAP;
+ return changan_http_submit_job(job);
+}
+
+/* ---------- dg / bdc / fc(ControlCarSign;对齐 http/py/openc_*_v1/v2_test.py) ---------- */
+
+static bool changan_http_ctrl_qp_append(char *buf, uint32_t cap, uint32_t *pos, const char *key, const char *val)
+{
+ char ve[768];
+ int n;
+ const char *v = (val != NULL) ? val : "";
+
+ if (!changan_ctrl_urlencode_val(v, ve, sizeof(ve))) {
+ return false;
+ }
+ if (*pos == 0U) {
+ n = snprintf(buf + *pos, (size_t)(cap - *pos), "%s=%s", key, ve);
+ } else {
+ n = snprintf(buf + *pos, (size_t)(cap - *pos), "&%s=%s", key, ve);
+ }
+ if (n < 0 || (uint32_t)n >= cap - *pos) {
+ return false;
+ }
+ *pos += (uint32_t)n;
+ return true;
+}
+
+static void changan_openc_fill_nonce4(const char *nonce_opt, char out[5])
+{
+ if (nonce_opt != NULL && nonce_opt[0] != '\0') {
+ size_t L = strlen(nonce_opt);
+
+ if (L > 4U) {
+ L = 4U;
+ }
+ (void)memcpy_s(out, 5, nonce_opt, L);
+ out[L] = '\0';
+ return;
+ }
+ changan_dkey_random_nonce4(out);
+}
+
+static int changan_http_openc_car_id_get_do_sync(const changan_openc_car_id_get_params_t *p, const char *path_default,
+ bool with_form_content_type, char *resp_buf, uint32_t resp_cap)
+{
+ char ts_buf[24] = {0};
+ char enc_car[512];
+ char query_wire[1024];
+ char authorization[160];
+ char access_buf[CHANGAN_HTTP_OAUTH_STORE_ACCESS_TOKEN_MAX];
+ char secret_buf[CHANGAN_HTTP_OAUTH_STORE_SECRET_KEY_MAX];
+ const char *access_eff = NULL;
+ const char *secret_eff = NULL;
+ char nonce4[5] = {0};
+ char *req_hdr = NULL;
+ char *full_url = NULL;
+ changan_control_car_auth_params_t auth = {0};
+ int http_code = -1;
+ const char *path_use = NULL;
+
+ if (p == NULL || path_default == NULL || p->car_id == NULL || p->car_id[0] == '\0' || resp_buf == NULL ||
+ resp_cap == 0U) {
+ return -1;
+ }
+ resp_buf[0] = '\0';
+
+ if (!changan_ctrl_car_resolve_credentials(p->access_token, p->secret_key, p->oauth_bootstrap,
+ access_buf, (uint32_t)sizeof(access_buf), secret_buf, (uint32_t)sizeof(secret_buf),
+ &access_eff, &secret_eff)) {
+ printf("[changan_http][openc_cid] access_token/secret_key missing\r\n");
+ return -1;
+ }
+
+ path_use = (p->api_path != NULL && p->api_path[0] != '\0') ? p->api_path : path_default;
+
+ if (!changan_ctrl_urlencode_val(p->car_id, enc_car, sizeof(enc_car))) {
+ printf("[changan_http][openc_cid] carId encode failed\r\n");
+ return -1;
+ }
+ if (snprintf(query_wire, sizeof(query_wire), "carId=%s", enc_car) >= (int)sizeof(query_wire)) {
+ return -1;
+ }
+
+ changan_openc_fill_nonce4(p->nonce, nonce4);
+
+ auth.access_token = access_eff;
+ auth.secret_key = secret_eff;
+ auth.timestamp = p->timestamp;
+ auth.timestamp_ms = p->timestamp_ms;
+ auth.nonce = nonce4;
+ auth.http_method = "GET";
+ auth.http_url = path_use;
+ auth.query_wire = query_wire;
+ auth.body_for_sign = "";
+
+ if (changan_control_car_build_authorization_for_http(&auth, ts_buf, (uint32_t)sizeof(ts_buf),
+ authorization, (uint32_t)sizeof(authorization)) != 0) {
+ return -1;
+ }
+
+ req_hdr = (char *)malloc((size_t)CHANGAN_CTRL_HDR_SZ);
+ full_url = (char *)malloc((size_t)CHANGAN_CTRL_CANON_MAX);
+ if (req_hdr == NULL || full_url == NULL) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+
+ if (with_form_content_type) {
+ if (snprintf(req_hdr, CHANGAN_CTRL_HDR_SZ,
+ "Accept: application/json, text/plain, */*\r\n"
+ "Content-Type: application/x-www-form-urlencoded\r\n"
+ "X-VCS-User-Access-Token: %s\r\n"
+ "X-VCS-Token: %s\r\n"
+ "X-VCS-Timestamp: %s\r\n"
+ "X-VCS-Nonce: %s\r\n"
+ "Authorization: %s\r\n",
+ access_eff, access_eff, ts_buf, nonce4, authorization) >= CHANGAN_CTRL_HDR_SZ) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+ } else {
+ if (snprintf(req_hdr, CHANGAN_CTRL_HDR_SZ,
+ "Accept: application/json, text/plain, */*\r\n"
+ "X-VCS-User-Access-Token: %s\r\n"
+ "X-VCS-Token: %s\r\n"
+ "X-VCS-Timestamp: %s\r\n"
+ "X-VCS-Nonce: %s\r\n"
+ "Authorization: %s\r\n",
+ access_eff, access_eff, ts_buf, nonce4, authorization) >= CHANGAN_CTRL_HDR_SZ) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+ }
+
+ if (snprintf(full_url, CHANGAN_CTRL_CANON_MAX, "%s%s?%s", CHANGAN_HTTP_SERVER, path_use, query_wire) >=
+ (int)CHANGAN_CTRL_CANON_MAX) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+
+ {
+ HttpClient client = (HttpClient){0};
+ HttpClientData cd = (HttpClientData){0};
+ int prep_rsp = (int)resp_cap;
+
+ if (prep_rsp > CHANGAN_CTRL_HTTP_PREP_RSP_CAP_LIMIT) {
+ prep_rsp = CHANGAN_CTRL_HTTP_PREP_RSP_CAP_LIMIT;
+ }
+ if (HttpClientPrepare(&cd, CHANGAN_CTRL_HDR_SZ, prep_rsp) != HTTP_SUCCESS) {
+ free(req_hdr);
+ free(full_url);
+ printf("[changan_http][openc_cid] HttpClientPrepare failed\r\n");
+ return -1;
+ }
+ cd.postBuf = NULL;
+ cd.postBufLen = 0;
+ client.header = req_hdr;
+ (void)HttpClientGetRequest(&client, full_url, &cd);
+ http_code = client.responseCode;
+ if (cd.responseBuf != NULL) {
+ changan_http_apply_cd_body_to_resp(&cd, resp_buf, resp_cap);
+ }
+ HttpClientUnprepare(&cd);
+ }
+
+ free(req_hdr);
+ free(full_url);
+ printf("[changan_http][openc_cid] http=%d path=%s\r\n", http_code, path_use);
+ return http_code;
+}
+
+static int changan_http_fc_get_receiver_informations_v2_do_sync(const changan_fc_get_receiver_informations_v2_params_t *p,
+ char *resp_buf, uint32_t resp_cap)
+{
+ char ts_buf[24] = {0};
+ char query_wire[2048];
+ char authorization[160];
+ char access_buf[CHANGAN_HTTP_OAUTH_STORE_ACCESS_TOKEN_MAX];
+ char secret_buf[CHANGAN_HTTP_OAUTH_STORE_SECRET_KEY_MAX];
+ const char *access_eff = NULL;
+ const char *secret_eff = NULL;
+ char nonce4[5] = {0};
+ char *req_hdr = NULL;
+ char *full_url = NULL;
+ changan_control_car_auth_params_t auth = {0};
+ int http_code = -1;
+ const char *path_use = NULL;
+ const char *action = NULL;
+ uint32_t qo = 0;
+
+ if (p == NULL || p->track_user_id == NULL || p->track_user_id[0] == '\0' || resp_buf == NULL || resp_cap == 0U) {
+ return -1;
+ }
+ resp_buf[0] = '\0';
+ query_wire[0] = '\0';
+
+ if (!changan_ctrl_car_resolve_credentials(p->access_token, p->secret_key, p->oauth_bootstrap,
+ access_buf, (uint32_t)sizeof(access_buf), secret_buf, (uint32_t)sizeof(secret_buf),
+ &access_eff, &secret_eff)) {
+ printf("[changan_http][fc_rcv] access_token/secret_key missing\r\n");
+ return -1;
+ }
+
+ path_use = (p->api_path != NULL && p->api_path[0] != '\0') ? p->api_path : CHANGAN_HTTP_API_PATH_FC_GET_RECEIVER_INFORMATIONS_V2;
+ action = (p->action_type != NULL && p->action_type[0] != '\0') ? p->action_type : "1";
+
+ if (!changan_http_ctrl_qp_append(query_wire, (uint32_t)sizeof(query_wire), &qo, "actionType", action)) {
+ return -1;
+ }
+ if (!changan_http_ctrl_qp_append(query_wire, (uint32_t)sizeof(query_wire), &qo, "trackUserId", p->track_user_id)) {
+ return -1;
+ }
+ if (p->real_receiver_id != NULL && p->real_receiver_id[0] != '\0') {
+ if (!changan_http_ctrl_qp_append(query_wire, (uint32_t)sizeof(query_wire), &qo, "realReceiverId",
+ p->real_receiver_id)) {
+ return -1;
+ }
+ }
+ if (p->trunk_full_path != NULL && p->trunk_full_path[0] != '\0') {
+ if (!changan_http_ctrl_qp_append(query_wire, (uint32_t)sizeof(query_wire), &qo, "trunkFullPath",
+ p->trunk_full_path)) {
+ return -1;
+ }
+ }
+ if (p->page != NULL && p->page[0] != '\0') {
+ if (!changan_http_ctrl_qp_append(query_wire, (uint32_t)sizeof(query_wire), &qo, "page", p->page)) {
+ return -1;
+ }
+ }
+ if (p->limit != NULL && p->limit[0] != '\0') {
+ if (!changan_http_ctrl_qp_append(query_wire, (uint32_t)sizeof(query_wire), &qo, "limit", p->limit)) {
+ return -1;
+ }
+ }
+
+ changan_openc_fill_nonce4(p->nonce, nonce4);
+
+ auth.access_token = access_eff;
+ auth.secret_key = secret_eff;
+ auth.timestamp = p->timestamp;
+ auth.timestamp_ms = p->timestamp_ms;
+ auth.nonce = nonce4;
+ auth.http_method = "POST";
+ auth.http_url = path_use;
+ auth.query_wire = query_wire;
+ auth.body_for_sign = "";
+
+ if (changan_control_car_build_authorization_for_http(&auth, ts_buf, (uint32_t)sizeof(ts_buf),
+ authorization, (uint32_t)sizeof(authorization)) != 0) {
+ return -1;
+ }
+
+ req_hdr = (char *)malloc((size_t)CHANGAN_CTRL_HDR_SZ);
+ full_url = (char *)malloc((size_t)CHANGAN_CTRL_CANON_MAX);
+ if (req_hdr == NULL || full_url == NULL) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+
+ if (snprintf(req_hdr, CHANGAN_CTRL_HDR_SZ,
+ "Accept: application/json, text/plain, */*\r\n"
+ "Content-Type: application/x-www-form-urlencoded\r\n"
+ "X-VCS-User-Access-Token: %s\r\n"
+ "X-VCS-Token: %s\r\n"
+ "X-VCS-Timestamp: %s\r\n"
+ "X-VCS-Nonce: %s\r\n"
+ "Authorization: %s\r\n",
+ access_eff, access_eff, ts_buf, nonce4, authorization) >= CHANGAN_CTRL_HDR_SZ) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+
+ if (snprintf(full_url, CHANGAN_CTRL_CANON_MAX, "%s%s?%s", CHANGAN_HTTP_SERVER, path_use, query_wire) >=
+ (int)CHANGAN_CTRL_CANON_MAX) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+
+ http_code = changan_http_control_car_post_json(full_url, req_hdr, "", resp_buf, resp_cap);
+ free(req_hdr);
+ free(full_url);
+ printf("[changan_http][fc_rcv] http=%d path=%s\r\n", http_code, path_use);
+ return http_code;
+}
+
+static int changan_http_openc_car_id_get_submit(const changan_openc_car_id_get_params_t *p, const char *path_default,
+ bool form_ct, changan_http_req_type_e req_type, changan_http_result_cb_t cb, void *user_data)
+{
+ changan_http_job_t *job;
+
+ if (cb == NULL) {
+ return -100;
+ }
+ if (p == NULL || path_default == NULL || p->car_id == NULL || p->car_id[0] == '\0') {
+ return -1;
+ }
+ job = (changan_http_job_t *)calloc(1, sizeof(changan_http_job_t));
+ if (job == NULL) {
+ return -101;
+ }
+ job->kind = CHANGAN_HTTP_JK_OPENC_CARID_GET;
+ job->req_type = req_type;
+ job->done_cb = cb;
+ job->done_ud = user_data;
+ job->u.openc_cid.params = (const changan_openc_car_id_get_params_t *)changan_openc_car_id_get_params_heap_clone(p);
+ if (job->u.openc_cid.params == NULL) {
+ free(job);
+ return -101;
+ }
+ job->u.openc_cid.path_if_api_null = path_default;
+ job->u.openc_cid.get_hdr_form_urlencoded = form_ct ? 1U : 0U;
+ job->u.openc_cid.resp_heap = (uint8_t *)malloc((size_t)CHANGAN_HTTP_CTRL_RESP_CAP);
+ if (job->u.openc_cid.resp_heap == NULL) {
+ changan_openc_car_id_get_params_heap_free((changan_openc_car_id_get_params_t *)job->u.openc_cid.params);
+ free((void *)job->u.openc_cid.params);
+ free(job);
+ return -101;
+ }
+ job->u.openc_cid.resp_cap = CHANGAN_HTTP_CTRL_RESP_CAP;
+ return changan_http_submit_job(job);
+}
+
+int changan_http_get_dg_check_result_v1(const changan_openc_car_id_get_params_t *p, changan_http_result_cb_t cb,
+ void *user_data)
+{
+ return changan_http_openc_car_id_get_submit(p, CHANGAN_HTTP_API_PATH_DG_CHECK_RESULT_V1, true,
+ CHANGAN_HTTP_REQ_GET_DG_CHECK_RESULT_V1, cb, user_data);
+}
+
+int changan_http_get_bdc_car_info_use_car_id_v1(const changan_openc_car_id_get_params_t *p, changan_http_result_cb_t cb,
+ void *user_data)
+{
+ return changan_http_openc_car_id_get_submit(p, CHANGAN_HTTP_API_PATH_BDC_GET_CAR_INFO_USE_CAR_ID_V1, false,
+ CHANGAN_HTTP_REQ_GET_BDC_CAR_INFO_USE_CAR_ID_V1, cb, user_data);
+}
+
+int changan_http_post_fc_get_receiver_informations_v2(const changan_fc_get_receiver_informations_v2_params_t *p,
+ changan_http_result_cb_t cb, void *user_data)
+{
+ changan_http_job_t *job;
+
+ if (cb == NULL) {
+ return -100;
+ }
+ if (p == NULL || p->track_user_id == NULL || p->track_user_id[0] == '\0') {
+ return -1;
+ }
+ job = (changan_http_job_t *)calloc(1, sizeof(changan_http_job_t));
+ if (job == NULL) {
+ return -101;
+ }
+ job->kind = CHANGAN_HTTP_JK_FC_RECEIVER_INFO;
+ job->req_type = CHANGAN_HTTP_REQ_POST_FC_GET_RECEIVER_INFORMATIONS_V2;
+ job->done_cb = cb;
+ job->done_ud = user_data;
+ job->u.fc_rcv.params =
+ (const changan_fc_get_receiver_informations_v2_params_t *)changan_fc_rcv_params_heap_clone(p);
+ if (job->u.fc_rcv.params == NULL) {
+ free(job);
+ return -101;
+ }
+ job->u.fc_rcv.resp_heap = (uint8_t *)malloc((size_t)CHANGAN_HTTP_CTRL_RESP_CAP);
+ if (job->u.fc_rcv.resp_heap == NULL) {
+ changan_fc_rcv_params_heap_free((changan_fc_get_receiver_informations_v2_params_t *)job->u.fc_rcv.params);
+ free((void *)job->u.fc_rcv.params);
+ free(job);
+ return -101;
+ }
+ job->u.fc_rcv.resp_cap = CHANGAN_HTTP_CTRL_RESP_CAP;
+ return changan_http_submit_job(job);
+}
+
+/* ---------- dkey public-key-register / download-owner-key(py/openc_dkey_register_and_download_owner_key_control_car_test.py) ---------- */
+
+#define CHANGAN_DKEY_SIGN_B64_MAX 512U
+#define CHANGAN_DKEY_PUBLIC_KEY_ID_MAX 64U
+
+static void changan_dkey_random_nonce4(char out[5])
+{
+ static const char C[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+ uint32_t seed = (uint32_t)time(NULL) ^ (uint32_t)osKernelGetTickCount();
+
+ for (int i = 0; i < 4; i++) {
+ seed = seed * 1103515245U + 12345U;
+ out[i] = C[seed % (sizeof(C) - 1U)];
+ }
+ out[4] = '\0';
+}
+
+static void changan_dkey_random_body_nonce16(char out[17])
+{
+ static const char H[] = "0123456789ABCDEF";
+ uint32_t seed = (uint32_t)time(NULL) ^ (uint32_t)osKernelGetTickCount() ^ 0x444B4559u; /* 'DKEY' */
+
+ for (int i = 0; i < 16; i++) {
+ seed = seed * 1103515245U + 12345U + (uint32_t)i;
+ out[i] = H[seed % 16U];
+ }
+ out[16] = '\0';
+}
+
+static int changan_http_control_car_post_json_do_sync(const char *url, const char *req_hdr, const char *body,
+ char *resp_buf, uint32_t resp_cap)
+{
+ HttpClient client = (HttpClient){0};
+ HttpClientData cd = (HttpClientData){0};
+ int prep_rsp = (int)resp_cap;
+ int http_code = -1;
+
+ if (url == NULL || req_hdr == NULL || body == NULL || resp_buf == NULL || resp_cap == 0U) {
+ return -1;
+ }
+ resp_buf[0] = '\0';
+
+ if (prep_rsp > CHANGAN_CTRL_HTTP_PREP_RSP_CAP_LIMIT) {
+ prep_rsp = CHANGAN_CTRL_HTTP_PREP_RSP_CAP_LIMIT;
+ }
+ if (HttpClientPrepare(&cd, CHANGAN_CTRL_HDR_SZ, prep_rsp) != HTTP_SUCCESS) {
+ printf("[changan_http][dkey] HttpClientPrepare failed\r\n");
+ return -1;
+ }
+
+ cd.postBuf = (char *)body;
+ cd.postBufLen = (int)strlen(body);
+ client.header = req_hdr;
+
+ HTTPC_RESULT hr = HttpClientPostRequest(&client, url, &cd);
+
+ http_code = client.responseCode;
+ if (hr == HTTP_SUCCESS && cd.responseBuf != NULL) {
+ changan_http_apply_cd_body_to_resp(&cd, resp_buf, resp_cap);
+ }
+
+ HttpClientUnprepare(&cd);
+ return http_code;
+}
+
+static int changan_http_control_car_post_json(const char *url, const char *req_hdr, const char *body,
+ char *resp_buf, uint32_t resp_cap)
+{
+ (void)changan_http_worker_init();
+ return changan_http_control_car_post_json_do_sync(url, req_hdr, body, resp_buf, resp_cap);
+}
+
+/* ---------- vrtm car-control v2 POST(http/py/openc_car_control_v2_test.py) ---------- */
+
+typedef struct {
+ const char *url_segment;
+ const char *body_cmd;
+} changan_vrtm_car_ctrl_meta_t;
+
+static const changan_vrtm_car_ctrl_meta_t k_changan_vrtm_car_ctrl_meta[CHANGAN_VRTM_CAR_CTRL_COUNT] = {
+ [CHANGAN_VRTM_CAR_CTRL_CLOSE_AIR] = { "closeAir", "closeAir" },
+ [CHANGAN_VRTM_CAR_CTRL_CLOSE_WINDOW] = { "closeWindow", "CloseWindow" },
+ [CHANGAN_VRTM_CAR_CTRL_FLASH_LIGHT] = { "flashLight", "flashLight" },
+ [CHANGAN_VRTM_CAR_CTRL_LOCK_DOOR] = { "lockDoor", "LockDoor" },
+ [CHANGAN_VRTM_CAR_CTRL_OPEN_AIR] = { "openAir", "openAir" },
+ [CHANGAN_VRTM_CAR_CTRL_REMOTE_SEARCH_CAR] = { "remoteSearchCar", "remoteSearchCar" },
+ [CHANGAN_VRTM_CAR_CTRL_UNLOCK_DOOR] = { "unLockDoor", "UnLockDoor" },
+ [CHANGAN_VRTM_CAR_CTRL_WINDOW_SLIT] = { "windowSlit", "windowSlit" },
+ [CHANGAN_VRTM_CAR_CTRL_UP_CAR_CONDITION] = { "upCarCondition", "upCarCondition" },
+};
+
+static bool changan_vrtm_car_control_build_body_json(const char *map_args_json, const char *sender_type,
+ const char *cmd, const char *car_id, char *out, uint32_t cap)
+{
+ const char *mapj = (map_args_json != NULL && map_args_json[0] != '\0') ? map_args_json : "{}";
+ const char *snd = (sender_type != NULL && sender_type[0] != '\0') ? sender_type : "APP";
+ int n;
+
+ if (car_id == NULL || car_id[0] == '\0' || cmd == NULL || cmd[0] == '\0' || out == NULL || cap < 64U) {
+ return false;
+ }
+ if (strchr(mapj, '"') != NULL || strchr(car_id, '"') != NULL || strchr(snd, '"') != NULL ||
+ strchr(cmd, '"') != NULL) {
+ printf("[changan_http][vrtm_ctrl] mapArgsJson/carId/senderType/cmd must not contain raw \"\r\n");
+ return false;
+ }
+ n = snprintf(out, cap, "{\"mapArgsJson\":\"%s\",\"senderType\":\"%s\",\"cmd\":\"%s\",\"carId\":\"%s\"}",
+ mapj, snd, cmd, car_id);
+ return n > 0 && (uint32_t)n < cap;
+}
+
+static int changan_http_post_vrtm_car_control_v2_impl(const changan_vrtm_car_control_v2_params_t *p, char *resp_buf,
+ uint32_t resp_cap, changan_http_req_type_e req_type)
+{
+ (void)req_type;
+ char access_buf[CHANGAN_HTTP_OAUTH_STORE_ACCESS_TOKEN_MAX];
+ char secret_buf[CHANGAN_HTTP_OAUTH_STORE_SECRET_KEY_MAX];
+ char ts_buf[24] = {0};
+ char path_buf[160];
+ char authorization[160];
+ const char *access_eff = NULL;
+ const char *secret_eff = NULL;
+ const char *path_use = NULL;
+ const char *cmd_use = NULL;
+ const char *nonce_hdr = NULL;
+ char *req_hdr = NULL;
+ char *full_url = NULL;
+ char *body = NULL;
+ changan_control_car_auth_params_t auth = {0};
+ int http_code = -1;
+
+ if (p == NULL || p->car_id == NULL || p->car_id[0] == '\0' || resp_buf == NULL || resp_cap == 0U) {
+ return -1;
+ }
+ if ((int)p->command < 0 || p->command >= CHANGAN_VRTM_CAR_CTRL_COUNT) {
+ printf("[changan_http][vrtm_ctrl] invalid command\r\n");
+ return -1;
+ }
+
+ resp_buf[0] = '\0';
+
+ if (!changan_ctrl_car_resolve_credentials(p->access_token, p->secret_key, p->oauth_bootstrap,
+ access_buf, (uint32_t)sizeof(access_buf), secret_buf, (uint32_t)sizeof(secret_buf),
+ &access_eff, &secret_eff)) {
+ printf("[changan_http][vrtm_ctrl] access_token/secret_key missing\r\n");
+ return -1;
+ }
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t1 cred_lens at=%u sk=%u\r\n",
+ (unsigned)strnlen(access_eff, (size_t)CHANGAN_HTTP_OAUTH_STORE_ACCESS_TOKEN_MAX),
+ (unsigned)strnlen(secret_eff, (size_t)CHANGAN_HTTP_OAUTH_STORE_SECRET_KEY_MAX));
+#endif
+
+ cmd_use = (p->body_cmd_override != NULL && p->body_cmd_override[0] != '\0') ?
+ p->body_cmd_override : k_changan_vrtm_car_ctrl_meta[p->command].body_cmd;
+
+ if (p->api_path != NULL && p->api_path[0] != '\0') {
+ path_use = p->api_path;
+ } else {
+ if (snprintf(path_buf, sizeof(path_buf), "%s%s", CHANGAN_HTTP_API_PATH_VRTM_CAR_CONTROL_PREFIX,
+ k_changan_vrtm_car_ctrl_meta[p->command].url_segment) >= (int)sizeof(path_buf)) {
+ return -1;
+ }
+ path_use = path_buf;
+ }
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t2 cmd=%u path_len=%u cmd_use_len=%u\r\n", (unsigned)p->command,
+ (unsigned)strnlen(path_use, 512U), (unsigned)strnlen(cmd_use, 64U));
+#endif
+
+ body = (char *)malloc((size_t)CHANGAN_DKEY_BODY_MAX);
+ if (body == NULL) {
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t3 body_malloc fail\r\n");
+#endif
+ return -1;
+ }
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t3 body_malloc ok\r\n");
+#endif
+ if (!changan_vrtm_car_control_build_body_json(p->map_args_json, p->sender_type, cmd_use, p->car_id, body,
+ CHANGAN_DKEY_BODY_MAX)) {
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t4 build_body_json fail\r\n");
+#endif
+ free(body);
+ return -1;
+ }
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t4 body_len=%u\r\n", (unsigned)strnlen(body, (size_t)CHANGAN_DKEY_BODY_MAX));
+#endif
+
+ auth.access_token = access_eff;
+ auth.secret_key = secret_eff;
+ auth.timestamp = p->timestamp;
+ auth.timestamp_ms = p->timestamp_ms;
+ auth.nonce = p->nonce;
+ auth.http_method = "POST";
+ auth.http_url = path_use;
+ auth.query_wire = "";
+ auth.body_for_sign = body;
+
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t5 before build_authorization_for_http\r\n");
+#endif
+ if (changan_control_car_build_authorization_for_http(&auth, ts_buf, (uint32_t)sizeof(ts_buf),
+ authorization, (uint32_t)sizeof(authorization)) != 0) {
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t5 build_authorization_for_http fail\r\n");
+#endif
+ free(body);
+ return -1;
+ }
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t6 after build_authorization_for_http ts_len=%u auth_len=%u\r\n",
+ (unsigned)strnlen(ts_buf, sizeof(ts_buf)), (unsigned)strnlen(authorization, sizeof(authorization)));
+#endif
+
+ nonce_hdr = (p->nonce != NULL && p->nonce[0] != '\0') ? p->nonce : "WYYL";
+
+ req_hdr = (char *)malloc((size_t)CHANGAN_CTRL_HDR_SZ);
+ full_url = (char *)malloc((size_t)CHANGAN_CTRL_CANON_MAX);
+ if (req_hdr == NULL || full_url == NULL) {
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t7 hdr/url malloc fail\r\n");
+#endif
+ free(req_hdr);
+ free(full_url);
+ free(body);
+ return -1;
+ }
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t7 hdr/url malloc ok\r\n");
+#endif
+
+ {
+ int nh;
+
+ nh = snprintf(req_hdr, CHANGAN_CTRL_HDR_SZ,
+ "Accept: application/json, text/plain, */*\r\n"
+ "Content-Type: application/json\r\n"
+ "X-VCS-User-Access-Token: %s\r\n"
+ "X-VCS-Token: %s\r\n"
+ "X-VCS-Timestamp: %s\r\n"
+ "X-VCS-Nonce: %s\r\n"
+ "Authorization: %s\r\n",
+ access_eff, access_eff, ts_buf, nonce_hdr, authorization);
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t8 snprintf req_hdr ret=%d cap=%d\r\n", nh, CHANGAN_CTRL_HDR_SZ);
+#endif
+ if (nh >= CHANGAN_CTRL_HDR_SZ) {
+ free(req_hdr);
+ free(full_url);
+ free(body);
+ return -1;
+ }
+ }
+
+ {
+ int nu;
+
+ nu = snprintf(full_url, CHANGAN_CTRL_CANON_MAX, "%s%s", CHANGAN_HTTP_SERVER, path_use);
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t9 snprintf full_url ret=%d\r\n", nu);
+#endif
+ if (nu >= (int)CHANGAN_CTRL_CANON_MAX) {
+ free(req_hdr);
+ free(full_url);
+ free(body);
+ return -1;
+ }
+ }
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t10 before HttpClientPost path_len=%u\r\n",
+ (unsigned)strnlen(full_url, (size_t)CHANGAN_CTRL_CANON_MAX));
+#endif
+
+ http_code = changan_http_control_car_post_json(full_url, req_hdr, body, resp_buf, resp_cap);
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_http][vrtm_trace] t11 after HttpClientPost http=%d\r\n", http_code);
+#endif
+ free(req_hdr);
+ free(full_url);
+ free(body);
+
+ printf("[changan_http][vrtm_ctrl] http=%d path=%s cmd=%s\r\n", http_code, path_use, cmd_use);
+ return http_code;
+}
+
+static int changan_http_post_vrtm_car_control_v2_submit(const changan_vrtm_car_control_v2_params_t *p,
+ changan_http_req_type_e req_type, changan_http_result_cb_t cb, void *user_data)
+{
+ changan_http_job_t *job;
+
+ if (cb == NULL) {
+ return -100;
+ }
+ if (p == NULL) {
+ return -1;
+ }
+ job = (changan_http_job_t *)calloc(1, sizeof(changan_http_job_t));
+ if (job == NULL) {
+ return -101;
+ }
+ job->kind = CHANGAN_HTTP_JK_VRTM;
+ job->req_type = req_type;
+ job->done_cb = cb;
+ job->done_ud = user_data;
+ job->u.vrtm.params = changan_http_vrtm_params_heap_clone(p);
+ if (job->u.vrtm.params == NULL) {
+ free(job);
+ return -101;
+ }
+ job->u.vrtm.resp_heap = (uint8_t *)malloc((size_t)CHANGAN_HTTP_CTRL_RESP_CAP);
+ if (job->u.vrtm.resp_heap == NULL) {
+ changan_http_vrtm_params_heap_free((changan_vrtm_car_control_v2_params_t *)job->u.vrtm.params);
+ free((void *)job->u.vrtm.params);
+ free(job);
+ return -101;
+ }
+ job->u.vrtm.resp_cap = CHANGAN_HTTP_CTRL_RESP_CAP;
+ return changan_http_submit_job(job);
+}
+
+int changan_http_post_vrtm_car_control_v2(const changan_vrtm_car_control_v2_params_t *p,
+ changan_http_result_cb_t cb, void *user_data)
+{
+ return changan_http_post_vrtm_car_control_v2_submit(p, CHANGAN_HTTP_REQ_POST_VRTM_CAR_CONTROL_V2, cb, user_data);
+}
+
+#ifndef CHANGAN_DKEY_STORE_PUBLIC_KEY_REGISTER_PATH
+/** 文本:首行 1=已向服务端成功注册公钥、0=否;次行为 public_key_id(仅首行为 1 时有效) */
+#define CHANGAN_DKEY_STORE_PUBLIC_KEY_REGISTER_PATH "/user/changan_dkey_pk_register.txt"
+#endif
+#ifndef CHANGAN_DKEY_BLE_MAC_STR_CAP
+#define CHANGAN_DKEY_BLE_MAC_STR_CAP 32U
+#endif
+
+static bool changan_dkey_file_read_trimmed(const char *path, char *out, uint32_t cap)
+{
+ FILE *fp;
+ long sz;
+ size_t rd;
+ char *p;
+ size_t i;
+
+ if (path == NULL || out == NULL || cap < 2U) {
+ return false;
+ }
+ fp = fopen(path, "rb");
+ if (fp == NULL) {
+ return false;
+ }
+ if (fseek(fp, 0, SEEK_END) != 0) {
+ fclose(fp);
+ return false;
+ }
+ sz = ftell(fp);
+ if (sz < 0 || sz >= (long)cap) {
+ fclose(fp);
+ return false;
+ }
+ if (fseek(fp, 0, SEEK_SET) != 0) {
+ fclose(fp);
+ return false;
+ }
+ rd = fread(out, 1U, (size_t)sz, fp);
+ fclose(fp);
+ if (rd != (size_t)sz) {
+ return false;
+ }
+ out[rd] = '\0';
+ p = out;
+ while (*p == ' ' || *p == '\t' || *p == '\r' || *p == '\n') {
+ p++;
+ }
+ if (p != out) {
+ memmove(out, p, strlen(p) + 1U);
+ }
+ i = strlen(out);
+ while (i > 0U && (out[i - 1U] == ' ' || out[i - 1U] == '\t' || out[i - 1U] == '\r' || out[i - 1U] == '\n')) {
+ i--;
+ out[i] = '\0';
+ }
+ return out[0] != '\0';
+}
+
+static void changan_dkey_save_keypair_to_files(const char *pem, const char *spki_b64)
+{
+ FILE *fp;
+
+ if (pem != NULL && pem[0] != '\0') {
+ fp = fopen(CHANGAN_DKEY_STORE_PRIVATE_PEM_PATH, "wb");
+ if (fp != NULL) {
+ (void)fwrite(pem, 1U, strlen(pem), fp);
+ (void)fclose(fp);
+ } else {
+ printf("[changan_http] dkey save private pem failed: %s\r\n", CHANGAN_DKEY_STORE_PRIVATE_PEM_PATH);
+ }
+ }
+ if (spki_b64 != NULL && spki_b64[0] != '\0') {
+ fp = fopen(CHANGAN_DKEY_STORE_SPKI_B64_PATH, "wb");
+ if (fp != NULL) {
+ (void)fwrite(spki_b64, 1U, strlen(spki_b64), fp);
+ (void)fclose(fp);
+ } else {
+ printf("[changan_http] dkey save spki b64 failed: %s\r\n", CHANGAN_DKEY_STORE_SPKI_B64_PATH);
+ }
+ }
+}
+
+
+static void changan_dkey_save_public_key_register_to_file(bool registered_ok, const char *public_key_id)
+{
+ FILE *fp;
+ char buf[CHANGAN_HTTP_PUBLIC_KEY_ID_MAX + 16U];
+ int n;
+
+ if (registered_ok && public_key_id != NULL && public_key_id[0] != '\0') {
+ n = snprintf(buf, sizeof(buf), "1\n%s\n", public_key_id);
+ } else {
+ n = snprintf(buf, sizeof(buf), "0\n");
+ }
+ if (n <= 0 || (size_t)n >= sizeof(buf)) {
+ printf("[changan_http] dkey save pk_register internal buf overflow\r\n");
+ return;
+ }
+ fp = fopen(CHANGAN_DKEY_STORE_PUBLIC_KEY_REGISTER_PATH, "wb");
+ if (fp != NULL) {
+ (void)fwrite(buf, 1U, (size_t)n, fp);
+ (void)fclose(fp);
+ printf("[changan_http] dkey save pk_register ok -> %s (registered=%d)\r\n",
+ CHANGAN_DKEY_STORE_PUBLIC_KEY_REGISTER_PATH, registered_ok ? 1 : 0);
+ } else {
+ printf("[changan_http] dkey save pk_register failed: %s\r\n", CHANGAN_DKEY_STORE_PUBLIC_KEY_REGISTER_PATH);
+ }
+}
+
+int changan_http_dkey_store_private_pem_file(const char *pem)
+{
+ if (pem == NULL || pem[0] == '\0') {
+ return -1;
+ }
+ changan_dkey_save_keypair_to_files(pem, NULL);
+ return 0;
+}
+
+int changan_http_dkey_load_stored_public_key_register(bool *registered_ok_out, char *public_key_id_out,
+ uint32_t public_key_id_cap)
+{
+ FILE *fp;
+ long sz;
+ size_t rd;
+ char *p;
+ char *q;
+ char *end;
+ char filebuf[CHANGAN_HTTP_PUBLIC_KEY_ID_MAX + 64U];
+
+ if (registered_ok_out == NULL) {
+ return -1;
+ }
+ *registered_ok_out = false;
+ if (public_key_id_out != NULL && public_key_id_cap > 0U) {
+ public_key_id_out[0] = '\0';
+ }
+ fp = fopen(CHANGAN_DKEY_STORE_PUBLIC_KEY_REGISTER_PATH, "rb");
+ if (fp == NULL) {
+ return -2;
+ }
+ if (fseek(fp, 0, SEEK_END) != 0) {
+ fclose(fp);
+ return -2;
+ }
+ sz = ftell(fp);
+ if (sz < 0 || sz >= (long)sizeof(filebuf)) {
+ fclose(fp);
+ return -2;
+ }
+ if (fseek(fp, 0, SEEK_SET) != 0) {
+ fclose(fp);
+ return -2;
+ }
+ rd = fread(filebuf, 1U, (size_t)sz, fp);
+ fclose(fp);
+ if (rd != (size_t)sz) {
+ return -2;
+ }
+ filebuf[rd] = '\0';
+ p = filebuf;
+ while (*p == ' ' || *p == '\t' || *p == '\r' || *p == '\n') {
+ p++;
+ }
+ if (p[0] != '0' && p[0] != '1') {
+ return -2;
+ }
+ if (p[0] == '0') {
+ *registered_ok_out = false;
+ return 0;
+ }
+ p++;
+ if (*p != '\n' && *p != '\r' && *p != '\0') {
+ return -2;
+ }
+ while (*p == '\n' || *p == '\r') {
+ p++;
+ }
+ q = p;
+ while (*q != '\0' && *q != '\r' && *q != '\n') {
+ q++;
+ }
+ *q = '\0';
+ end = q;
+ while (end > p && (end[-1] == ' ' || end[-1] == '\t')) {
+ end--;
+ *end = '\0';
+ }
+ if (p[0] == '\0') {
+ return -2;
+ }
+ *registered_ok_out = true;
+ if (public_key_id_out != NULL && public_key_id_cap > 0U) {
+ size_t idl = strlen(p);
+
+ if (idl >= (size_t)public_key_id_cap) {
+ idl = (size_t)public_key_id_cap - 1U;
+ }
+ if (memcpy_s(public_key_id_out, public_key_id_cap, p, idl) != 0) {
+ public_key_id_out[0] = '\0';
+ *registered_ok_out = false;
+ return -2;
+ }
+ public_key_id_out[idl] = '\0';
+ }
+ return 0;
+}
+
+static bool changan_dkey_build_register_body(const changan_dkey_public_key_register_params_t *p,
+ char *out, uint32_t cap)
+{
+ const char *app = (p->app_id != NULL && p->app_id[0] != '\0') ? p->app_id : CHANGAN_HTTP_DKEY_DEFAULT_APP_ID;
+ const char *dev = changan_http_effective_device_id();
+ const char *algo = (p->algorithm != NULL && p->algorithm[0] != '\0') ? p->algorithm : "RSA";
+ int n;
+
+ if (p->public_key_spki_b64 == NULL || p->user_id == NULL) {
+ return false;
+ }
+ n = snprintf(out, cap,
+ "{\"publicKey\":\"%s\",\"algorithm\":\"%s\",\"appId\":\"%s\",\"userId\":\"%s\",\"deviceId\":\"%s\"}",
+ p->public_key_spki_b64, algo, app, p->user_id, dev);
+ return n > 0 && (uint32_t)n < cap;
+}
+
+static bool changan_dkey_build_download_body(const changan_dkey_download_owner_key_params_t *p,
+ const char *body_nonce, const char *sign_b64, char *out, uint32_t cap)
+{
+ char proto[16];
+ int protocol = (p->protocol_type != 0) ? p->protocol_type : 1;
+ int n;
+
+ if (p->car_id == NULL || p->public_key_id == NULL || p->user_id == NULL || sign_b64 == NULL) {
+ return false;
+ }
+ (void)snprintf(proto, sizeof(proto), "%d", protocol);
+ if (p->protocol_type_json_number) {
+ n = snprintf(out, cap,
+ "{\"carId\":\"%s\",\"nonce\":\"%s\",\"privateKeySign\":\"%s\",\"protocolType\":%d,\"publicKeyId\":\"%s\",\"userId\":\"%s\"}",
+ p->car_id, body_nonce, sign_b64, protocol, p->public_key_id, p->user_id);
+ } else {
+ n = snprintf(out, cap,
+ "{\"carId\":\"%s\",\"nonce\":\"%s\",\"privateKeySign\":\"%s\",\"protocolType\":\"%s\",\"publicKeyId\":\"%s\",\"userId\":\"%s\"}",
+ p->car_id, body_nonce, sign_b64, proto, p->public_key_id, p->user_id);
+ }
+ return n > 0 && (uint32_t)n < cap;
+}
+
+/**
+ * 从原始 JSON 文本解析根对象里 "data" 的值(字符串或纯数字),避免 cJSON 将大整数放进 double 丢精度、
+ * 以及 valueint 溢出(如 2147483647)。对齐 py:public_key_id_str = str(reg_json["data"])。
+ */
+static bool changan_dkey_extract_root_data_string(const char *json_resp, char *out, uint32_t cap)
+{
+ const char *k;
+ const char *p;
+ const char *beg;
+ size_t n;
+
+ if (json_resp == NULL || out == NULL || cap < 2U) {
+ return false;
+ }
+ k = strstr(json_resp, "\"data\"");
+ if (k == NULL) {
+ return false;
+ }
+ p = strchr(k + 6, ':');
+ if (p == NULL) {
+ return false;
+ }
+ p++;
+ while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r') {
+ p++;
+ }
+ if (*p == '"') {
+ p++;
+ beg = p;
+ while (*p != '\0' && *p != '"') {
+ p++;
+ }
+ n = (size_t)(p - beg);
+ if (*p != '"' || n + 1U > (size_t)cap) {
+ return false;
+ }
+ if (memcpy_s(out, cap, beg, n) != 0) {
+ return false;
+ }
+ out[n] = '\0';
+ return true;
+ }
+ if (*p == '-' || (*p >= '0' && *p <= '9')) {
+ beg = p;
+ if (*p == '-') {
+ p++;
+ }
+ if (*p < '0' || *p > '9') {
+ return false;
+ }
+ while (*p >= '0' && *p <= '9') {
+ p++;
+ }
+ n = (size_t)(p - beg);
+ if (n + 1U > (size_t)cap || n == 0U) {
+ return false;
+ }
+ if (memcpy_s(out, cap, beg, n) != 0) {
+ return false;
+ }
+ out[n] = '\0';
+ return true;
+ }
+ return false;
+}
+
+static bool changan_dkey_parse_register_public_key_id(const char *json_resp, char *out, uint32_t cap)
+{
+ cJSON *root = NULL;
+ cJSON *code = NULL;
+ cJSON *success = NULL;
+ cJSON *data = NULL;
+ bool ok = false;
+
+ if (json_resp == NULL || out == NULL || cap == 0U) {
+ return false;
+ }
+ out[0] = '\0';
+ root = cJSON_Parse(json_resp);
+ if (root == NULL) {
+ return false;
+ }
+ code = cJSON_GetObjectItem(root, "code");
+ success = cJSON_GetObjectItem(root, "success");
+ if (code == NULL || !cJSON_IsNumber(code) || code->valueint != 0) {
+ goto EXIT;
+ }
+ if (success != NULL && cJSON_IsBool(success) && !cJSON_IsTrue(success)) {
+ goto EXIT;
+ }
+ data = cJSON_GetObjectItem(root, "data");
+ if (data == NULL) {
+ goto EXIT;
+ }
+ /* 优先从原文截取 data,兼容大整数与字符串两种形态 */
+ if (changan_dkey_extract_root_data_string(json_resp, out, cap)) {
+ ok = true;
+ goto EXIT;
+ }
+ if (cJSON_IsString(data) && data->valuestring != NULL) {
+ if (strlen(data->valuestring) + 1U > (size_t)cap) {
+ goto EXIT;
+ }
+ if (memcpy_s(out, cap, data->valuestring, strlen(data->valuestring) + 1U) != 0) {
+ goto EXIT;
+ }
+ ok = true;
+ } else if (cJSON_IsNumber(data)) {
+ /* 原文截取失败时的兜底:尽量用双精度整数格式化(可能丢精度,仅作后备) */
+ double dv = cJSON_GetNumberValue(data);
+
+ if (snprintf(out, cap, "%.0f", dv) >= (int)cap || out[0] == '\0') {
+ goto EXIT;
+ }
+ ok = true;
+ }
+
+EXIT:
+ cJSON_Delete(root);
+ return ok;
+}
+
+static int changan_dkey_post_control_car(const char *path, const char *access_token, const char *secret_key,
+ bool timestamp_ms, const char *timestamp, const char *header_nonce,
+ const char *body_wire, char *resp_buf, uint32_t resp_cap, changan_http_req_type_e req_type)
+{
+ char ts_buf[24] = {0};
+ char authorization[160];
+ char nonce4[5] = {0};
+ char *req_hdr = NULL;
+ char *full_url = NULL;
+ changan_control_car_auth_params_t auth = {0};
+ int http_code = -1;
+
+ (void)req_type;
+ if (path == NULL || access_token == NULL || secret_key == NULL || body_wire == NULL ||
+ resp_buf == NULL || resp_cap == 0U) {
+ return -1;
+ }
+
+ if (header_nonce != NULL && header_nonce[0] != '\0') {
+ if (strlen(header_nonce) >= sizeof(nonce4)) {
+ return -1;
+ }
+ (void)memcpy_s(nonce4, sizeof(nonce4), header_nonce, strlen(header_nonce) + 1U);
+ } else {
+ changan_dkey_random_nonce4(nonce4);
+ }
+
+ auth.access_token = access_token;
+ auth.secret_key = secret_key;
+ auth.timestamp = timestamp;
+ auth.timestamp_ms = timestamp_ms;
+ auth.nonce = nonce4;
+ auth.http_method = "POST";
+ auth.http_url = path;
+ auth.query_wire = NULL;
+ auth.body_for_sign = body_wire;
+
+ if (changan_control_car_build_authorization_for_http(&auth, ts_buf, (uint32_t)sizeof(ts_buf),
+ authorization, (uint32_t)sizeof(authorization)) != 0) {
+ return -1;
+ }
+
+ req_hdr = (char *)malloc((size_t)CHANGAN_CTRL_HDR_SZ);
+ full_url = (char *)malloc((size_t)CHANGAN_CTRL_CANON_MAX);
+ if (req_hdr == NULL || full_url == NULL) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+
+ if (snprintf(req_hdr, CHANGAN_CTRL_HDR_SZ,
+ "Accept: application/json, text/plain, */*\r\n"
+ "Content-Type: application/json\r\n"
+ "X-VCS-User-Access-Token: %s\r\n"
+ "X-VCS-Token: %s\r\n"
+ "X-VCS-Timestamp: %s\r\n"
+ "X-VCS-Nonce: %s\r\n"
+ "Authorization: %s\r\n",
+ access_token, access_token, ts_buf, nonce4, authorization) >= CHANGAN_CTRL_HDR_SZ) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+ if (snprintf(full_url, CHANGAN_CTRL_CANON_MAX, "%s%s", CHANGAN_HTTP_SERVER, path) >= (int)CHANGAN_CTRL_CANON_MAX) {
+ free(req_hdr);
+ free(full_url);
+ return -1;
+ }
+
+ http_code = changan_http_control_car_post_json(full_url, req_hdr, body_wire, resp_buf, resp_cap);
+ free(req_hdr);
+ free(full_url);
+ return http_code;
+}
+
+int changan_http_dkey_public_key_register(const changan_dkey_public_key_register_params_t *p,
+ changan_http_result_cb_t cb, void *user_data)
+{
+ changan_http_job_t *job;
+
+ if (cb == NULL) {
+ return -100;
+ }
+ if (p == NULL) {
+ return -1;
+ }
+ job = (changan_http_job_t *)calloc(1, sizeof(changan_http_job_t));
+ if (job == NULL) {
+ return -101;
+ }
+ job->kind = CHANGAN_HTTP_JK_DKEY_REG;
+ job->req_type = CHANGAN_HTTP_REQ_DKEY_PUBLIC_KEY_REGISTER;
+ job->done_cb = cb;
+ job->done_ud = user_data;
+ job->u.dreg.p = (const changan_dkey_public_key_register_params_t *)changan_dkey_reg_params_heap_clone(p);
+ if (job->u.dreg.p == NULL) {
+ free(job);
+ return -101;
+ }
+ job->u.dreg.resp_heap = (uint8_t *)malloc((size_t)CHANGAN_HTTP_CTRL_RESP_CAP);
+ if (job->u.dreg.resp_heap == NULL) {
+ changan_dkey_reg_params_heap_free((changan_dkey_public_key_register_params_t *)job->u.dreg.p);
+ free((void *)job->u.dreg.p);
+ free(job);
+ return -101;
+ }
+ job->u.dreg.resp_cap = CHANGAN_HTTP_CTRL_RESP_CAP;
+ job->u.dreg.public_key_id_buf[0] = '\0';
+ return changan_http_submit_job(job);
+}
+
+int changan_http_dkey_ensure_owner_key_for_vehicle(const changan_http_dkey_ensure_owner_key_params_t *params,
+ changan_http_result_cb_t download_done_cb, void *download_user_data)
+{
+ int rr;
+ int prep;
+
+ if (params == NULL) {
+ return -1;
+ }
+ if (g_changan_dkey_ensure_pending != 0U) {
+ return -103;
+ }
+ if (params->vehicle_car_id != NULL && params->vehicle_car_id[0] != '\0' &&
+ ble_icce_changan_auth_card_identity_ready(params->vehicle_car_id)) {
+ return 0;
+ }
+
+ prep = changan_dkey_ensure_prepare_from_params(params);
+ if (prep != 0) {
+ return prep;
+ }
+ g_changan_dkey_ensure_dl_done_cb =
+ (download_done_cb != NULL) ? download_done_cb : changan_dkey_ensure_download_noop_cb;
+ g_changan_dkey_ensure_dl_done_ud = download_user_data;
+
+ if (!changan_dkey_local_spki_b64_file_nonempty()) {
+ enum { k_dkey_ensure_pem_cap = 3072, k_dkey_ensure_spki_cap = 768 };
+ char *tmp_pem = (char *)malloc((size_t)k_dkey_ensure_pem_cap);
+ char *tmp_spki = (char *)malloc((size_t)k_dkey_ensure_spki_cap);
+ int gen_rc;
+
+ if (tmp_pem == NULL || tmp_spki == NULL) {
+ free(tmp_pem);
+ free(tmp_spki);
+ return -101;
+ }
+ (void)memset(tmp_pem, 0, (size_t)k_dkey_ensure_pem_cap);
+ (void)memset(tmp_spki, 0, (size_t)k_dkey_ensure_spki_cap);
+ gen_rc = changan_http_dkey_generate_rsa2048_keypair(tmp_pem, (uint32_t)k_dkey_ensure_pem_cap, tmp_spki,
+ (uint32_t)k_dkey_ensure_spki_cap);
+ free(tmp_pem);
+ free(tmp_spki);
+ if (gen_rc != 0) {
+ return -104;
+ }
+ }
+
+ /* 本机已有「注册成功」落盘且 SPKI/私钥齐全:跳过 public-key-register,直接用落盘的 public_key_id 拉 download-owner-key */
+ if (changan_dkey_local_spki_b64_file_nonempty() && changan_dkey_local_private_pem_file_nonempty()) {
+ bool reg_ok = false;
+ char pkid_stored[CHANGAN_HTTP_PUBLIC_KEY_ID_MAX];
+
+ if (changan_http_dkey_load_stored_public_key_register(®_ok, pkid_stored, (uint32_t)sizeof(pkid_stored)) ==
+ 0 &&
+ reg_ok && pkid_stored[0] != '\0') {
+ size_t idl = strnlen(pkid_stored, sizeof(pkid_stored));
+
+ if (idl >= sizeof(g_changan_dkey_ensure_public_key_id)) {
+ idl = sizeof(g_changan_dkey_ensure_public_key_id) - 1U;
+ }
+ if (memcpy_s(g_changan_dkey_ensure_public_key_id, sizeof(g_changan_dkey_ensure_public_key_id), pkid_stored,
+ idl) != 0) {
+ printf("[changan_http][dkey_ensure] copy stored public_key_id failed\r\n");
+ } else {
+ g_changan_dkey_ensure_public_key_id[idl] = '\0';
+ g_changan_dkey_ensure_dl.public_key_id = g_changan_dkey_ensure_public_key_id;
+ g_changan_dkey_ensure_decrypt_use_car_id = 1U;
+ rr = changan_http_dkey_download_owner_key(&g_changan_dkey_ensure_dl, g_changan_dkey_ensure_dl_done_cb,
+ g_changan_dkey_ensure_dl_done_ud);
+ if (rr == -100 || rr == -101 || rr == -102) {
+ g_changan_dkey_ensure_decrypt_use_car_id = 0U;
+ return rr;
+ }
+ if (rr < 0) {
+ g_changan_dkey_ensure_decrypt_use_car_id = 0U;
+ return rr;
+ }
+ if (g_changan_dkey_ensure_pending == 0U) {
+ return (rr == 200) ? 0 : rr;
+ }
+ return 0;
+ }
+ }
+ }
+
+ g_changan_dkey_ensure_pending = 1U;
+ rr = changan_http_dkey_public_key_register(&g_changan_dkey_ensure_reg_params, changan_dkey_ensure_unified_register_cb,
+ NULL);
+ if (rr == -100 || rr == -101 || rr == -102) {
+ g_changan_dkey_ensure_pending = 0U;
+ return rr;
+ }
+ if (rr < 0) {
+ g_changan_dkey_ensure_pending = 0U;
+ return rr;
+ }
+ if (g_changan_dkey_ensure_pending == 0U) {
+ return (rr == 200) ? 0 : rr;
+ }
+ return 0;
+}
+
+static int changan_http_dkey_public_key_register_impl(const changan_dkey_public_key_register_params_t *p,
+ char *resp_buf, uint32_t resp_cap, char *public_key_id_out, uint32_t public_key_id_cap,
+ changan_http_req_type_e req_http_type)
+{
+ char access_buf[CHANGAN_HTTP_OAUTH_STORE_ACCESS_TOKEN_MAX];
+ char secret_buf[CHANGAN_HTTP_OAUTH_STORE_SECRET_KEY_MAX];
+ char *body = NULL;
+ char *spki_heap = NULL;
+ changan_dkey_public_key_register_params_t eff;
+ const char *access_eff = NULL;
+ const char *secret_eff = NULL;
+ const char *path = NULL;
+ int http_code = -1;
+
+ if (p == NULL || resp_buf == NULL || resp_cap == 0U) {
+ return -1;
+ }
+ resp_buf[0] = '\0';
+ if (public_key_id_out != NULL && public_key_id_cap > 0U) {
+ public_key_id_out[0] = '\0';
+ }
+
+ if (!changan_ctrl_car_resolve_credentials(p->access_token, p->secret_key, p->oauth_bootstrap,
+ access_buf, (uint32_t)sizeof(access_buf), secret_buf, (uint32_t)sizeof(secret_buf),
+ &access_eff, &secret_eff)) {
+ printf("[changan_http][dkey_reg] access_token/secret_key missing\r\n");
+ return -1;
+ }
+
+ eff = *p;
+ if (eff.public_key_spki_b64 == NULL || eff.public_key_spki_b64[0] == '\0') {
+ spki_heap = (char *)malloc((size_t)CHANGAN_DKEY_BODY_MAX);
+ if (spki_heap == NULL || !changan_dkey_file_read_trimmed(CHANGAN_DKEY_STORE_SPKI_B64_PATH, spki_heap,
+ CHANGAN_DKEY_BODY_MAX)) {
+ printf("[changan_http][dkey_reg] public_key_spki_b64 empty and store file missing/invalid\r\n");
+ free(spki_heap);
+ return -1;
+ }
+ eff.public_key_spki_b64 = spki_heap;
+ }
+ if (eff.user_id == NULL) {
+ free(spki_heap);
+ return -1;
+ }
+
+ body = (char *)malloc((size_t)CHANGAN_DKEY_BODY_MAX);
+ if (body == NULL) {
+ free(spki_heap);
+ return -1;
+ }
+ if (!changan_dkey_build_register_body(&eff, body, CHANGAN_DKEY_BODY_MAX)) {
+ free(body);
+ free(spki_heap);
+ return -1;
+ }
+
+ path = (eff.api_path != NULL && eff.api_path[0] != '\0') ?
+ eff.api_path : CHANGAN_HTTP_API_PATH_DKEY_PUBLIC_KEY_REGISTER;
+ http_code = changan_dkey_post_control_car(path, access_eff, secret_eff,
+ eff.timestamp_ms, eff.timestamp, eff.header_nonce, body, resp_buf, resp_cap, req_http_type);
+ free(body);
+ free(spki_heap);
+
+ if (http_code == 200) {
+ char parse_id[CHANGAN_HTTP_PUBLIC_KEY_ID_MAX];
+
+ parse_id[0] = '\0';
+ (void)changan_dkey_parse_register_public_key_id(resp_buf, parse_id, (uint32_t)sizeof(parse_id));
+ if (public_key_id_out != NULL && public_key_id_cap > 0U) {
+ if (parse_id[0] != '\0') {
+ size_t idl = strnlen(parse_id, sizeof(parse_id));
+
+ if (idl >= (size_t)public_key_id_cap) {
+ idl = (size_t)public_key_id_cap - 1U;
+ }
+ if (memcpy_s(public_key_id_out, public_key_id_cap, parse_id, idl) != 0) {
+ public_key_id_out[0] = '\0';
+ } else {
+ public_key_id_out[idl] = '\0';
+ }
+ } else {
+ public_key_id_out[0] = '\0';
+ }
+ }
+ if (parse_id[0] != '\0') {
+ changan_dkey_save_public_key_register_to_file(true, parse_id);
+ } else {
+ changan_dkey_save_public_key_register_to_file(false, NULL);
+ }
+ }
+ printf("[changan_http][dkey_reg] http=%d\r\n", http_code);
+ return http_code;
+}
+
+int changan_http_dkey_download_owner_key(const changan_dkey_download_owner_key_params_t *p,
+ changan_http_result_cb_t cb, void *user_data)
+{
+ changan_http_job_t *job;
+
+ if (cb == NULL) {
+ return -100;
+ }
+ if (p == NULL) {
+ return -1;
+ }
+ job = (changan_http_job_t *)calloc(1, sizeof(changan_http_job_t));
+ if (job == NULL) {
+ return -101;
+ }
+ job->kind = CHANGAN_HTTP_JK_DKEY_DL;
+ job->req_type = CHANGAN_HTTP_REQ_DKEY_DOWNLOAD_OWNER_KEY;
+ job->done_cb = cb;
+ job->done_ud = user_data;
+ job->u.dld.p = (const changan_dkey_download_owner_key_params_t *)changan_dkey_dl_params_heap_clone(p);
+ if (job->u.dld.p == NULL) {
+ free(job);
+ return -101;
+ }
+ job->u.dld.resp_heap = (uint8_t *)malloc((size_t)CHANGAN_HTTP_CTRL_RESP_CAP);
+ if (job->u.dld.resp_heap == NULL) {
+ changan_dkey_dl_params_heap_free((changan_dkey_download_owner_key_params_t *)job->u.dld.p);
+ free((void *)job->u.dld.p);
+ free(job);
+ return -101;
+ }
+ job->u.dld.resp_cap = CHANGAN_HTTP_CTRL_RESP_CAP;
+ return changan_http_submit_job(job);
+}
+
+static int changan_http_dkey_download_owner_key_impl(const changan_dkey_download_owner_key_params_t *p,
+ char *resp_buf, uint32_t resp_cap, changan_http_req_type_e req_http_type)
+{
+ char access_buf[CHANGAN_HTTP_OAUTH_STORE_ACCESS_TOKEN_MAX];
+ char secret_buf[CHANGAN_HTTP_OAUTH_STORE_SECRET_KEY_MAX];
+ char body_nonce[17] = {0};
+ char sign_b64[CHANGAN_DKEY_SIGN_B64_MAX];
+ char *body = NULL;
+ char *pem_heap = NULL;
+ const char *access_eff = NULL;
+ const char *secret_eff = NULL;
+ const char *rsa_pem = NULL;
+ const char *path = NULL;
+ int protocol = 1;
+ int http_code = -1;
+
+ if (p == NULL || resp_buf == NULL || resp_cap == 0U) {
+ return -1;
+ }
+ resp_buf[0] = '\0';
+
+ if (!changan_ctrl_car_resolve_credentials(p->access_token, p->secret_key, p->oauth_bootstrap,
+ access_buf, (uint32_t)sizeof(access_buf), secret_buf, (uint32_t)sizeof(secret_buf),
+ &access_eff, &secret_eff)) {
+ printf("[changan_http][dkey_dl] access_token/secret_key missing\r\n");
+ return -1;
+ }
+ if (p->car_id == NULL || p->public_key_id == NULL || p->user_id == NULL) {
+ printf("[changan_http][dkey_dl] invalid params\r\n");
+ return -1;
+ }
+
+ rsa_pem = p->rsa_private_key_pem;
+ if (rsa_pem == NULL || rsa_pem[0] == '\0') {
+ pem_heap = (char *)malloc((size_t)CHANGAN_DKEY_BODY_MAX);
+ if (pem_heap == NULL || !changan_dkey_file_read_trimmed(CHANGAN_DKEY_STORE_PRIVATE_PEM_PATH, pem_heap,
+ CHANGAN_DKEY_BODY_MAX)) {
+ printf("[changan_http][dkey_dl] rsa_private_key_pem empty and store file missing/invalid\r\n");
+ free(pem_heap);
+ return -1;
+ }
+ rsa_pem = pem_heap;
+ }
+
+ if (p->body_nonce != NULL && p->body_nonce[0] != '\0') {
+ if (strlen(p->body_nonce) != 16U) {
+ printf("[changan_http][dkey_dl] body nonce must be 16 hex chars\r\n");
+ free(pem_heap);
+ return -1;
+ }
+ (void)memcpy_s(body_nonce, sizeof(body_nonce), p->body_nonce, strlen(p->body_nonce) + 1U);
+ } else {
+ changan_dkey_random_body_nonce16(body_nonce);
+ }
+
+ protocol = (p->protocol_type != 0) ? p->protocol_type : 1;
+ if (changan_dkey_build_private_key_sign(p->car_id, body_nonce, p->public_key_id, p->user_id, protocol,
+ p->private_sign_exclude_protocol_type, rsa_pem, sign_b64,
+ (uint32_t)sizeof(sign_b64)) != 0) {
+ printf("[changan_http][dkey_dl] privateKeySign failed\r\n");
+ free(pem_heap);
+ return -1;
+ }
+
+ body = (char *)malloc((size_t)CHANGAN_DKEY_BODY_MAX);
+ if (body == NULL) {
+ free(pem_heap);
+ return -1;
+ }
+ if (!changan_dkey_build_download_body(p, body_nonce, sign_b64, body, CHANGAN_DKEY_BODY_MAX)) {
+ free(body);
+ free(pem_heap);
+ return -1;
+ }
+
+ path = (p->api_path != NULL && p->api_path[0] != '\0') ?
+ p->api_path : CHANGAN_HTTP_API_PATH_DKEY_DOWNLOAD_OWNER_KEY;
+ http_code = changan_dkey_post_control_car(path, access_eff, secret_eff,
+ p->timestamp_ms, p->timestamp, p->header_nonce, body, resp_buf, resp_cap, req_http_type);
+ free(body);
+ free(pem_heap);
+ printf("[changan_http][dkey_dl] http=%d\r\n", http_code);
+ return http_code;
+}
+
+/** 与 changan_api_at.c changan_parse_bt_address 一致:人眼 MAC 从左到右,栈内 addr[0]..[5] 反序 */
+static int changan_http_parse_ble_mac_bd_addr(const char *addr_str, bd_addr_t *addr)
+{
+ unsigned int addr_bytes[6] = {0};
+ int count;
+
+ if (addr_str == NULL || addr == NULL) {
+ return -1;
+ }
+ count = sscanf(addr_str, "%02x:%02x:%02x:%02x:%02x:%02x", &addr_bytes[0], &addr_bytes[1], &addr_bytes[2],
+ &addr_bytes[3], &addr_bytes[4], &addr_bytes[5]);
+ if (count != 6) {
+ count = sscanf(addr_str, "%02x%02x%02x%02x%02x%02x", &addr_bytes[0], &addr_bytes[1], &addr_bytes[2],
+ &addr_bytes[3], &addr_bytes[4], &addr_bytes[5]);
+ if (count != 6) {
+ count = sscanf(addr_str, "%02X:%02X:%02X:%02X:%02X:%02X", &addr_bytes[0], &addr_bytes[1], &addr_bytes[2],
+ &addr_bytes[3], &addr_bytes[4], &addr_bytes[5]);
+ if (count != 6) {
+ count = sscanf(addr_str, "%02X%02X%02X%02X%02X%02X", &addr_bytes[0], &addr_bytes[1], &addr_bytes[2],
+ &addr_bytes[3], &addr_bytes[4], &addr_bytes[5]);
+ if (count != 6) {
+ return -1;
+ }
+ }
+ }
+ }
+ addr->addr[0] = (uint8_t)addr_bytes[5];
+ addr->addr[1] = (uint8_t)addr_bytes[4];
+ addr->addr[2] = (uint8_t)addr_bytes[3];
+ addr->addr[3] = (uint8_t)addr_bytes[2];
+ addr->addr[4] = (uint8_t)addr_bytes[1];
+ addr->addr[5] = (uint8_t)addr_bytes[0];
+ addr->type = BT_ADDRESS_TYPE_PUBLIC_DEVICE_ADDRESS;
+ return 0;
+}
+
+/** download-owner-key 明文 cardInfo:前 16B=9F3B CardID,16–23=5A CardSEID;整段作 9F05 CardInfo1(123B),与 bleICCE.c 注释一致 */
+static void changan_dkey_decrypt_apply_icce_auth(const char *card_info, uint32_t card_info_len,
+ const uint8_t *dkey, uint32_t dkey_len, const char *ble_mac_str, const char *vehicle_car_id_str)
+{
+ uint8_t card_info1[ICCE_CARD_INFO1_TEST_LEN];
+ const uint8_t *bin = (const uint8_t *)(const void *)card_info;
+ const uint8_t *card_id = NULL;
+ const uint8_t *card_seid = NULL;
+ bd_addr_t ble_bd = {0};
+ const bd_addr_t *ble_ptr = NULL;
+ const uint8_t *dkey_ptr = NULL;
+
+ if (ble_mac_str != NULL && ble_mac_str[0] != '\0' && changan_http_parse_ble_mac_bd_addr(ble_mac_str, &ble_bd) == 0) {
+ ble_ptr = &ble_bd;
+ }
+
+ (void)memset(card_info1, 0, sizeof(card_info1));
+ if (card_info != NULL && card_info_len > 0U) {
+ size_t n = (size_t)card_info_len;
+
+ if (n > sizeof(card_info1)) {
+ n = sizeof(card_info1);
+ }
+ (void)memcpy(card_info1, bin, n);
+ }
+
+ if (card_info != NULL && card_info_len >= 16U) {
+ card_id = bin;
+ }
+ if (card_info != NULL && card_info_len >= 24U) {
+ card_seid = bin + 16U;
+ }
+ if (dkey != NULL && dkey_len == 16U) {
+ dkey_ptr = dkey;
+ }
+ ble_icce_changan_set_auth_card_identity(ble_ptr, vehicle_car_id_str, card_seid, card_id, card_info1, dkey_ptr);
+}
+
+int changan_http_dkey_decrypt_download_owner_key_response(const char *download_resp_json,
+ const char *rsa_private_key_pem,
+ char *card_info_out, uint32_t card_info_cap, uint32_t *card_info_len_out,
+ uint8_t *dkey_out, uint32_t dkey_cap, uint32_t *dkey_len_out, const char *car_id_opt)
+{
+ cJSON *root = NULL;
+ cJSON *data = NULL;
+ cJSON *card_enc = NULL;
+ cJSON *dkey_enc = NULL;
+ const char *card_b64 = NULL;
+ const char *dkey_b64 = NULL;
+ char ble_mac_buf[CHANGAN_DKEY_BLE_MAC_STR_CAP];
+ char car_id_buf[CHANGAN_HTTP_DKEY_CAR_ID_CAP];
+ char *pem_heap = NULL;
+ const char *rsa_pem = rsa_private_key_pem;
+ int ret = -1;
+
+ if (download_resp_json == NULL) {
+ return -1;
+ }
+
+ pem_heap = (char *)malloc((size_t)CHANGAN_DKEY_BODY_MAX);
+ if (pem_heap != NULL && changan_dkey_file_read_trimmed(CHANGAN_DKEY_STORE_PRIVATE_PEM_PATH, pem_heap,
+ CHANGAN_DKEY_BODY_MAX)) {
+ rsa_pem = pem_heap;
+ } else {
+ free(pem_heap);
+ pem_heap = NULL;
+ rsa_pem = rsa_private_key_pem;
+ if (rsa_pem == NULL || rsa_pem[0] == '\0') {
+ printf("[changan_http][dkey_dec] pem file missing/invalid and rsa_private_key_pem empty\r\n");
+ return -1;
+ }
+ }
+
+ root = cJSON_Parse(download_resp_json);
+ if (root == NULL) {
+ printf("[changan_http][dkey_dec] invalid json\r\n");
+ free(pem_heap);
+ return -1;
+ }
+
+ data = root;
+ if (cJSON_IsObject(root)) {
+ cJSON *wrap = cJSON_GetObjectItem(root, "data");
+
+ if (cJSON_IsObject(wrap)) {
+ data = wrap;
+ }
+ }
+
+ card_enc = cJSON_GetObjectItemCaseSensitive(data, "cardInfoEnc");
+ dkey_enc = cJSON_GetObjectItemCaseSensitive(data, "dkeyEnc");
+ if (cJSON_IsString(card_enc) && card_enc->valuestring != NULL) {
+ card_b64 = card_enc->valuestring;
+ }
+ if (cJSON_IsString(dkey_enc) && dkey_enc->valuestring != NULL) {
+ dkey_b64 = dkey_enc->valuestring;
+ }
+
+ ble_mac_buf[0] = '\0';
+ {
+ cJSON *ble_mac_j = cJSON_GetObjectItemCaseSensitive(data, "bleMac");
+
+ if (cJSON_IsString(ble_mac_j) && ble_mac_j->valuestring != NULL) {
+ size_t n = strlen(ble_mac_j->valuestring);
+
+ if (n < (size_t)CHANGAN_DKEY_BLE_MAC_STR_CAP &&
+ memcpy_s(ble_mac_buf, sizeof(ble_mac_buf), ble_mac_j->valuestring, n + 1U) != 0) {
+ ble_mac_buf[0] = '\0';
+ }
+ }
+ }
+
+ car_id_buf[0] = '\0';
+ if (car_id_opt != NULL && car_id_opt[0] != '\0') {
+ size_t lim = strnlen(car_id_opt, (size_t)CHANGAN_HTTP_DKEY_CAR_ID_CAP - 1U);
+
+ if (memcpy_s(car_id_buf, sizeof(car_id_buf), car_id_opt, lim) == 0) {
+ car_id_buf[lim] = '\0';
+ }
+ } else {
+ cJSON *cid = cJSON_GetObjectItemCaseSensitive(data, "carId");
+
+ if (!(cJSON_IsString(cid) && cid->valuestring != NULL)) {
+ cid = cJSON_GetObjectItemCaseSensitive(data, "car_id");
+ }
+ if (cJSON_IsString(cid) && cid->valuestring != NULL) {
+ size_t n = strlen(cid->valuestring);
+
+ if (n >= (size_t)CHANGAN_HTTP_DKEY_CAR_ID_CAP) {
+ n = (size_t)CHANGAN_HTTP_DKEY_CAR_ID_CAP - 1U;
+ }
+ if (n > 0U && memcpy_s(car_id_buf, sizeof(car_id_buf), cid->valuestring, n) == 0) {
+ car_id_buf[n] = '\0';
+ }
+ }
+ }
+
+ if (card_b64 == NULL || dkey_b64 == NULL) {
+ printf("[changan_http][dkey_dec] missing cardInfoEnc or dkeyEnc (expect strings under data or root)\r\n");
+ cJSON_Delete(root);
+ free(pem_heap);
+ return -1;
+ }
+
+ ret = changan_dkey_decrypt_download_owner_key_fields(card_b64, dkey_b64, rsa_pem,
+ card_info_out, card_info_cap, card_info_len_out, dkey_out, dkey_cap, dkey_len_out);
+ cJSON_Delete(root);
+ free(pem_heap);
+ if (ret != 0) {
+ printf("[changan_http][dkey_dec] decrypt failed\r\n");
+ return ret;
+ }
+
+ {
+ uint32_t card_len = 0U;
+ uint32_t dk_len = 0U;
+
+ if (card_info_len_out != NULL) {
+ card_len = *card_info_len_out;
+ } else if (card_info_out != NULL) {
+ card_len = (uint32_t)strlen(card_info_out);
+ }
+ if (dkey_len_out != NULL) {
+ dk_len = *dkey_len_out;
+ }
+ const char *vid = (car_id_buf[0] != '\0') ? car_id_buf : NULL;
+
+ changan_dkey_decrypt_apply_icce_auth(card_info_out, card_len, dkey_out, dk_len, ble_mac_buf, vid);
+ }
+ return ret;
+}
+
+int changan_http_dkey_generate_rsa2048_keypair(char *private_pem_out, uint32_t private_pem_cap,
+ char *public_spki_b64_out, uint32_t public_spki_b64_cap)
+{
+ int rc = changan_dkey_generate_rsa2048_keypair(private_pem_out, private_pem_cap,
+ public_spki_b64_out, public_spki_b64_cap);
+
+ if (rc == 0 && private_pem_out != NULL && public_spki_b64_out != NULL) {
+ changan_dkey_save_keypair_to_files(private_pem_out, public_spki_b64_out);
+ changan_dkey_save_public_key_register_to_file(false, NULL);
+ }
+ return rc;
+}
+
+/* ---------- openC 二维码 v1(对齐 http/py/qrcode_generate_v1_test.py、qrcode_status_no_backend_v1_test.py) ---------- */
+
+#define CHANGAN_QR_FORM_ENC_SZ 512U
+#define CHANGAN_QR_POST_BODY_SZ 1536U
+#define CHANGAN_QR_SIGN_SOURCE_SZ 1024U
+#define CHANGAN_QR_HTTP_HDR_SZ 4096
+#define CHANGAN_QR_URL_SZ 2048
+#define CHANGAN_QR_STATUS_ENC_BLOCKS 5U
+
+static bool changan_qr_urlencode_value(const char *in, char *out, size_t out_sz)
+{
+ size_t j = 0;
+
+ if (out_sz == 0U) {
+ return false;
+ }
+ if (in == NULL) {
+ in = "";
+ }
+ for (size_t i = 0; in[i] != '\0'; i++) {
+ unsigned char c = (unsigned char)in[i];
+
+ if (c == ' ') {
+ if (j + 1U >= out_sz) {
+ return false;
+ }
+ out[j++] = '+';
+ } else if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
+ (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == '*') {
+ if (j + 1U >= out_sz) {
+ return false;
+ }
+ out[j++] = (char)c;
+ } else {
+ static const char H[] = "0123456789ABCDEF";
+
+ if (j + 3U >= out_sz) {
+ return false;
+ }
+ out[j++] = '%';
+ out[j++] = H[(c >> 4) & 0xFU];
+ out[j++] = H[c & 0xFU];
+ }
+ }
+ if (j >= out_sz) {
+ return false;
+ }
+ out[j] = '\0';
+ return true;
+}
+
+static int changan_http_header_content_length(const char *hdr)
+{
+ if (hdr == NULL) {
+ return -1;
+ }
+
+ const char *p = hdr;
+
+ while (*p != '\0') {
+ const char *line_start = p;
+ const char *colon = NULL;
+
+ while (*p != '\0' && *p != '\r' && *p != '\n') {
+ if (*p == ':' && colon == NULL) {
+ colon = p;
+ }
+ p++;
+ }
+ if (colon != NULL && (size_t)(colon - line_start) == 15U) {
+ const char *want = "Content-Length";
+ size_t k;
+
+ for (k = 0U; k < 15U; k++) {
+ char a = line_start[k];
+ char b = want[k];
+
+ if (a >= 'a' && a <= 'z') {
+ a = (char)(a - 'a' + 'A');
+ }
+ if (b >= 'a' && b <= 'z') {
+ b = (char)(b - 'a' + 'A');
+ }
+ if (a != b) {
+ break;
+ }
+ }
+ if (k == 15U) {
+ const char *q = colon + 1;
+
+ while (*q == ' ' || *q == '\t') {
+ q++;
+ }
+ int v = 0;
+
+ while (*q >= '0' && *q <= '9') {
+ v = v * 10 + (*q - '0');
+ q++;
+ }
+ return v;
+ }
+ }
+ while (*p == '\r' || *p == '\n') {
+ p++;
+ }
+ }
+ return -1;
+}
+
+/**
+ * 从 HttpClientData 推断响应体字节数(优先 responseContentLen / contentBlockLen / retrieveLen / Content-Length),
+ * 避免依赖栈缓冲内可能缺失的 '\\0',从而不把扩充区未初始化数据当作 JSON 正文。
+ */
+static uint32_t changan_http_cd_response_text_len(HttpClientData *cd, uint32_t resp_cap)
+{
+ uint32_t buf_cap;
+ int cl;
+ uint32_t n;
+
+ if (cd == NULL || cd->responseBuf == NULL || resp_cap == 0U) {
+ return 0U;
+ }
+ buf_cap = (cd->responseBufLen > 0) ? (uint32_t)cd->responseBufLen : resp_cap;
+ if (buf_cap > resp_cap) {
+ buf_cap = resp_cap;
+ }
+
+ if (cd->responseContentLen > 0) {
+ n = (uint32_t)cd->responseContentLen;
+ if (n > buf_cap) {
+ n = buf_cap;
+ }
+ if (n > resp_cap) {
+ n = resp_cap;
+ }
+ return n;
+ }
+ if (cd->contentBlockLen > 0) {
+ n = (uint32_t)cd->contentBlockLen;
+ if (n > buf_cap) {
+ n = buf_cap;
+ }
+ if (n > resp_cap) {
+ n = resp_cap;
+ }
+ return n;
+ }
+ if (cd->retrieveLen > 0) {
+ n = (uint32_t)cd->retrieveLen;
+ if (n > buf_cap) {
+ n = buf_cap;
+ }
+ if (n > resp_cap) {
+ n = resp_cap;
+ }
+ return n;
+ }
+ cl = changan_http_header_content_length(cd->headerBuf);
+ if (cl >= 0) {
+ n = (uint32_t)cl;
+ if (n > buf_cap) {
+ n = buf_cap;
+ }
+ if (n > resp_cap) {
+ n = resp_cap;
+ }
+ return n;
+ }
+
+ n = (uint32_t)strnlen(cd->responseBuf, (size_t)buf_cap);
+ if (n > 0U && n >= buf_cap && buf_cap > 0U) {
+ /* 无可靠长度且无 NUL:按 JSON 从尾向前截到 '}',避免 malloc 尾部的随机字节 */
+ for (uint32_t i = buf_cap; i > 0U; i--) {
+ if (cd->responseBuf[i - 1U] == '}') {
+ return i;
+ }
+ }
+ return 0U;
+ }
+ return n;
+}
+
+static void changan_http_apply_cd_body_to_resp(HttpClientData *cd, char *resp_buf, uint32_t resp_cap)
+{
+ uint32_t copy_len;
+
+ if (resp_buf == NULL || resp_cap == 0U) {
+ return;
+ }
+ if (cd == NULL || cd->responseBuf == NULL) {
+ resp_buf[0] = '\0';
+ return;
+ }
+ copy_len = changan_http_cd_response_text_len(cd, resp_cap);
+ if (copy_len >= resp_cap) {
+ copy_len = resp_cap - 1U;
+ }
+ if (copy_len > 0U) {
+ (void)memcpy_s(resp_buf, resp_cap, cd->responseBuf, copy_len);
+ }
+ resp_buf[copy_len] = '\0';
+}
+
+static void changan_http_header_field_value(const char *hdr, const char *field_name, char *out, uint32_t out_cap)
+{
+ if (out == NULL || out_cap == 0U) {
+ return;
+ }
+ out[0] = '\0';
+ if (hdr == NULL || field_name == NULL) {
+ return;
+ }
+
+ size_t nlen = strlen(field_name);
+ const char *p = hdr;
+
+ while (*p != '\0') {
+ const char *line_start = p;
+ const char *colon = NULL;
+
+ while (*p != '\0' && *p != '\r' && *p != '\n') {
+ if (*p == ':' && colon == NULL) {
+ colon = p;
+ }
+ p++;
+ }
+ if (colon != NULL && (size_t)(colon - line_start) == nlen) {
+ size_t k;
+
+ for (k = 0U; k < nlen; k++) {
+ char a = line_start[k];
+ char b = field_name[k];
+
+ if (a >= 'a' && a <= 'z') {
+ a = (char)(a - 'a' + 'A');
+ }
+ if (b >= 'a' && b <= 'z') {
+ b = (char)(b - 'a' + 'A');
+ }
+ if (a != b) {
+ break;
+ }
+ }
+ if (k == nlen) {
+ const char *q = colon + 1;
+ uint32_t i = 0;
+
+ while (*q == ' ' || *q == '\t') {
+ q++;
+ }
+ while (*q != '\0' && *q != '\r' && *q != '\n' && i + 1U < out_cap) {
+ out[i++] = *q++;
+ }
+ out[i] = '\0';
+ return;
+ }
+ }
+ while (*p == '\r' || *p == '\n') {
+ p++;
+ }
+ }
+}
+
+static bool changan_header_contains_ci(const char *hdr, const char *needle)
+{
+ if (hdr == NULL || needle == NULL) {
+ return false;
+ }
+
+ size_t nlen = strlen(needle);
+
+ for (const char *p = hdr; *p != '\0'; p++) {
+ size_t k;
+
+ for (k = 0U; k < nlen && p[k] != '\0'; k++) {
+ char a = p[k];
+ char b = needle[k];
+
+ if (a >= 'a' && a <= 'z') {
+ a = (char)(a - 'a' + 'A');
+ }
+ if (b >= 'a' && b <= 'z') {
+ b = (char)(b - 'a' + 'A');
+ }
+ if (a != b) {
+ break;
+ }
+ }
+ if (k == nlen) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static int changan_form_append_pair(char *buf, uint32_t cap, uint32_t *pos, const char *key, const char *val,
+ char *enc_scratch, uint32_t esc_cap, bool with_amp)
+{
+ if (!changan_qr_urlencode_value(val, enc_scratch, esc_cap)) {
+ return -1;
+ }
+ if (cap <= *pos) {
+ return -1;
+ }
+ const char *fmt = with_amp ? "%s=%s&" : "%s=%s";
+
+ int w = snprintf(buf + *pos, (size_t)(cap - *pos), fmt, key, enc_scratch);
+
+ if (w < 0 || (uint32_t)w >= cap - *pos) {
+ return -1;
+ }
+ *pos += (uint32_t)w;
+ return 0;
+}
+
+static int changan_http_qrcode_generate_v1_do_sync(const changan_qrcode_generate_v1_params_t *params,
+ uint8_t *resp_buf, uint32_t resp_cap, uint32_t *out_body_len,
+ char *qrcode_id_out, uint32_t qrcode_id_cap)
+{
+ char ts_ms[24] = {0};
+ char sign_hex[65];
+ const char *device_id_eff = NULL;
+ changan_sign_kv_t kv[12];
+ char *sign_src = NULL;
+ char *post_body = NULL;
+ char *enc = NULL;
+ int nk = 0;
+ uint32_t pos = 0;
+ HttpClient client = (HttpClient){0};
+ HttpClientData cd = (HttpClientData){0};
+ int http_code = -1;
+ bool cd_prepared = false;
+
+ if (out_body_len != NULL) {
+ *out_body_len = 0U;
+ }
+ if (qrcode_id_out != NULL && qrcode_id_cap > 0U) {
+ qrcode_id_out[0] = '\0';
+ }
+ if (params == NULL || resp_buf == NULL || resp_cap == 0U || out_body_len == NULL) {
+ return -1;
+ }
+ if (params->client_id == NULL || params->nonce == NULL ||
+ params->size == NULL || params->state == NULL || params->app_key == NULL || params->app_code == NULL) {
+ printf("[changan_http][qrcode_gen] invalid params\r\n");
+ return -1;
+ }
+
+ sign_src = (char *)malloc(CHANGAN_QR_SIGN_SOURCE_SZ);
+ post_body = (char *)malloc(CHANGAN_QR_POST_BODY_SZ);
+ enc = (char *)malloc(CHANGAN_QR_FORM_ENC_SZ);
+ if (sign_src == NULL || post_body == NULL || enc == NULL) {
+ printf("[changan_http][qrcode_gen] malloc failed\r\n");
+ free(sign_src);
+ free(post_body);
+ free(enc);
+ return -1;
+ }
+
+ if (params->timestamp_ms != NULL) {
+ if (strlen(params->timestamp_ms) >= sizeof(ts_ms)) {
+ printf("[changan_http][qrcode_gen] timestamp_ms too long\r\n");
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+ (void)memcpy_s(ts_ms, sizeof(ts_ms), params->timestamp_ms, strlen(params->timestamp_ms) + 1U);
+ } else {
+ unsigned long long ms = (unsigned long long)time(NULL) * 1000ULL;
+
+ (void)snprintf(ts_ms, sizeof(ts_ms), "%llu", ms);
+ }
+
+ device_id_eff = changan_http_effective_device_id();
+ nk = 0;
+ kv[nk++] = (changan_sign_kv_t){ "appKey", params->app_key };
+ if (!params->exclude_app_code_from_sign) {
+ kv[nk++] = (changan_sign_kv_t){ "appCode", params->app_code };
+ }
+ kv[nk++] = (changan_sign_kv_t){ "client_id", params->client_id };
+ kv[nk++] = (changan_sign_kv_t){ "device_id", device_id_eff };
+ kv[nk++] = (changan_sign_kv_t){ "nonce", params->nonce };
+ kv[nk++] = (changan_sign_kv_t){ "size", params->size };
+ kv[nk++] = (changan_sign_kv_t){ "state", params->state };
+ kv[nk++] = (changan_sign_kv_t){ "timestamp", ts_ms };
+
+ if (changan_build_java_like_sign_source(kv, nk, sign_src, CHANGAN_QR_SIGN_SOURCE_SZ) != 0) {
+ printf("[changan_http][qrcode_gen] sign source overflow\r\n");
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+ if (changan_sha256_hex_upper_str(sign_src, sign_hex) != 0) {
+ printf("[changan_http][qrcode_gen] sha256 failed\r\n");
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+
+ pos = 0;
+ if (changan_form_append_pair(post_body, CHANGAN_QR_POST_BODY_SZ, &pos, "client_id", params->client_id, enc,
+ CHANGAN_QR_FORM_ENC_SZ, true) != 0) {
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+ if (changan_form_append_pair(post_body, CHANGAN_QR_POST_BODY_SZ, &pos, "device_id", device_id_eff, enc,
+ CHANGAN_QR_FORM_ENC_SZ, true) != 0) {
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+ if (changan_form_append_pair(post_body, CHANGAN_QR_POST_BODY_SZ, &pos, "nonce", params->nonce, enc,
+ CHANGAN_QR_FORM_ENC_SZ, true) != 0) {
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+ if (changan_form_append_pair(post_body, CHANGAN_QR_POST_BODY_SZ, &pos, "size", params->size, enc,
+ CHANGAN_QR_FORM_ENC_SZ, true) != 0) {
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+ if (changan_form_append_pair(post_body, CHANGAN_QR_POST_BODY_SZ, &pos, "state", params->state, enc,
+ CHANGAN_QR_FORM_ENC_SZ, true) != 0) {
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+ if (changan_form_append_pair(post_body, CHANGAN_QR_POST_BODY_SZ, &pos, "timestamp", ts_ms, enc,
+ CHANGAN_QR_FORM_ENC_SZ, true) != 0) {
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+ if (changan_form_append_pair(post_body, CHANGAN_QR_POST_BODY_SZ, &pos, "appKey", params->app_key, enc,
+ CHANGAN_QR_FORM_ENC_SZ, true) != 0) {
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+ if (changan_form_append_pair(post_body, CHANGAN_QR_POST_BODY_SZ, &pos, "appCode", params->app_code, enc,
+ CHANGAN_QR_FORM_ENC_SZ, true) != 0) {
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+ if (changan_form_append_pair(post_body, CHANGAN_QR_POST_BODY_SZ, &pos, "sign", sign_hex, enc,
+ CHANGAN_QR_FORM_ENC_SZ, false) != 0) {
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+
+ if (HttpClientPrepare(&cd, CHANGAN_QR_HTTP_HDR_SZ, (int)resp_cap) != HTTP_SUCCESS) {
+ printf("[changan_http][qrcode_gen] HttpClientPrepare failed\r\n");
+ http_code = -1;
+ goto GEN_CLEANUP;
+ }
+ cd_prepared = true;
+
+ cd.postBuf = post_body;
+ cd.postBufLen = (int)strlen(post_body);
+ client.header = "Content-Type: application/x-www-form-urlencoded\r\n";
+
+ HTTPC_RESULT hr = HttpClientPostRequest(&client, CHANGAN_HTTP_API_QRCODE_GENERATE, &cd);
+
+ http_code = client.responseCode;
+ printf("[changan_http][qrcode_gen] hr=%d code=%d\r\n", (int)hr, http_code);
+
+ if (hr == HTTP_SUCCESS && http_code == 200 && cd.responseBuf != NULL) {
+ int cl = changan_http_header_content_length(cd.headerBuf);
+
+ if (cl < 0 && cd.responseContentLen > 0) {
+ cl = cd.responseContentLen;
+ }
+ if (cl < 0 && cd.contentBlockLen > 0) {
+ cl = cd.contentBlockLen;
+ }
+ bool is_png = changan_header_contains_ci(cd.headerBuf, "image/png");
+ uint32_t copy_len;
+
+ if (cl >= 0) {
+ copy_len = (uint32_t)cl;
+ } else if (is_png) {
+ if (cd.retrieveLen > 0) {
+ copy_len = (uint32_t)cd.retrieveLen;
+ } else {
+ printf("[changan_http][qrcode_gen] PNG missing Content-Length\r\n");
+ goto GEN_UNPREPARE;
+ }
+ } else {
+ copy_len = changan_http_cd_response_text_len(&cd, resp_cap);
+ }
+ if (copy_len > resp_cap) {
+ copy_len = resp_cap;
+ }
+ if (memcpy_s(resp_buf, resp_cap, cd.responseBuf, copy_len) != 0) {
+ goto GEN_UNPREPARE;
+ }
+ *out_body_len = copy_len;
+
+ if (!is_png && copy_len < resp_cap) {
+ resp_buf[copy_len] = '\0';
+ }
+
+ if (qrcode_id_out != NULL && qrcode_id_cap > 0U) {
+ changan_http_header_field_value(cd.headerBuf, "qrcode_id", qrcode_id_out, qrcode_id_cap);
+ if (qrcode_id_out[0] == '\0') {
+ changan_http_header_field_value(cd.headerBuf, "qrcode-id", qrcode_id_out, qrcode_id_cap);
+ }
+ }
+ }
+
+GEN_UNPREPARE:
+ if (cd_prepared) {
+ HttpClientUnprepare(&cd);
+ cd_prepared = false;
+ }
+
+GEN_CLEANUP:
+ free(sign_src);
+ free(post_body);
+ free(enc);
+ return http_code;
+}
+
+int changan_http_qrcode_generate_v1(const changan_qrcode_generate_v1_params_t *params,
+ changan_http_result_cb_t cb, void *user_data)
+{
+ changan_http_job_t *job;
+
+ if (cb == NULL) {
+ return -100;
+ }
+ if (params == NULL) {
+ return -1;
+ }
+ job = (changan_http_job_t *)calloc(1, sizeof(changan_http_job_t));
+ if (job == NULL) {
+ return -101;
+ }
+ job->kind = CHANGAN_HTTP_JK_QR_GEN;
+ job->req_type = CHANGAN_HTTP_REQ_QRCODE_GENERATE_V1;
+ job->done_cb = cb;
+ job->done_ud = user_data;
+ job->u.qr_gen.params = (const changan_qrcode_generate_v1_params_t *)changan_qr_gen_params_heap_clone(params);
+ if (job->u.qr_gen.params == NULL) {
+ free(job);
+ return -101;
+ }
+ job->u.qr_gen.resp_heap = (uint8_t *)malloc((size_t)CHANGAN_HTTP_QR_RESP_CAP);
+ if (job->u.qr_gen.resp_heap == NULL) {
+ changan_qr_gen_params_heap_free((changan_qrcode_generate_v1_params_t *)job->u.qr_gen.params);
+ free((void *)job->u.qr_gen.params);
+ free(job);
+ return -101;
+ }
+ job->u.qr_gen.resp_cap = CHANGAN_HTTP_QR_RESP_CAP;
+ job->u.qr_gen.out_body_len = 0U;
+ job->u.qr_gen.qrcode_id_buf[0] = '\0';
+ return changan_http_submit_job(job);
+}
+
+static int changan_http_qrcode_status_no_backend_v1_do_sync(const changan_qrcode_status_no_backend_v1_params_t *params,
+ char *resp_buf, uint32_t resp_cap)
+{
+ char ts_sec[20] = {0};
+ char sign_hex[65];
+ changan_sign_kv_t kv[8];
+ char *sign_src = NULL;
+ char *url = NULL;
+ char *enc_blk = NULL;
+ char *enc_nonce = NULL;
+ char *enc_ts = NULL;
+ char *enc_qid = NULL;
+ char *enc_key = NULL;
+ char *enc_sign = NULL;
+ int nk = 0;
+ HttpClient client = (HttpClient){0};
+ HttpClientData cd = (HttpClientData){0};
+ int http_code = -1;
+ bool cd_prepared = false;
+
+ if (resp_buf == NULL || resp_cap == 0U || params == NULL) {
+ return -1;
+ }
+ resp_buf[0] = '\0';
+ if (params->nonce == NULL || params->qrcode_id == NULL) {
+ printf("[changan_http][qrcode_st] invalid params\r\n");
+ return -1;
+ }
+
+ sign_src = (char *)malloc(CHANGAN_QR_SIGN_SOURCE_SZ);
+ url = (char *)malloc(CHANGAN_QR_URL_SZ);
+ enc_blk = (char *)malloc((size_t)CHANGAN_QR_FORM_ENC_SZ * (size_t)CHANGAN_QR_STATUS_ENC_BLOCKS);
+ if (sign_src == NULL || url == NULL || enc_blk == NULL) {
+ printf("[changan_http][qrcode_st] malloc failed\r\n");
+ free(sign_src);
+ free(url);
+ free(enc_blk);
+ return -1;
+ }
+
+ enc_nonce = enc_blk;
+ enc_ts = enc_blk + CHANGAN_QR_FORM_ENC_SZ * 1U;
+ enc_qid = enc_blk + CHANGAN_QR_FORM_ENC_SZ * 2U;
+ enc_key = enc_blk + CHANGAN_QR_FORM_ENC_SZ * 3U;
+ enc_sign = enc_blk + CHANGAN_QR_FORM_ENC_SZ * 4U;
+
+ if (params->timestamp_sec != NULL) {
+ if (strlen(params->timestamp_sec) >= sizeof(ts_sec)) {
+ http_code = -1;
+ goto ST_CLEANUP;
+ }
+ (void)memcpy_s(ts_sec, sizeof(ts_sec), params->timestamp_sec, strlen(params->timestamp_sec) + 1U);
+ } else {
+ (void)snprintf(ts_sec, sizeof(ts_sec), "%lld", (long long)time(NULL));
+ }
+
+ nk = 0;
+ if (!params->no_app_key && params->app_key != NULL) {
+ kv[nk++] = (changan_sign_kv_t){ "appKey", params->app_key };
+ }
+ kv[nk++] = (changan_sign_kv_t){ "nonce", params->nonce };
+ kv[nk++] = (changan_sign_kv_t){ "qrcodeId", params->qrcode_id };
+ kv[nk++] = (changan_sign_kv_t){ "timestamp", ts_sec };
+
+ if (changan_build_java_like_sign_source(kv, nk, sign_src, CHANGAN_QR_SIGN_SOURCE_SZ) != 0) {
+ http_code = -1;
+ goto ST_CLEANUP;
+ }
+ if (changan_sha256_hex_upper_str(sign_src, sign_hex) != 0) {
+ http_code = -1;
+ goto ST_CLEANUP;
+ }
+
+ if (!changan_qr_urlencode_value(params->nonce, enc_nonce, CHANGAN_QR_FORM_ENC_SZ) ||
+ !changan_qr_urlencode_value(ts_sec, enc_ts, CHANGAN_QR_FORM_ENC_SZ) ||
+ !changan_qr_urlencode_value(params->qrcode_id, enc_qid, CHANGAN_QR_FORM_ENC_SZ) ||
+ !changan_qr_urlencode_value(sign_hex, enc_sign, CHANGAN_QR_FORM_ENC_SZ)) {
+ http_code = -1;
+ goto ST_CLEANUP;
+ }
+ if (!params->no_app_key && params->app_key != NULL) {
+ if (!changan_qr_urlencode_value(params->app_key, enc_key, CHANGAN_QR_FORM_ENC_SZ)) {
+ http_code = -1;
+ goto ST_CLEANUP;
+ }
+ }
+
+ int n;
+ if (!params->no_app_key && params->app_key != NULL) {
+ n = snprintf(url, CHANGAN_QR_URL_SZ, "%s?nonce=%s×tamp=%s&qrcodeId=%s&appKey=%s&sign=%s",
+ CHANGAN_HTTP_API_QRCODE_GET_STATUS_NO_BACKEND, enc_nonce, enc_ts, enc_qid, enc_key, enc_sign);
+ } else {
+ n = snprintf(url, CHANGAN_QR_URL_SZ, "%s?nonce=%s×tamp=%s&qrcodeId=%s&sign=%s",
+ CHANGAN_HTTP_API_QRCODE_GET_STATUS_NO_BACKEND, enc_nonce, enc_ts, enc_qid, enc_sign);
+ }
+ if (n <= 0 || (size_t)n >= CHANGAN_QR_URL_SZ) {
+ printf("[changan_http][qrcode_st] url overflow\r\n");
+ http_code = -1;
+ goto ST_CLEANUP;
+ }
+
+ if (HttpClientPrepare(&cd, CHANGAN_QR_HTTP_HDR_SZ, (int)resp_cap) != HTTP_SUCCESS) {
+ http_code = -1;
+ goto ST_CLEANUP;
+ }
+ cd_prepared = true;
+
+ client.header = "Content-Type: application/x-www-form-urlencoded\r\n";
+ HTTPC_RESULT hr = HttpClientGetRequest(&client, url, &cd);
+
+ http_code = client.responseCode;
+
+ if (hr == HTTP_SUCCESS && http_code == 200 && cd.responseBuf != NULL) {
+ changan_http_apply_cd_body_to_resp(&cd, resp_buf, resp_cap);
+ }
+
+ if (cd_prepared) {
+ HttpClientUnprepare(&cd);
+ cd_prepared = false;
+ }
+
+ST_CLEANUP:
+ free(sign_src);
+ free(url);
+ free(enc_blk);
+ return http_code;
+}
+
+int changan_http_qrcode_status_no_backend_v1(const changan_qrcode_status_no_backend_v1_params_t *params,
+ changan_http_result_cb_t cb, void *user_data)
+{
+ changan_http_job_t *job;
+
+ if (cb == NULL) {
+ return -100;
+ }
+ if (params == NULL) {
+ return -1;
+ }
+ job = (changan_http_job_t *)calloc(1, sizeof(changan_http_job_t));
+ if (job == NULL) {
+ return -101;
+ }
+ job->kind = CHANGAN_HTTP_JK_QR_ST;
+ job->req_type = CHANGAN_HTTP_REQ_QRCODE_STATUS_NO_BACKEND_V1;
+ job->done_cb = cb;
+ job->done_ud = user_data;
+ job->u.qr_st.params =
+ (const changan_qrcode_status_no_backend_v1_params_t *)changan_qr_st_params_heap_clone(params);
+ if (job->u.qr_st.params == NULL) {
+ free(job);
+ return -101;
+ }
+ job->u.qr_st.resp_heap = (uint8_t *)malloc((size_t)CHANGAN_HTTP_QR_STATUS_RESP_CAP);
+ if (job->u.qr_st.resp_heap == NULL) {
+ changan_qr_st_params_heap_free((changan_qrcode_status_no_backend_v1_params_t *)job->u.qr_st.params);
+ free((void *)job->u.qr_st.params);
+ free(job);
+ return -101;
+ }
+ job->u.qr_st.resp_cap = CHANGAN_HTTP_QR_STATUS_RESP_CAP;
+ return changan_http_submit_job(job);
+}
+
+
+// {
+// "userId":" c13f7d2d-25db-46fc-b7f8-1c4e953330f3",
+// "appId":" cn.com.changan.cvim",
+// "deviceId":" 367543dcd953ac8b2332a42eb3e246ef",
+// "algorithm":"RSA",
+// "publicKey":" +UH4ZY1Dt4zD/tk16HQa0MzzCX6P4LMO1uy8iF8QduON7JjOxUZDUBur7QR5s7X5/dHv2pUJVnehd8atn6xVodF3XVvXZognrBJkraf3knY7Y3isbCCFdU6h83w52ixFJIbUowIDAQAB"
+// }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
--- /dev/null
+#include "changan_http_sign.h"
+
+#include "mbedtls/base64.h"
+#include "mbedtls/ctr_drbg.h"
+#include "mbedtls/entropy.h"
+#include "mbedtls/md.h"
+#include "mbedtls/pk.h"
+#include "mbedtls/rsa.h"
+#include "mbedtls/sha256.h"
+#include "securec.h"
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#define CHANGAN_CTRL_SIGN_CANON_MAX 8192U
+
+static void changan_sign_kv_sort(changan_sign_kv_t *kv, int n)
+{
+ for (int i = 0; i < n - 1; i++) {
+ for (int j = i + 1; j < n; j++) {
+ if (strcmp(kv[i].k, kv[j].k) > 0) {
+ changan_sign_kv_t t = kv[i];
+
+ kv[i] = kv[j];
+ kv[j] = t;
+ }
+ }
+ }
+}
+
+int changan_build_java_like_sign_source(changan_sign_kv_t *kv, int n, char *out, uint32_t cap)
+{
+ changan_sign_kv_sort(kv, n);
+ uint32_t pos = 0;
+
+ for (int i = 0; i < n; i++) {
+ const char *k = kv[i].k;
+ const char *v = kv[i].v != NULL ? kv[i].v : "";
+
+ if (k == NULL || k[0] == '\0' || strcmp(k, "sign") == 0) {
+ continue;
+ }
+ if (cap <= pos) {
+ return -1;
+ }
+ int w = snprintf(out + pos, (size_t)(cap - pos), "%s=%s&", k, v);
+
+ if (w < 0 || (uint32_t)w >= cap - pos) {
+ return -1;
+ }
+ pos += (uint32_t)w;
+ }
+ return 0;
+}
+
+int changan_sha256_hex_upper_str(const char *s, char out65[65])
+{
+ mbedtls_sha256_context ctx;
+ unsigned char dig[32];
+ const char *use = (s != NULL) ? s : "";
+
+ mbedtls_sha256_init(&ctx);
+ if (mbedtls_sha256_starts(&ctx, 0) != 0) {
+ mbedtls_sha256_free(&ctx);
+ return -1;
+ }
+ if (mbedtls_sha256_update(&ctx, (const unsigned char *)use, strlen(use)) != 0) {
+ mbedtls_sha256_free(&ctx);
+ return -1;
+ }
+ if (mbedtls_sha256_finish(&ctx, dig) != 0) {
+ mbedtls_sha256_free(&ctx);
+ return -1;
+ }
+ mbedtls_sha256_free(&ctx);
+
+ static const char H[] = "0123456789ABCDEF";
+
+ for (int i = 0; i < 32; i++) {
+ out65[(size_t)i * 2U] = H[(dig[i] >> 4) & 0xF];
+ out65[(size_t)i * 2U + 1U] = H[dig[i] & 0xF];
+ }
+ out65[64] = '\0';
+ return 0;
+}
+
+static void changan_ctrl_sha256_hex_lower_bytes(const unsigned char *data, size_t len, char out65[65])
+{
+ unsigned char dig[32];
+ mbedtls_sha256_context ctx;
+
+ mbedtls_sha256_init(&ctx);
+ (void)mbedtls_sha256_starts(&ctx, 0);
+ (void)mbedtls_sha256_update(&ctx, data, len);
+ (void)mbedtls_sha256_finish(&ctx, dig);
+ mbedtls_sha256_free(&ctx);
+
+ static const char H[] = "0123456789abcdef";
+ for (int i = 0; i < 32; i++) {
+ out65[(size_t)i * 2U] = H[(dig[i] >> 4) & 0xF];
+ out65[(size_t)i * 2U + 1U] = H[dig[i] & 0xF];
+ }
+ out65[64] = '\0';
+}
+
+static void changan_ctrl_sha256_hex_lower_str(const char *s, char out65[65])
+{
+ const char *u = (s != NULL) ? s : "";
+
+ changan_ctrl_sha256_hex_lower_bytes((const unsigned char *)u, strlen(u), out65);
+}
+
+bool changan_ctrl_urlencode_val(const char *in, char *out, size_t out_sz)
+{
+ size_t j = 0;
+
+ if (out_sz == 0U) {
+ return false;
+ }
+ if (in == NULL) {
+ in = "";
+ }
+ for (size_t i = 0; in[i] != '\0'; i++) {
+ unsigned char c = (unsigned char)in[i];
+
+ if (c == ' ') {
+ if (j + 1U >= out_sz) {
+ return false;
+ }
+ out[j++] = '+';
+ } else if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
+ (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == '*') {
+ if (j + 1U >= out_sz) {
+ return false;
+ }
+ out[j++] = (char)c;
+ } else {
+ static const char H[] = "0123456789ABCDEF";
+
+ if (j + 3U >= out_sz) {
+ return false;
+ }
+ out[j++] = '%';
+ out[j++] = H[(c >> 4) & 0xFU];
+ out[j++] = H[c & 0xFU];
+ }
+ }
+ if (j >= out_sz) {
+ return false;
+ }
+ out[j] = '\0';
+ return true;
+}
+
+static int changan_ctrl_hmac_sha256_hex_lower(const unsigned char *key, size_t key_len, const char *msg, char out65[65])
+{
+ const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256);
+
+ if (md_info == NULL || msg == NULL) {
+ return -1;
+ }
+ unsigned char digest[32];
+
+ if (mbedtls_md_hmac(md_info, key, key_len, (const unsigned char *)msg, strlen(msg), digest) != 0) {
+ return -1;
+ }
+ static const char H[] = "0123456789abcdef";
+ for (int i = 0; i < 32; i++) {
+ out65[(size_t)i * 2U] = H[(digest[i] >> 4) & 0xF];
+ out65[(size_t)i * 2U + 1U] = H[digest[i] & 0xF];
+ }
+ out65[64] = '\0';
+ return 0;
+}
+
+/* 对齐 http/py/openc_car_getCarListByBrandCode_control_car_test.py::_print_sign_debug_annotated(步骤与注释结构) */
+static void changan_ctrl_car_sign_debug_print_splicing_lines(const char *splicing_full)
+{
+ const char *cur = splicing_full;
+ unsigned nline = 1U;
+
+ printf("[ctrl_car_sign_debug] ----- splicing line-by-line; <EMPTY> = blank line -----\r\n");
+ for (;;) {
+ const char *nl = strchr(cur, '\n');
+
+ if (nl == NULL) {
+ printf("[ctrl_car_sign_debug] %02u|%s\r\n", nline, (cur[0] == '\0') ? "<EMPTY>" : cur);
+ break;
+ }
+ if (nl == cur) {
+ printf("[ctrl_car_sign_debug] %02u|<EMPTY>\r\n", nline);
+ } else {
+ int line_len = (int)(nl - cur);
+ int show = line_len > 512 ? 512 : line_len;
+
+ printf("[ctrl_car_sign_debug] %02u|%.*s%s\r\n", nline, show, cur, line_len > 512 ? "..." : "");
+ }
+ nline++;
+ cur = nl + 1;
+ if (*cur == '\0') {
+ break;
+ }
+ }
+ printf("[ctrl_car_sign_debug] ------------------------------------------------\r\n");
+}
+
+static void changan_ctrl_car_sign_debug_print_hmac_key_bytes(const unsigned char *key, size_t key_len)
+{
+ printf("[ctrl_car_sign_debug] >>> HMAC 实际使用的密钥材料(mbedtls_md_hmac 的 key / keylen)\r\n");
+ printf("[ctrl_car_sign_debug] 长度: %u 字节\r\n", (unsigned)key_len);
+ if (key == NULL || key_len == 0U) {
+ printf("[ctrl_car_sign_debug] (empty)\r\n");
+ return;
+ }
+ for (size_t i = 0; i < key_len; i++) {
+ if ((i % 16U) == 0U) {
+ printf("[ctrl_car_sign_debug] %04u:", (unsigned)i);
+ }
+ printf(" %02X", key[i]);
+ if ((i % 16U) == 15U || (i + 1U) == key_len) {
+ printf("\r\n");
+ }
+ }
+}
+
+static void changan_ctrl_car_sign_debug_print_annotated(const changan_get_car_list_by_brand_params_t *p,
+ const char *path_used, const char *ts_buf, const char *query_wire, const char *head_block,
+ const char *body_sha, const char *splicing_full,
+ const unsigned char *hmac_key, size_t hmac_key_len,
+ const char *hashed_req, const char *string_to_sign, const char *authorization)
+{
+ const char *nonce = (p->nonce != NULL && p->nonce[0] != '\0') ? p->nonce : "WYYL";
+ const char *token = p->access_token;
+ const char *sk = p->secret_key;
+
+ printf("\r\n[ctrl_car_sign_debug] ========== SIGN DEBUG(ControlCarSign / py --sign-debug)==========\r\n");
+ printf("[ctrl_car_sign_debug] >>> key(verifySign 入参 secret;ControlCarSign.java:53)\r\n");
+ printf("[ctrl_car_sign_debug] HMAC:secret_key 按 UTF-8 原文作密钥\r\n");
+ printf("[ctrl_car_sign_debug] 入参 secret_key 字符串:\r\n");
+ printf("%s\r\n", (sk != NULL) ? sk : "(null)");
+ changan_ctrl_car_sign_debug_print_hmac_key_bytes(hmac_key, hmac_key_len);
+ printf("\r\n");
+
+ printf("[ctrl_car_sign_debug] >>> headmap(参与签名的四个头;verifySign 入参 headmap)\r\n");
+ printf("[ctrl_car_sign_debug] - X-VCS-User-Access-Token: %s\r\n", (token != NULL) ? token : "(null)");
+ printf("[ctrl_car_sign_debug] - X-VCS-Token: %s\r\n", (token != NULL) ? token : "(null)");
+ printf("[ctrl_car_sign_debug] - X-VCS-Timestamp: %s\r\n", ts_buf);
+ printf("[ctrl_car_sign_debug] - X-VCS-Nonce: %s\r\n", nonce);
+ printf("\r\n");
+
+ printf("[ctrl_car_sign_debug] >>> headMap2String(sortMapByKey(headmap))(key 小写 + ':' + value + '\\n')\r\n");
+ printf("%s", head_block);
+ printf("\r\n");
+
+ printf("[ctrl_car_sign_debug] >>> HashUtils.getSHA256(bodymap)(GET body 等价 \"\")\r\n");
+ printf("%s\r\n", body_sha);
+ printf("\r\n");
+
+ printf("[ctrl_car_sign_debug] >>> HashedCanonicalRequest splicing(method + \\n + url + \\n + query + \\n + head + \\n + bodySha)\r\n");
+ printf("[ctrl_car_sign_debug] httpMethod=GET httpUrl(path)=%s\r\n", path_used);
+ printf("[ctrl_car_sign_debug] query_wire=%s\r\n", query_wire);
+ printf("[ctrl_car_sign_debug] ----- splicing(含最后一行 bodySha)-----\r\n");
+ printf("%s", splicing_full);
+ printf("\r\n--------------------------------------\r\n\r\n");
+
+ changan_ctrl_car_sign_debug_print_splicing_lines(splicing_full);
+
+ printf("[ctrl_car_sign_debug] >>> HashedCanonicalRequest = SHA256(splicing) 小写 hex\r\n");
+ printf("%s\r\n", hashed_req);
+ printf("\r\n");
+
+ printf("[ctrl_car_sign_debug] >>> StringToSign(head2String / VCS-HMAC-SHA256 + \\n + time + \\n + HashedCanonicalRequest)\r\n");
+ printf("%s\r\n", string_to_sign);
+ printf("\r\n");
+
+ printf("[ctrl_car_sign_debug] >>> Authorization(HMAC-SHA256(StringToSign) 小写 hex → Signature=)\r\n");
+ printf("%s\r\n", authorization);
+ printf("[ctrl_car_sign_debug] ===============================================================\r\n\r\n");
+}
+
+int changan_control_car_build_authorization(const changan_get_car_list_by_brand_params_t *p,
+ char *timestamp_out, uint32_t ts_cap,
+ char *query_wire_out, uint32_t query_cap,
+ char *authorization_out, uint32_t auth_cap)
+{
+ char ts_buf[24] = {0};
+ char body_sha[65];
+ char hashed_req[65];
+ char string_to_sign[512];
+ char sig_hex[65];
+ char head_block[768];
+ char enc_brand[128];
+ char *canonical = NULL;
+ unsigned char key_bin[128];
+ size_t key_len = 0;
+
+ if (p == NULL || timestamp_out == NULL || ts_cap == 0U ||
+ query_wire_out == NULL || query_cap == 0U || authorization_out == NULL || auth_cap == 0U) {
+ return -1;
+ }
+ if (p->access_token == NULL || p->secret_key == NULL) {
+ printf("[changan_sign][ctrl_car] access_token/secret_key required\r\n");
+ return -1;
+ }
+
+ timestamp_out[0] = '\0';
+ query_wire_out[0] = '\0';
+ authorization_out[0] = '\0';
+
+ const char *path = (p->api_path != NULL && p->api_path[0] != '\0') ?
+ p->api_path : CHANGAN_HTTP_API_PATH_GET_CAR_LIST_BY_BRAND;
+ const char *brand = (p->brand_code != NULL && p->brand_code[0] != '\0') ? p->brand_code : "CHANGAN";
+
+ if (p->timestamp_sec != NULL && p->timestamp_sec[0] != '\0') {
+ if (strlen(p->timestamp_sec) >= sizeof(ts_buf)) {
+ return -1;
+ }
+ (void)memcpy_s(ts_buf, sizeof(ts_buf), p->timestamp_sec, strlen(p->timestamp_sec) + 1U);
+ } else {
+ (void)snprintf(ts_buf, sizeof(ts_buf), "%lld", (long long)time(NULL));
+ }
+
+ if (ts_cap <= (uint32_t)strlen(ts_buf)) {
+ return -1;
+ }
+ if (memcpy_s(timestamp_out, ts_cap, ts_buf, strlen(ts_buf) + 1U) != 0) {
+ return -1;
+ }
+
+ if (!changan_ctrl_urlencode_val(brand, enc_brand, sizeof(enc_brand))) {
+ return -1;
+ }
+ if (snprintf(query_wire_out, query_cap, "brandCode=%s", enc_brand) >= (int)query_cap) {
+ return -1;
+ }
+
+ changan_ctrl_sha256_hex_lower_str("", body_sha);
+
+ if (snprintf(head_block, sizeof(head_block),
+ "x-vcs-nonce:%s\n"
+ "x-vcs-timestamp:%s\n"
+ "x-vcs-token:%s\n"
+ "x-vcs-user-access-token:%s\n",
+ (p->nonce != NULL && p->nonce[0] != '\0') ? p->nonce : "WYYL",
+ ts_buf, p->access_token, p->access_token) >= (int)sizeof(head_block)) {
+ return -1;
+ }
+
+ key_len = strlen(p->secret_key);
+ if (key_len > sizeof(key_bin)) {
+ printf("[changan_sign][ctrl_car] secret too long\r\n");
+ return -1;
+ }
+ (void)memcpy_s(key_bin, sizeof(key_bin), p->secret_key, key_len);
+
+ canonical = (char *)malloc(CHANGAN_CTRL_SIGN_CANON_MAX);
+ if (canonical == NULL) {
+ return -1;
+ }
+ if (snprintf(canonical, CHANGAN_CTRL_SIGN_CANON_MAX, "GET\n%s\n%s\n%s\n%s",
+ path, query_wire_out, head_block, body_sha) >= (int)CHANGAN_CTRL_SIGN_CANON_MAX) {
+ free(canonical);
+ printf("[changan_sign][ctrl_car] canonical overflow\r\n");
+ return -1;
+ }
+
+ changan_ctrl_sha256_hex_lower_str(canonical, hashed_req);
+
+ if (snprintf(string_to_sign, sizeof(string_to_sign), "VCS-HMAC-SHA256\n%s\n%s", ts_buf, hashed_req) >= (int)sizeof(string_to_sign)) {
+ free(canonical);
+ return -1;
+ }
+
+ if (changan_ctrl_hmac_sha256_hex_lower(key_bin, key_len, string_to_sign, sig_hex) != 0) {
+ free(canonical);
+ printf("[changan_sign][ctrl_car] hmac failed\r\n");
+ return -1;
+ }
+
+ if (snprintf(authorization_out, auth_cap, "VCS-HMAC-SHA256 Signature=%s", sig_hex) >= (int)auth_cap) {
+ free(canonical);
+ return -1;
+ }
+
+ if (p->print_control_car_sign_debug) {
+ changan_ctrl_car_sign_debug_print_annotated(p, path, ts_buf, query_wire_out, head_block, body_sha, canonical,
+ key_bin, key_len, hashed_req, string_to_sign, authorization_out);
+ }
+
+ free(canonical);
+ return 0;
+}
+
+static int changan_ctrl_fill_timestamp(char *ts_buf, size_t ts_sz, const char *timestamp, bool timestamp_ms)
+{
+ if (ts_buf == NULL || ts_sz == 0U) {
+ return -1;
+ }
+ if (timestamp != NULL && timestamp[0] != '\0') {
+ if (strlen(timestamp) >= ts_sz) {
+ return -1;
+ }
+ (void)memcpy_s(ts_buf, ts_sz, timestamp, strlen(timestamp) + 1U);
+ return 0;
+ }
+ if (timestamp_ms) {
+ (void)snprintf(ts_buf, ts_sz, "%lld", (long long)time(NULL) * 1000LL);
+ } else {
+ (void)snprintf(ts_buf, ts_sz, "%lld", (long long)time(NULL));
+ }
+ return 0;
+}
+
+static int changan_ctrl_hmac_authorization(const char *secret_key,
+ const char *ts_buf, const char *canonical, char *authorization_out, uint32_t auth_cap)
+{
+ char hashed_req[65];
+ char string_to_sign[512];
+ char sig_hex[65];
+ unsigned char key_bin[128];
+ size_t key_len = 0;
+
+ if (secret_key == NULL || canonical == NULL || authorization_out == NULL || auth_cap == 0U) {
+ return -1;
+ }
+
+ changan_ctrl_sha256_hex_lower_str(canonical, hashed_req);
+ if (snprintf(string_to_sign, sizeof(string_to_sign), "VCS-HMAC-SHA256\n%s\n%s", ts_buf, hashed_req) >=
+ (int)sizeof(string_to_sign)) {
+ return -1;
+ }
+
+ key_len = strlen(secret_key);
+ if (key_len > sizeof(key_bin)) {
+ return -1;
+ }
+ (void)memcpy_s(key_bin, sizeof(key_bin), secret_key, key_len);
+
+ if (changan_ctrl_hmac_sha256_hex_lower(key_bin, key_len, string_to_sign, sig_hex) != 0) {
+ return -1;
+ }
+ if (snprintf(authorization_out, auth_cap, "VCS-HMAC-SHA256 Signature=%s", sig_hex) >= (int)auth_cap) {
+ return -1;
+ }
+ return 0;
+}
+
+int changan_control_car_build_authorization_for_http(const changan_control_car_auth_params_t *p,
+ char *timestamp_out, uint32_t ts_cap, char *authorization_out, uint32_t auth_cap)
+{
+ char ts_buf[24] = {0};
+ char body_sha[65];
+ char head_block[768];
+ char *canonical = NULL;
+ const char *method = NULL;
+ const char *path = NULL;
+ const char *query = NULL;
+ const char *body = NULL;
+
+ if (p == NULL || timestamp_out == NULL || ts_cap == 0U || authorization_out == NULL || auth_cap == 0U) {
+ return -1;
+ }
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_sign][vrtm_trace] a1 build_auth_http enter\r\n");
+#endif
+ if (p->access_token == NULL || p->secret_key == NULL || p->http_method == NULL || p->http_url == NULL) {
+ return -1;
+ }
+
+ timestamp_out[0] = '\0';
+ authorization_out[0] = '\0';
+
+ method = p->http_method;
+ path = p->http_url;
+ query = (p->query_wire != NULL) ? p->query_wire : "";
+ body = (p->body_for_sign != NULL) ? p->body_for_sign : "";
+
+ if (changan_ctrl_fill_timestamp(ts_buf, sizeof(ts_buf), p->timestamp, p->timestamp_ms) != 0) {
+ return -1;
+ }
+ if (ts_cap <= (uint32_t)strlen(ts_buf)) {
+ return -1;
+ }
+ if (memcpy_s(timestamp_out, ts_cap, ts_buf, strlen(ts_buf) + 1U) != 0) {
+ return -1;
+ }
+
+ changan_ctrl_sha256_hex_lower_str(body, body_sha);
+ if (snprintf(head_block, sizeof(head_block),
+ "x-vcs-nonce:%s\n"
+ "x-vcs-timestamp:%s\n"
+ "x-vcs-token:%s\n"
+ "x-vcs-user-access-token:%s\n",
+ (p->nonce != NULL && p->nonce[0] != '\0') ? p->nonce : "WYYL",
+ ts_buf, p->access_token, p->access_token) >= (int)sizeof(head_block)) {
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_sign][vrtm_trace] a2 head_block snprintf overflow cap=%u\r\n", (unsigned)sizeof(head_block));
+#endif
+ return -1;
+ }
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_sign][vrtm_trace] a2 head_block ok head_len=%u\r\n",
+ (unsigned)strnlen(head_block, sizeof(head_block)));
+#endif
+
+ canonical = (char *)malloc(CHANGAN_CTRL_SIGN_CANON_MAX);
+ if (canonical == NULL) {
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_sign][vrtm_trace] a3 canonical malloc fail\r\n");
+#endif
+ return -1;
+ }
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_sign][vrtm_trace] a3 canonical malloc ok\r\n");
+#endif
+ if (query[0] == '\0') {
+ if (snprintf(canonical, CHANGAN_CTRL_SIGN_CANON_MAX, "%s\n%s\n\n%s\n%s",
+ method, path, head_block, body_sha) >= (int)CHANGAN_CTRL_SIGN_CANON_MAX) {
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_sign][vrtm_trace] a4 canonical snprintf overflow (no query)\r\n");
+#endif
+ free(canonical);
+ return -1;
+ }
+ } else if (snprintf(canonical, CHANGAN_CTRL_SIGN_CANON_MAX, "%s\n%s\n%s\n%s\n%s",
+ method, path, query, head_block, body_sha) >= (int)CHANGAN_CTRL_SIGN_CANON_MAX) {
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_sign][vrtm_trace] a4 canonical snprintf overflow (query)\r\n");
+#endif
+ free(canonical);
+ return -1;
+ }
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_sign][vrtm_trace] a4 canonical_len=%u\r\n",
+ (unsigned)strnlen(canonical, CHANGAN_CTRL_SIGN_CANON_MAX));
+#endif
+
+ if (changan_ctrl_hmac_authorization(p->secret_key, ts_buf, canonical, authorization_out, auth_cap) != 0) {
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_sign][vrtm_trace] a5 hmac fail\r\n");
+#endif
+ free(canonical);
+ return -1;
+ }
+#if CHANGAN_HTTP_DEBUG_VRTM_TRACE
+ printf("[changan_sign][vrtm_trace] a5 hmac ok\r\n");
+#endif
+ free(canonical);
+ return 0;
+}
+
+static const unsigned char *changan_dkey_pem_skip_comment_header(const unsigned char *pem, size_t pem_len,
+ size_t *out_len)
+{
+ if (pem == NULL || out_len == NULL) {
+ return NULL;
+ }
+ *out_len = pem_len;
+ if (pem_len == 0U) {
+ return pem;
+ }
+ if (pem[0] == '#') {
+ const unsigned char *begin = (const unsigned char *)strstr((const char *)pem, "-----BEGIN");
+
+ if (begin == NULL) {
+ return NULL;
+ }
+ *out_len = pem_len - (size_t)(begin - pem);
+ return begin;
+ }
+ return pem;
+}
+
+static int changan_dkey_pkcs1_v15_encode_type1_tail(size_t key_len, const unsigned char *tail, size_t tail_len,
+ unsigned char *em)
+{
+ size_t ps_len;
+
+ if (em == NULL || tail == NULL) {
+ return -1;
+ }
+ if (tail_len > key_len - 11U) {
+ return -1;
+ }
+ ps_len = key_len - 3U - tail_len;
+ if (ps_len < 8U) {
+ return -1;
+ }
+ em[0] = 0x00;
+ em[1] = 0x01;
+ (void)memset(em + 2, 0xFF, ps_len);
+ em[2U + ps_len] = 0x00;
+ if (memcpy_s(em + 3U + ps_len, key_len - (3U + ps_len), tail, tail_len) != 0) {
+ return -1;
+ }
+ return 0;
+}
+
+int changan_dkey_build_private_key_sign(const char *car_id, const char *body_nonce, const char *public_key_id,
+ const char *user_id, int protocol_type, bool exclude_protocol_type,
+ const char *rsa_private_key_pem, char *sign_b64_out, uint32_t sign_b64_cap)
+{
+ char sign_data[512];
+ char protocol_buf[16];
+ unsigned char digest[32];
+ unsigned char *em = NULL;
+ unsigned char *sig = NULL;
+ unsigned char *sig_b64 = NULL;
+ mbedtls_pk_context pk;
+ mbedtls_entropy_context entropy;
+ mbedtls_ctr_drbg_context ctr_drbg;
+ mbedtls_rsa_context *rsa = NULL;
+ const unsigned char *pem_use = NULL;
+ size_t pem_len = 0;
+ size_t key_len = 0;
+ size_t sig_b64_len = 0;
+ int ret = -1;
+
+ if (car_id == NULL || body_nonce == NULL || public_key_id == NULL || user_id == NULL ||
+ rsa_private_key_pem == NULL || sign_b64_out == NULL || sign_b64_cap == 0U) {
+ return -1;
+ }
+ sign_b64_out[0] = '\0';
+
+ if (exclude_protocol_type) {
+ if (snprintf(sign_data, sizeof(sign_data), "%s%s%s%s",
+ car_id, body_nonce, public_key_id, user_id) >= (int)sizeof(sign_data)) {
+ return -1;
+ }
+ } else {
+ (void)snprintf(protocol_buf, sizeof(protocol_buf), "%d", protocol_type);
+ if (snprintf(sign_data, sizeof(sign_data), "%s%s%s%s%s",
+ car_id, body_nonce, protocol_buf, public_key_id, user_id) >= (int)sizeof(sign_data)) {
+ return -1;
+ }
+ }
+
+ {
+ mbedtls_sha256_context ctx;
+
+ mbedtls_sha256_init(&ctx);
+ (void)mbedtls_sha256_starts(&ctx, 0);
+ (void)mbedtls_sha256_update(&ctx, (const unsigned char *)sign_data, strlen(sign_data));
+ (void)mbedtls_sha256_finish(&ctx, digest);
+ mbedtls_sha256_free(&ctx);
+ }
+
+ pem_use = changan_dkey_pem_skip_comment_header((const unsigned char *)rsa_private_key_pem,
+ strlen(rsa_private_key_pem), &pem_len);
+ if (pem_use == NULL) {
+ return -1;
+ }
+ pem_len = strlen((const char *)pem_use);
+
+ mbedtls_pk_init(&pk);
+ mbedtls_entropy_init(&entropy);
+ mbedtls_ctr_drbg_init(&ctr_drbg);
+ if (mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy,
+ (const unsigned char *)"changan_dkey", 12U) != 0) {
+ goto EXIT;
+ }
+ if (mbedtls_pk_parse_key(&pk, pem_use, pem_len + 1U, NULL, 0U, mbedtls_ctr_drbg_random, &ctr_drbg) != 0) {
+ goto EXIT;
+ }
+ if (!mbedtls_pk_can_do(&pk, MBEDTLS_PK_RSA)) {
+ goto EXIT;
+ }
+ rsa = mbedtls_pk_rsa(pk);
+ key_len = mbedtls_rsa_get_len(rsa);
+ em = (unsigned char *)malloc(key_len);
+ sig = (unsigned char *)malloc(key_len);
+ sig_b64 = (unsigned char *)malloc(key_len * 2U);
+ if (em == NULL || sig == NULL || sig_b64 == NULL) {
+ goto EXIT;
+ }
+ if (changan_dkey_pkcs1_v15_encode_type1_tail(key_len, digest, sizeof(digest), em) != 0) {
+ goto EXIT;
+ }
+ if (mbedtls_rsa_private(rsa, mbedtls_ctr_drbg_random, &ctr_drbg, em, sig) != 0) {
+ goto EXIT;
+ }
+ if (mbedtls_base64_encode(sig_b64, key_len * 2U, &sig_b64_len, sig, key_len) != 0) {
+ goto EXIT;
+ }
+ if (sig_b64_len + 1U > (size_t)sign_b64_cap) {
+ goto EXIT;
+ }
+ if (memcpy_s(sign_b64_out, sign_b64_cap, sig_b64, sig_b64_len + 1U) != 0) {
+ goto EXIT;
+ }
+ ret = 0;
+
+EXIT:
+ free(em);
+ free(sig);
+ free(sig_b64);
+ mbedtls_pk_free(&pk);
+ mbedtls_entropy_free(&entropy);
+ mbedtls_ctr_drbg_free(&ctr_drbg);
+ return ret;
+}
+
+static int changan_dkey_pk_init_from_pem(const char *rsa_private_key_pem, mbedtls_pk_context *pk,
+ mbedtls_entropy_context *entropy, mbedtls_ctr_drbg_context *ctr_drbg)
+{
+ const unsigned char *pem_use = NULL;
+ size_t pem_len = 0;
+
+ if (rsa_private_key_pem == NULL || pk == NULL || entropy == NULL || ctr_drbg == NULL) {
+ return -1;
+ }
+
+ pem_use = changan_dkey_pem_skip_comment_header((const unsigned char *)rsa_private_key_pem,
+ strlen(rsa_private_key_pem), &pem_len);
+ if (pem_use == NULL) {
+ return -1;
+ }
+ pem_len = strlen((const char *)pem_use);
+
+ mbedtls_pk_init(pk);
+ mbedtls_entropy_init(entropy);
+ mbedtls_ctr_drbg_init(ctr_drbg);
+ if (mbedtls_ctr_drbg_seed(ctr_drbg, mbedtls_entropy_func, entropy,
+ (const unsigned char *)"changan_dkey", 12U) != 0) {
+ return -1;
+ }
+ if (mbedtls_pk_parse_key(pk, pem_use, pem_len + 1U, NULL, 0U, mbedtls_ctr_drbg_random, ctr_drbg) != 0) {
+ return -1;
+ }
+ if (!mbedtls_pk_can_do(pk, MBEDTLS_PK_RSA)) {
+ return -1;
+ }
+ return 0;
+}
+
+static void changan_dkey_pk_teardown(mbedtls_pk_context *pk, mbedtls_entropy_context *entropy,
+ mbedtls_ctr_drbg_context *ctr_drbg)
+{
+ if (pk != NULL) {
+ mbedtls_pk_free(pk);
+ }
+ if (entropy != NULL) {
+ mbedtls_entropy_free(entropy);
+ }
+ if (ctr_drbg != NULL) {
+ mbedtls_ctr_drbg_free(ctr_drbg);
+ }
+}
+
+static int changan_dkey_hex_nibble(int c)
+{
+ if (c >= '0' && c <= '9') {
+ return c - '0';
+ }
+ if (c >= 'A' && c <= 'F') {
+ return c - 'A' + 10;
+ }
+ if (c >= 'a' && c <= 'f') {
+ return c - 'a' + 10;
+ }
+ return -1;
+}
+
+/** 仅含十六进制且偶数长度(与开放平台 cardInfoEnc/dkeyEnc 部分环境一致) */
+static bool changan_dkey_cipher_string_is_hex_even(const char *s, size_t slen)
+{
+ size_t i;
+
+ if (slen < 2U || (slen & 1U) != 0U) {
+ return false;
+ }
+ for (i = 0; i < slen; i++) {
+ if (changan_dkey_hex_nibble((unsigned char)s[i]) < 0) {
+ return false;
+ }
+ }
+ return true;
+}
+
+static int changan_dkey_hex_decode_string(const char *hex, size_t hex_len, unsigned char *out, size_t out_cap,
+ size_t *out_len)
+{
+ size_t j;
+ size_t nbin;
+
+ if (hex == NULL || out == NULL || out_len == NULL || (hex_len & 1U) != 0U) {
+ return -1;
+ }
+ nbin = hex_len / 2U;
+ if (nbin > out_cap) {
+ return -1;
+ }
+ for (j = 0; j < nbin; j++) {
+ int hi = changan_dkey_hex_nibble((unsigned char)hex[j * 2U]);
+ int lo = changan_dkey_hex_nibble((unsigned char)hex[j * 2U + 1U]);
+
+ if (hi < 0 || lo < 0) {
+ return -1;
+ }
+ out[j] = (unsigned char)(((unsigned)hi << 4) | (unsigned)lo);
+ }
+ *out_len = nbin;
+ return 0;
+}
+
+int changan_dkey_rsa_decrypt_base64_ciphertext(const char *cipher_b64, const char *rsa_private_key_pem,
+ unsigned char *plain_out, size_t plain_cap, size_t *plain_len_out)
+{
+ mbedtls_pk_context pk;
+ mbedtls_entropy_context entropy;
+ mbedtls_ctr_drbg_context ctr_drbg;
+ unsigned char *cipher_bin = NULL;
+ size_t cipher_len = 0;
+ size_t plain_len = 0;
+ size_t slen = 0;
+ size_t bin_cap = 0;
+ size_t rsa_byte_len = 0;
+ bool from_hex = false;
+ int ret = -1;
+
+ if (cipher_b64 == NULL || cipher_b64[0] == '\0' || rsa_private_key_pem == NULL ||
+ plain_out == NULL || plain_cap == 0U || plain_len_out == NULL) {
+ return -1;
+ }
+ *plain_len_out = 0;
+
+ slen = strlen(cipher_b64);
+
+ if (changan_dkey_pk_init_from_pem(rsa_private_key_pem, &pk, &entropy, &ctr_drbg) != 0) {
+ printf("[changan_http][dkey_dec] RSA private PEM load failed\r\n");
+ return -1;
+ }
+
+ rsa_byte_len = (mbedtls_pk_get_bitlen(&pk) + 7U) / 8U;
+ if (rsa_byte_len == 0U) {
+ changan_dkey_pk_teardown(&pk, &entropy, &ctr_drbg);
+ return -1;
+ }
+
+ bin_cap = slen / 2U + 32U;
+ if (bin_cap < (slen / 4U + 2U) * 3U) {
+ bin_cap = (slen / 4U + 2U) * 3U;
+ }
+ cipher_bin = (unsigned char *)malloc(bin_cap);
+ if (cipher_bin == NULL) {
+ printf("[changan_http][dkey_dec] ciphertext decode malloc failed\r\n");
+ changan_dkey_pk_teardown(&pk, &entropy, &ctr_drbg);
+ return -1;
+ }
+
+ if (changan_dkey_cipher_string_is_hex_even(cipher_b64, slen) && (slen / 2U) % rsa_byte_len == 0U &&
+ (slen / 2U) > 0U) {
+ if (changan_dkey_hex_decode_string(cipher_b64, slen, cipher_bin, bin_cap, &cipher_len) == 0) {
+ from_hex = true;
+ printf("[changan_http][dkey_dec] ciphertext wire=hex bin_len=%u\r\n", (unsigned)cipher_len);
+ }
+ }
+ if (!from_hex) {
+ if (mbedtls_base64_decode(cipher_bin, bin_cap, &cipher_len, (const unsigned char *)cipher_b64, slen) != 0) {
+ printf("[changan_http][dkey_dec] ciphertext base64 decode failed\r\n");
+ changan_dkey_pk_teardown(&pk, &entropy, &ctr_drbg);
+ free(cipher_bin);
+ return -1;
+ }
+ printf("[changan_http][dkey_dec] ciphertext wire=base64 bin_len=%u\r\n", (unsigned)cipher_len);
+ }
+
+ if (cipher_len % rsa_byte_len != 0U) {
+ printf("[changan_http][dkey_dec] RSA ciphertext len %u not multiple of key block %u\r\n",
+ (unsigned)cipher_len, (unsigned)rsa_byte_len);
+ changan_dkey_pk_teardown(&pk, &entropy, &ctr_drbg);
+ free(cipher_bin);
+ return -1;
+ }
+
+ plain_len = 0;
+ for (size_t off = 0; off < cipher_len; off += rsa_byte_len) {
+ size_t chunk_plain = 0;
+ size_t room = (plain_len < plain_cap) ? (plain_cap - plain_len) : 0U;
+
+ if (room == 0U) {
+ printf("[changan_http][dkey_dec] RSA plain buffer full (need more plain_cap)\r\n");
+ changan_dkey_pk_teardown(&pk, &entropy, &ctr_drbg);
+ free(cipher_bin);
+ return -1;
+ }
+ if (mbedtls_pk_decrypt(&pk, cipher_bin + off, rsa_byte_len, plain_out + plain_len, &chunk_plain, room,
+ mbedtls_ctr_drbg_random, &ctr_drbg) != 0) {
+ printf("[changan_http][dkey_dec] RSA decrypt failed off=%u blocks=%u/%u (wrong PEM or corrupt cipher)\r\n",
+ (unsigned)off, (unsigned)(off / rsa_byte_len + 1U), (unsigned)(cipher_len / rsa_byte_len));
+ changan_dkey_pk_teardown(&pk, &entropy, &ctr_drbg);
+ free(cipher_bin);
+ return -1;
+ }
+ plain_len += chunk_plain;
+ }
+
+ *plain_len_out = plain_len;
+ changan_dkey_pk_teardown(&pk, &entropy, &ctr_drbg);
+ free(cipher_bin);
+ ret = 0;
+ return ret;
+}
+
+int changan_dkey_decrypt_download_owner_key_fields(const char *card_info_enc_b64, const char *dkey_enc_b64,
+ const char *rsa_private_key_pem,
+ char *card_info_out, uint32_t card_info_cap, uint32_t *card_info_len_out,
+ uint8_t *dkey_out, uint32_t dkey_cap, uint32_t *dkey_len_out)
+{
+ bool want_card = (card_info_out != NULL && card_info_cap > 0U);
+ bool want_dkey = (dkey_out != NULL && dkey_cap > 0U);
+ enum { k_plain_work = 4096 };
+ unsigned char *plain_buf = NULL;
+ size_t plain_len = 0;
+ int ret = -1;
+
+ if (rsa_private_key_pem == NULL || (!want_card && !want_dkey)) {
+ return -1;
+ }
+
+ plain_buf = (unsigned char *)malloc((size_t)k_plain_work);
+ if (plain_buf == NULL) {
+ printf("[changan_http][dkey_dec] plain workbuf malloc failed\r\n");
+ return -1;
+ }
+ (void)memset(plain_buf, 0, (size_t)k_plain_work);
+
+ if (want_card) {
+ card_info_out[0] = '\0';
+ if (card_info_len_out != NULL) {
+ *card_info_len_out = 0U;
+ }
+ }
+ if (want_dkey && dkey_len_out != NULL) {
+ *dkey_len_out = 0U;
+ }
+
+ if (want_card) {
+ if (card_info_enc_b64 == NULL || card_info_enc_b64[0] == '\0') {
+ printf("[changan_http][dkey_dec] cardInfoEnc missing or empty\r\n");
+ goto out;
+ }
+ if (changan_dkey_rsa_decrypt_base64_ciphertext(card_info_enc_b64, rsa_private_key_pem,
+ plain_buf, (size_t)k_plain_work, &plain_len) != 0) {
+ printf("[changan_http][dkey_dec] cardInfoEnc RSA decrypt failed\r\n");
+ goto out;
+ }
+ if (plain_len >= (size_t)card_info_cap) {
+ printf("[changan_http][dkey_dec] cardInfo plain too long %u cap %u\r\n", (unsigned)plain_len,
+ (unsigned)card_info_cap);
+ goto out;
+ }
+ if (memcpy_s(card_info_out, card_info_cap, plain_buf, plain_len) != 0) {
+ goto out;
+ }
+ card_info_out[plain_len] = '\0';
+ if (card_info_len_out != NULL) {
+ *card_info_len_out = (uint32_t)plain_len;
+ }
+ }
+
+ if (want_dkey) {
+ if (dkey_enc_b64 == NULL || dkey_enc_b64[0] == '\0') {
+ printf("[changan_http][dkey_dec] dkeyEnc missing or empty\r\n");
+ goto out;
+ }
+ if (changan_dkey_rsa_decrypt_base64_ciphertext(dkey_enc_b64, rsa_private_key_pem,
+ plain_buf, (size_t)k_plain_work, &plain_len) != 0) {
+ printf("[changan_http][dkey_dec] dkeyEnc RSA decrypt failed\r\n");
+ goto out;
+ }
+ if (plain_len > (size_t)dkey_cap) {
+ printf("[changan_http][dkey_dec] dkey plain too long %u cap %u\r\n", (unsigned)plain_len,
+ (unsigned)dkey_cap);
+ goto out;
+ }
+ if (memcpy_s(dkey_out, dkey_cap, plain_buf, plain_len) != 0) {
+ goto out;
+ }
+ if (dkey_len_out != NULL) {
+ *dkey_len_out = (uint32_t)plain_len;
+ }
+ }
+
+ ret = 0;
+out:
+ free(plain_buf);
+ return ret;
+}
+
+int changan_dkey_generate_rsa2048_keypair(char *private_pem_out, uint32_t private_pem_cap,
+ char *public_spki_b64_out, uint32_t public_spki_b64_cap)
+{
+ mbedtls_pk_context pk;
+ mbedtls_entropy_context entropy;
+ mbedtls_ctr_drbg_context ctr_drbg;
+ unsigned char der_buf[512];
+ unsigned char b64_buf[768];
+ int der_len;
+ size_t olen = 0;
+ int ret = -1;
+
+ if (private_pem_out == NULL || public_spki_b64_out == NULL ||
+ private_pem_cap == 0U || public_spki_b64_cap == 0U) {
+ return -1;
+ }
+ private_pem_out[0] = '\0';
+ public_spki_b64_out[0] = '\0';
+
+ mbedtls_pk_init(&pk);
+ mbedtls_entropy_init(&entropy);
+ mbedtls_ctr_drbg_init(&ctr_drbg);
+
+ if (mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy,
+ (const unsigned char *)"changan_dkey_gen", 16U) != 0) {
+ goto cleanup;
+ }
+ if (mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) != 0) {
+ goto cleanup;
+ }
+ if (mbedtls_rsa_gen_key(mbedtls_pk_rsa(pk), mbedtls_ctr_drbg_random, &ctr_drbg, 2048U, 65537) != 0) {
+ goto cleanup;
+ }
+ if (mbedtls_pk_write_key_pem(&pk, (unsigned char *)private_pem_out, (size_t)private_pem_cap) != 0) {
+ goto cleanup;
+ }
+
+ der_len = mbedtls_pk_write_pubkey_der(&pk, der_buf, sizeof(der_buf));
+ if (der_len <= 0 || (size_t)der_len > sizeof(der_buf)) {
+ goto cleanup;
+ }
+ {
+ const unsigned char *der_start = der_buf + sizeof(der_buf) - (size_t)der_len;
+
+ if (mbedtls_base64_encode(b64_buf, sizeof(b64_buf), &olen, der_start, (size_t)der_len) != 0) {
+ goto cleanup;
+ }
+ }
+ if (olen + 1U > (size_t)public_spki_b64_cap) {
+ goto cleanup;
+ }
+ if (memcpy_s(public_spki_b64_out, public_spki_b64_cap, b64_buf, olen + 1U) != 0) {
+ goto cleanup;
+ }
+ ret = 0;
+
+cleanup:
+ if (ret != 0) {
+ if (private_pem_out != NULL) {
+ private_pem_out[0] = '\0';
+ }
+ if (public_spki_b64_out != NULL) {
+ public_spki_b64_out[0] = '\0';
+ }
+ }
+ mbedtls_pk_free(&pk);
+ mbedtls_entropy_free(&entropy);
+ mbedtls_ctr_drbg_free(&ctr_drbg);
+ return ret;
+}
--- /dev/null
+#ifndef CHANGAN_HTTP_SIGN_H
+#define CHANGAN_HTTP_SIGN_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "changan_http_api.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** openC v1:签名参数键值(对齐 TreeMap 排序后 key=value& 拼串) */
+typedef struct {
+ const char *k;
+ const char *v;
+} changan_sign_kv_t;
+
+/**
+ * 按 key ASCII 升序拼接 sign 原文:跳过空 key、跳过 key==sign;每项 key=value&(末尾保留 &)
+ * @return 0 成功;-1 缓冲区不足或其它错误
+ */
+int changan_build_java_like_sign_source(changan_sign_kv_t *kv, int n, char *out, uint32_t cap);
+
+/** UTF-8 字符串 SHA256,输出 64 位大写十六进制 + NUL */
+int changan_sha256_hex_upper_str(const char *s, char out65[65]);
+
+/** Query 值 URL 编码(与 Python urllib / 控车脚本一致:空格为 +,其余非安全字符为 %XX) */
+bool changan_ctrl_urlencode_val(const char *in, char *out, size_t out_sz);
+
+/**
+ * ControlCarSign.verifySign:生成 Authorization(及签名用的 timestamp、query 串)。
+ * 对齐 http/py/openc_car_getCarListByBrandCode_control_car_test.py。
+ * @return 0 成功;-1 失败
+ */
+int changan_control_car_build_authorization(const changan_get_car_list_by_brand_params_t *params,
+ char *timestamp_out, uint32_t ts_cap,
+ char *query_wire_out, uint32_t query_cap,
+ char *authorization_out, uint32_t auth_cap);
+
+/** GET/POST ControlCarSign;timestamp_out 为实际写入请求头的 X-VCS-Timestamp */
+int changan_control_car_build_authorization_for_http(const changan_control_car_auth_params_t *params,
+ char *timestamp_out, uint32_t ts_cap,
+ char *authorization_out, uint32_t auth_cap);
+
+/**
+ * privateKeySign:字段按 key 排序后仅拼接 value → SHA-256 → PKCS#1 type1 尾随 digest → NONEwithRSA → Base64。
+ * @return 0 成功;-1 失败
+ */
+int changan_dkey_build_private_key_sign(const char *car_id, const char *body_nonce, const char *public_key_id,
+ const char *user_id, int protocol_type, bool exclude_protocol_type,
+ const char *rsa_private_key_pem, char *sign_b64_out, uint32_t sign_b64_cap);
+
+/** Base64 或「全十六进制 ASCII、偶数长度」密文 → RSA PKCS#1 v1.5 私钥解密;多块密文按模长分段(对齐 Java RSA/ECB/PKCS1Padding) */
+int changan_dkey_rsa_decrypt_base64_ciphertext(const char *cipher_b64, const char *rsa_private_key_pem,
+ unsigned char *plain_out, size_t plain_cap, size_t *plain_len_out);
+
+/** 解密 download-owner-key data 字段;card_info_enc_b64 / dkey_enc_b64 可单独为 NULL */
+int changan_dkey_decrypt_download_owner_key_fields(const char *card_info_enc_b64, const char *dkey_enc_b64,
+ const char *rsa_private_key_pem,
+ char *card_info_out, uint32_t card_info_cap, uint32_t *card_info_len_out,
+ uint8_t *dkey_out, uint32_t dkey_cap, uint32_t *dkey_len_out);
+
+/**
+ * 本地生成 RSA-2048(e=65537),对齐 Python cryptography 默认。
+ * 私钥 PEM 为 mbedtls 输出的「RSA PRIVATE KEY」(PKCS#1);公钥为 SubjectPublicKeyInfo DER 的 Base64,供 public-key-register。
+ * @return 0 成功;-1 失败
+ */
+int changan_dkey_generate_rsa2048_keypair(char *private_pem_out, uint32_t private_pem_cap,
+ char *public_spki_b64_out, uint32_t public_spki_b64_cap);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CHANGAN_HTTP_SIGN_H */
--- /dev/null
+#!/usr/bin/env python3
+"""
+openC - vrtm 控车综合脚本(单入口,--command 选择指令)
+
+与独立脚本相同:POST + JSON Body + ControlCarSign(build_authorization_control_car)。
+
+支持的 --command 与独立脚本对应关系见 ``python openc_car_control_v2_test.py -h`` 末尾 epilog。
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import ssl
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+# (URL 路径最后一段, Body.cmd, 中文说明)
+VRTM_CAR_COMMANDS: dict[str, tuple[str, str, str]] = {
+ "close_air": ("closeAir", "closeAir", "关闭空调"),
+ "close_window": ("closeWindow", "CloseWindow", "关闭车窗"),
+ "flash_light": ("flashLight", "flashLight", "闪灯"),
+ "lock_door": ("lockDoor", "LockDoor", "锁定车门"),
+ "open_air": ("openAir", "openAir", "打开空调"),
+ "remote_search_car": ("remoteSearchCar", "remoteSearchCar", "闪灯鸣笛/远程寻车"),
+ "unlock_door": ("unLockDoor", "UnLockDoor", "解锁车门"),
+ "up_car_condition": ("upCarCondition", "upCarCondition", "车辆上报车况"),
+ "window_slit": ("windowSlit", "windowSlit", "车窗留缝"),
+}
+
+CAR_CONTROL_PATH_PREFIX = "/openc-apigw/vrtm-agent/api/v2/open/car-control/"
+
+
+def _commands_epilog() -> str:
+ lines = [
+ "支持的 --command 取值(每项:CLI 名 → URL 路径段 / Body.cmd / 说明)",
+ "",
+ ]
+ for key in sorted(VRTM_CAR_COMMANDS):
+ seg, cmd, desc = VRTM_CAR_COMMANDS[key]
+ lines.append(f" {key:<22} {seg} / {cmd} {desc}")
+ lines.extend(
+ [
+ "",
+ "默认 verifySign 的 httpUrl 为单段网关前缀:",
+ f" {CAR_CONTROL_PATH_PREFIX}<路径段>",
+ "若网关要求双前缀 /openc-apigw/openc-apigw/...,请用 --api-path 传入完整路径。",
+ "",
+ "独立脚本对照:",
+ " unlock_door → openc_car_unlockDoor_v2_test.py",
+ " lock_door → openc_car_lockDoor_v2_test.py",
+ " remote_search_car → openc_car_remoteSearchCar_v2_test.py",
+ " flash_light → openc_car_flashLight_v2_test.py",
+ " close_air → openc_car_closeAir_v2_test.py",
+ " window_slit → openc_car_windowSlit_v2_test.py",
+ " open_air → openc_car_openAir_v2_test.py",
+ " close_window → openc_car_closeWindow_v2_test.py",
+ " up_car_condition → openc_car_upCarCondition_v2_test.py",
+ ]
+ )
+ return "\n".join(lines)
+
+
+def _load_sign_module():
+ base = Path(__file__).resolve().parent
+ path = base / "openc_car_getCarListByBrandCode_v3_test.py"
+ if not path.is_file():
+ raise FileNotFoundError(f"找不到签名模块: {path}")
+ spec = importlib.util.spec_from_file_location("_openc_car_control_unified", path)
+ if spec is None or spec.loader is None:
+ raise RuntimeError(f"无法加载: {path}")
+ mod = importlib.util.module_from_spec(spec)
+ sys.modules["_openc_car_control_unified"] = mod
+ spec.loader.exec_module(mod)
+ return mod
+
+
+def main() -> None:
+ mod = _load_sign_module()
+ cmd_choices = sorted(VRTM_CAR_COMMANDS)
+ _cmd_metavar = "{" + "|".join(cmd_choices) + "}"
+
+ class _Fmt(argparse.RawDescriptionHelpFormatter, argparse.ArgumentDefaultsHelpFormatter):
+ pass
+
+ p = argparse.ArgumentParser(
+ description="vrtm 控车综合 POST(ControlCarSign,--command 选择指令)",
+ formatter_class=_Fmt,
+ epilog=_commands_epilog(),
+ )
+ p.add_argument(
+ "--command",
+ required=True,
+ choices=cmd_choices,
+ metavar=_cmd_metavar,
+ help="控车指令;可选值即 usage 中花括号内列表,说明见下方 epilog",
+ )
+ p.add_argument(
+ "--body-cmd",
+ default=None,
+ help="覆盖 JSON Body 中的 cmd(默认由 --command 决定;仅当平台与文档不一致时使用)",
+ )
+ p.add_argument("--access-token", "--accessToken", dest="access_token", default=None)
+ p.add_argument(
+ "--secret-key",
+ "--client-secret",
+ dest="secret_key",
+ default=None,
+ help="verifySign HMAC 密钥(与开放平台 SECRETKEY 一致)",
+ )
+ p.add_argument("--car-id", "--carId", dest="car_id", required=True, help="车辆 ID")
+ p.add_argument(
+ "--map-args-json",
+ default="{}",
+ help='mapArgsJson 字符串;open_air 可传如 {"temperature":20,"airModel":1,"windPower":1}',
+ )
+ p.add_argument("--sender-type", "--senderType", dest="sender_type", default="APP")
+ p.add_argument(
+ "--timestamp",
+ default=None,
+ help="X-VCS-Timestamp;未传则当前毫秒(13 位)",
+ )
+ p.add_argument(
+ "--timestamp-seconds",
+ action="store_true",
+ help="未传 --timestamp 时使用当前秒(10 位)",
+ )
+ p.add_argument("--nonce", default="RANDOM", help="X-VCS-Nonce,4 位;默认 RANDOM")
+ p.add_argument(
+ "--api-path",
+ default=None,
+ help="覆盖 verifySign 与 POST 的完整 httpUrl 路径(默认由 --command 拼出单段前缀)",
+ )
+ p.add_argument(
+ "--secret-base64-decoded",
+ action="store_true",
+ help="HMAC 密钥:对 secret-key 先 Base64 解码",
+ )
+ p.add_argument("--java-log", action="store_true", help="ControlCarSign.java 风格 Log 行")
+ p.add_argument(
+ "--debug",
+ action="store_true",
+ help="打印 body、HashUtils.getSHA256(body)、head、splicing、StringToSign",
+ )
+ p.add_argument("--timeout", type=float, default=30.0)
+ p.add_argument("--insecure", action="store_true")
+
+ p.add_argument("--grant-type", choices=["authorization_code", "refresh_token"], default="refresh_token")
+ p.add_argument("--code", default=None)
+ p.add_argument("--redirect-uri", default=None)
+ p.add_argument("--refresh-token", default=None)
+ p.add_argument("--client-id", default=mod.DEFAULT_CLIENT_ID)
+ p.add_argument("--oauth-client-secret", default=mod.DEFAULT_CLIENT_SECRET)
+
+ args = p.parse_args()
+
+ if not args.secret_key:
+ p.error("必须提供 --secret-key")
+
+ path_segment, default_body_cmd, _desc = VRTM_CAR_COMMANDS[args.command]
+ body_cmd = args.body_cmd if args.body_cmd is not None else default_body_cmd
+ default_path = f"{CAR_CONTROL_PATH_PREFIX}{path_segment}"
+ path_use = (args.api_path or default_path).strip()
+
+ token = args.access_token
+ if not token:
+ token = mod.fetch_user_access_token(
+ timeout=args.timeout,
+ insecure=args.insecure,
+ grant_type=args.grant_type,
+ client_id=args.client_id,
+ client_secret=args.oauth_client_secret,
+ code=args.code,
+ redirect_uri=args.redirect_uri,
+ refresh_token=args.refresh_token,
+ )
+
+ if args.timestamp_seconds:
+ ts = args.timestamp or str(int(time.time()))
+ else:
+ ts = args.timestamp or str(int(time.time() * 1000))
+ nonce = args.nonce
+ if nonce.upper() == "RANDOM":
+ nonce = mod.rand_nonce(4)
+
+ body_obj = {
+ "mapArgsJson": args.map_args_json,
+ "senderType": args.sender_type,
+ "cmd": body_cmd,
+ "carId": args.car_id,
+ }
+ body_wire = json.dumps(body_obj, ensure_ascii=False, separators=(",", ":"))
+
+ authorization, _qw, head_block, string_to_sign, splicing_full = mod.build_authorization_control_car(
+ client_secret=args.secret_key,
+ token=token,
+ timestamp=ts,
+ nonce=nonce,
+ query_params=None,
+ http_url=path_use,
+ hmac_secret_base64_decode=args.secret_base64_decoded,
+ java_style_log=args.java_log,
+ http_method="POST",
+ body_for_sign=body_wire,
+ )
+
+ url = f"https://{mod.SERVER}{path_use}"
+ headers = {
+ "Content-Type": "application/json",
+ mod.TOKEN_HEADER_NAME: token,
+ mod.X_VCS_TOKEN: token,
+ mod.X_VCS_TIMESTAMP: ts,
+ mod.X_VCS_NONCE: nonce,
+ "Authorization": authorization,
+ }
+
+ if args.debug:
+ body_sha_hex = mod.hash_utils_get_sha256_for_control_car(body_wire)
+ print(">>> command / path / body.cmd")
+ print(f" {args.command} {path_use} {body_cmd!r}")
+ print()
+ print(">>> 参与签名的 HTTP Body 原文(UTF-8,须与发包一致)")
+ print(body_wire)
+ print()
+ print(">>> HashUtils.getSHA256(bodymap) 小写 hex")
+ print(body_sha_hex)
+ print()
+ print(">>> headMap2String block")
+ print(head_block, end="")
+ print()
+ print(">>> HashedCanonicalRequest splicing")
+ print(splicing_full)
+ print()
+ print(">>> StringToSign")
+ print(string_to_sign)
+ print()
+
+ print(">>> 请求 URL:" + url)
+ print("========== 请求报文 ==========")
+ print(f"POST {path_use} HTTP/1.1")
+ print(f"Host: {mod.SERVER}")
+ for k, v in headers.items():
+ print(f"{k}: {v}")
+ print()
+ print(body_wire)
+ print("==============================")
+ print()
+
+ ctx = ssl.create_default_context()
+ if args.insecure:
+ ctx.check_hostname = False
+ ctx.verify_mode = ssl.CERT_NONE
+
+ req = urllib.request.Request(
+ url,
+ data=body_wire.encode("utf-8"),
+ headers=headers,
+ method="POST",
+ )
+ try:
+ with urllib.request.urlopen(req, timeout=args.timeout, context=ctx) as r:
+ status = r.getcode()
+ body = r.read()
+ except urllib.error.HTTPError as e:
+ status = e.code
+ body = e.read()
+
+ print("========== 响应报文 ==========")
+ print(f"HTTP/1.1 {status}")
+ print(body.decode("utf-8", errors="replace"))
+ print("==============================")
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+#!/usr/bin/env python3
+"""
+openC - vrtm 控车综合脚本(单入口,--command 选择指令)
+
+与独立脚本相同:POST + JSON Body + ControlCarSign(build_authorization_control_car)。
+
+支持的 --command 与独立脚本对应关系见 ``python openc_car_control_v2_test.py -h`` 末尾 epilog。
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import ssl
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+# (URL 路径最后一段, Body.cmd, 中文说明)
+VRTM_CAR_COMMANDS: dict[str, tuple[str, str, str]] = {
+ "close_air": ("closeAir", "closeAir", "关闭空调"),
+ "close_window": ("closeWindow", "CloseWindow", "关闭车窗"),
+ "flash_light": ("flashLight", "flashLight", "闪灯"),
+ "lock_door": ("lockDoor", "LockDoor", "锁定车门"),
+ "open_air": ("openAir", "openAir", "打开空调"),
+ "remote_search_car": ("remoteSearchCar", "remoteSearchCar", "闪灯鸣笛/远程寻车"),
+ "unlock_door": ("unLockDoor", "UnLockDoor", "解锁车门"),
+ "window_slit": ("windowSlit", "windowSlit", "车窗留缝"),
+}
+
+CAR_CONTROL_PATH_PREFIX = "/openc-apigw/vrtm-agent/api/v2/open/car-control/"
+
+
+def _commands_epilog() -> str:
+ lines = [
+ "支持的 --command 取值(每项:CLI 名 → URL 路径段 / Body.cmd / 说明)",
+ "",
+ ]
+ for key in sorted(VRTM_CAR_COMMANDS):
+ seg, cmd, desc = VRTM_CAR_COMMANDS[key]
+ lines.append(f" {key:<22} {seg} / {cmd} {desc}")
+ lines.extend(
+ [
+ "",
+ "默认 verifySign 的 httpUrl 为单段网关前缀:",
+ f" {CAR_CONTROL_PATH_PREFIX}<路径段>",
+ "若网关要求双前缀 /openc-apigw/openc-apigw/...,请用 --api-path 传入完整路径。",
+ "",
+ "独立脚本对照:",
+ " unlock_door → openc_car_unlockDoor_v2_test.py",
+ " lock_door → openc_car_lockDoor_v2_test.py",
+ " remote_search_car → openc_car_remoteSearchCar_v2_test.py",
+ " flash_light → openc_car_flashLight_v2_test.py",
+ " close_air → openc_car_closeAir_v2_test.py",
+ " window_slit → openc_car_windowSlit_v2_test.py",
+ " open_air → openc_car_openAir_v2_test.py",
+ " close_window → openc_car_closeWindow_v2_test.py",
+ ]
+ )
+ return "\n".join(lines)
+
+
+def _load_sign_module():
+ base = Path(__file__).resolve().parent
+ path = base / "openc_car_getCarListByBrandCode_v3_test.py"
+ if not path.is_file():
+ raise FileNotFoundError(f"找不到签名模块: {path}")
+ spec = importlib.util.spec_from_file_location("_openc_car_control_unified", path)
+ if spec is None or spec.loader is None:
+ raise RuntimeError(f"无法加载: {path}")
+ mod = importlib.util.module_from_spec(spec)
+ sys.modules["_openc_car_control_unified"] = mod
+ spec.loader.exec_module(mod)
+ return mod
+
+
+def main() -> None:
+ mod = _load_sign_module()
+ cmd_choices = sorted(VRTM_CAR_COMMANDS)
+ _cmd_metavar = "{" + "|".join(cmd_choices) + "}"
+
+ class _Fmt(argparse.RawDescriptionHelpFormatter, argparse.ArgumentDefaultsHelpFormatter):
+ pass
+
+ p = argparse.ArgumentParser(
+ description="vrtm 控车综合 POST(ControlCarSign,--command 选择指令)",
+ formatter_class=_Fmt,
+ epilog=_commands_epilog(),
+ )
+ p.add_argument(
+ "--command",
+ required=True,
+ choices=cmd_choices,
+ metavar=_cmd_metavar,
+ help="控车指令;可选值即 usage 中花括号内列表,说明见下方 epilog",
+ )
+ p.add_argument(
+ "--body-cmd",
+ default=None,
+ help="覆盖 JSON Body 中的 cmd(默认由 --command 决定;仅当平台与文档不一致时使用)",
+ )
+ p.add_argument("--access-token", "--accessToken", dest="access_token", default=None)
+ p.add_argument(
+ "--secret-key",
+ "--client-secret",
+ dest="secret_key",
+ default=None,
+ help="verifySign HMAC 密钥(与开放平台 SECRETKEY 一致)",
+ )
+ p.add_argument("--car-id", "--carId", dest="car_id", required=True, help="车辆 ID")
+ p.add_argument(
+ "--map-args-json",
+ default="{}",
+ help='mapArgsJson 字符串;open_air 可传如 {"temperature":20,"airModel":1,"windPower":1}',
+ )
+ p.add_argument("--sender-type", "--senderType", dest="sender_type", default="APP")
+ p.add_argument(
+ "--timestamp",
+ default=None,
+ help="X-VCS-Timestamp;未传则当前毫秒(13 位)",
+ )
+ p.add_argument(
+ "--timestamp-seconds",
+ action="store_true",
+ help="未传 --timestamp 时使用当前秒(10 位)",
+ )
+ p.add_argument("--nonce", default="RANDOM", help="X-VCS-Nonce,4 位;默认 RANDOM")
+ p.add_argument(
+ "--api-path",
+ default=None,
+ help="覆盖 verifySign 与 POST 的完整 httpUrl 路径(默认由 --command 拼出单段前缀)",
+ )
+ p.add_argument(
+ "--secret-base64-decoded",
+ action="store_true",
+ help="HMAC 密钥:对 secret-key 先 Base64 解码",
+ )
+ p.add_argument("--java-log", action="store_true", help="ControlCarSign.java 风格 Log 行")
+ p.add_argument(
+ "--debug",
+ action="store_true",
+ help="打印 body、HashUtils.getSHA256(body)、head、splicing、StringToSign",
+ )
+ p.add_argument("--timeout", type=float, default=30.0)
+ p.add_argument("--insecure", action="store_true")
+
+ p.add_argument("--grant-type", choices=["authorization_code", "refresh_token"], default="refresh_token")
+ p.add_argument("--code", default=None)
+ p.add_argument("--redirect-uri", default=None)
+ p.add_argument("--refresh-token", default=None)
+ p.add_argument("--client-id", default=mod.DEFAULT_CLIENT_ID)
+ p.add_argument("--oauth-client-secret", default=mod.DEFAULT_CLIENT_SECRET)
+
+ args = p.parse_args()
+
+ if not args.secret_key:
+ p.error("必须提供 --secret-key")
+
+ path_segment, default_body_cmd, _desc = VRTM_CAR_COMMANDS[args.command]
+ body_cmd = args.body_cmd if args.body_cmd is not None else default_body_cmd
+ default_path = f"{CAR_CONTROL_PATH_PREFIX}{path_segment}"
+ path_use = (args.api_path or default_path).strip()
+
+ token = args.access_token
+ if not token:
+ token = mod.fetch_user_access_token(
+ timeout=args.timeout,
+ insecure=args.insecure,
+ grant_type=args.grant_type,
+ client_id=args.client_id,
+ client_secret=args.oauth_client_secret,
+ code=args.code,
+ redirect_uri=args.redirect_uri,
+ refresh_token=args.refresh_token,
+ )
+
+ if args.timestamp_seconds:
+ ts = args.timestamp or str(int(time.time()))
+ else:
+ ts = args.timestamp or str(int(time.time() * 1000))
+ nonce = args.nonce
+ if nonce.upper() == "RANDOM":
+ nonce = mod.rand_nonce(4)
+
+ body_obj = {
+ "mapArgsJson": args.map_args_json,
+ "senderType": args.sender_type,
+ "cmd": body_cmd,
+ "carId": args.car_id,
+ }
+ body_wire = json.dumps(body_obj, ensure_ascii=False, separators=(",", ":"))
+
+ authorization, _qw, head_block, string_to_sign, splicing_full = mod.build_authorization_control_car(
+ client_secret=args.secret_key,
+ token=token,
+ timestamp=ts,
+ nonce=nonce,
+ query_params=None,
+ http_url=path_use,
+ hmac_secret_base64_decode=args.secret_base64_decoded,
+ java_style_log=args.java_log,
+ http_method="POST",
+ body_for_sign=body_wire,
+ )
+
+ url = f"https://{mod.SERVER}{path_use}"
+ headers = {
+ "Content-Type": "application/json",
+ mod.TOKEN_HEADER_NAME: token,
+ mod.X_VCS_TOKEN: token,
+ mod.X_VCS_TIMESTAMP: ts,
+ mod.X_VCS_NONCE: nonce,
+ "Authorization": authorization,
+ }
+
+ if args.debug:
+ body_sha_hex = mod.hash_utils_get_sha256_for_control_car(body_wire)
+ print(">>> command / path / body.cmd")
+ print(f" {args.command} {path_use} {body_cmd!r}")
+ print()
+ print(">>> 参与签名的 HTTP Body 原文(UTF-8,须与发包一致)")
+ print(body_wire)
+ print()
+ print(">>> HashUtils.getSHA256(bodymap) 小写 hex")
+ print(body_sha_hex)
+ print()
+ print(">>> headMap2String block")
+ print(head_block, end="")
+ print()
+ print(">>> HashedCanonicalRequest splicing")
+ print(splicing_full)
+ print()
+ print(">>> StringToSign")
+ print(string_to_sign)
+ print()
+
+ print(">>> 请求 URL:" + url)
+ print("========== 请求报文 ==========")
+ print(f"POST {path_use} HTTP/1.1")
+ print(f"Host: {mod.SERVER}")
+ for k, v in headers.items():
+ print(f"{k}: {v}")
+ print()
+ print(body_wire)
+ print("==============================")
+ print()
+
+ ctx = ssl.create_default_context()
+ if args.insecure:
+ ctx.check_hostname = False
+ ctx.verify_mode = ssl.CERT_NONE
+
+ req = urllib.request.Request(
+ url,
+ data=body_wire.encode("utf-8"),
+ headers=headers,
+ method="POST",
+ )
+ try:
+ with urllib.request.urlopen(req, timeout=args.timeout, context=ctx) as r:
+ status = r.getcode()
+ body = r.read()
+ except urllib.error.HTTPError as e:
+ status = e.code
+ body = e.read()
+
+ print("========== 响应报文 ==========")
+ print(f"HTTP/1.1 {status}")
+ print(body.decode("utf-8", errors="replace"))
+ print("==============================")
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+#!/usr/bin/env python3
+"""
+Test GET /openc-apigw/baseMeta/api/v1/car/getCarListByBrandCode — App 侧与截图一致:
+
+ • headerMap:X-VCS-User-Access-Token、X-VCS-Token(同 ACCESS_TOKEN)、X-VCS-Timestamp、X-VCS-Nonce
+ • queryMap:brandCode(默认 CHANGAN)
+ • bodyMap:GET → 等价 null(签名字符串中空 body)
+ • httpMethod:GET;httpUrl:Constans.api_getcarList → 默认与本仓库 PATH 一致
+ • sign = ControlCarSign.verifySign(...) → 写入 headerMap.put(\"Authorization\", sign)
+
+签名实现复用同目录 openc_car_getCarListByBrandCode_v3_test.py 中的 build_authorization_control_car(对齐 ControlCarSign.java)。
+
+示例:
+ python openc_car_getCarListByBrandCode_control_car_test.py --access-token <token> --secret-key <Constans.SECRETKEY>
+ python openc_car_getCarListByBrandCode_control_car_test.py --code <授权码> --secret-key ...
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import ssl
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+def _load_sign_module():
+ """加载同目录下的 v3 测试模块(仅函数定义,不执行其 main)。"""
+ base = Path(__file__).resolve().parent
+ path = base / "openc_car_getCarListByBrandCode_v3_test.py"
+ if not path.is_file():
+ raise FileNotFoundError(f"找不到签名实现文件: {path}")
+ spec = importlib.util.spec_from_file_location("_openc_car_sign_impl", path)
+ if spec is None or spec.loader is None:
+ raise RuntimeError(f"无法加载模块: {path}")
+ mod = importlib.util.module_from_spec(spec)
+ sys.modules["_openc_car_sign_impl"] = mod
+ spec.loader.exec_module(mod)
+ return mod
+
+
+def _print_sign_debug_annotated(
+ *,
+ mod,
+ secret_key: str,
+ http_method: str,
+ http_url: str,
+ query_map: dict,
+ token: str,
+ timestamp: str,
+ nonce: str,
+ head_block: str,
+ splicing_full: str,
+ string_to_sign: str,
+ authorization: str,
+) -> None:
+ # 依据 ControlCarSign.verifySign/HashedCanonicalRequest/head2String 的生成路径加注释
+ body_sha256 = mod.sha256_hex("").lower()
+ hashed_canonical_request = string_to_sign.split("\n")[-1].strip() if string_to_sign else ""
+
+ print()
+ print("========== SIGN DEBUG(注释版,ControlCarSign.java 路径) ==========")
+ print(">>> key(verifySign 入参;ControlCarSign.java:53 secret = key)")
+ print(secret_key)
+ print()
+
+ print(">>> headmap(参与签名的四个头;verifySign 入参 headmap)")
+ print(f"- {mod.TOKEN_HEADER_NAME}: {token}")
+ print(f"- {mod.X_VCS_TOKEN}: {token}")
+ print(f"- {mod.X_VCS_TIMESTAMP}: {timestamp}")
+ print(f"- {mod.X_VCS_NONCE}: {nonce}")
+ print()
+
+ print(">>> headMap2String(sortMapByKey(headmap))(ControlCarSign.java:56 → headMap2String)")
+ print("说明:key 排序后逐行输出 `key小写:value\\n`。")
+ print(head_block, end="")
+ print()
+
+ print(">>> HashUtils.getSHA256(bodymap)(ControlCarSign.java:181)")
+ print("说明:GET 场景 bodymap=null → verifySign 内部 json=\"\" → SHA256(\"\")。")
+ print(body_sha256)
+ print()
+
+ print(">>> HashedCanonicalRequest splicing(ControlCarSign.java:174-185)")
+ if query_map is None:
+ print("说明:querymap==null 分支:method + \"\\n\" + url + \"\\n\\n\" + headmap + \"\\n\" + bodySha")
+ else:
+ print(
+ "说明:querymap!=null 分支:method + \"\\n\" + url + \"\\n\" + getUrlencodeStr(querymap) + \"\\n\" + "
+ "headmap + \"\\n\" + bodySha"
+ )
+ print("说明:headMap2String 末尾带 \"\\n\",再接 \"\\n\" + bodySha 会出现 \"\\n\\n\",bodySha 前会显示为空行(与 Java 一致)。")
+ print("----- splicing(含最后一行 bodySha)-----")
+ print(splicing_full)
+ print("--------------------------------------")
+ print()
+ print("----- splicing(逐行显示;<EMPTY> 表示空行)-----")
+ for i, line in enumerate(splicing_full.splitlines(), start=1):
+ show = line if line != "" else "<EMPTY>"
+ print(f"{i:02d}|{show}")
+ print("------------------------------------------------")
+ print()
+
+ print(">>> HashedCanonicalRequest(ControlCarSign.java:183-185)")
+ print("说明:HashUtils.getSHA256(splicing)(即对上面的 splicing_full 再做一次 SHA256)。")
+ print(hashed_canonical_request)
+ print()
+
+ print(">>> head2String(signature) / StringToSign(ControlCarSign.java:188-193)")
+ print("说明:\"VCS-HMAC-SHA256\" + \"\\n\" + time + \"\\n\" + HashedCanonicalRequest。")
+ print(string_to_sign)
+ print()
+
+ print(">>> Authorization(verifySign 最终返回;ControlCarSign.java:68-70)")
+ print("说明:HashUtils.sha256Hex(secret, StringToSign) → 组装为 `VCS-HMAC-SHA256 Signature=<hex>`。")
+ print(authorization)
+ print("===============================================================")
+ print()
+
+
+def main() -> None:
+ mod = _load_sign_module()
+
+ p = argparse.ArgumentParser(
+ description="getCarListByBrandCode(ControlCarSign.verifySign,对齐 App 截图)",
+ )
+ p.add_argument("--access-token", "--accessToken", dest="access_token", default=None, help="Constans.ACCESS_TOKEN")
+ p.add_argument(
+ "--secret-key",
+ "--client-secret",
+ dest="secret_key",
+ required=False,
+ default=None,
+ help="spUtil Constans.SECRETKEY(verifySign 最后一个参数)",
+ )
+ p.add_argument("--brand-code", "--brandCode", dest="brand_code", default="CHANGAN")
+ p.add_argument("--nonce", default="WYYL", help="默认与截图一致 WYYL;可传 RANDOM")
+ p.add_argument("--timestamp", default=None, help="与 header 中 X-VCS-Timestamp 一致(秒);默认当前时间")
+ p.add_argument(
+ "--api-path",
+ default=None,
+ help="Constans.api_getcarList,传入 verifySign 的 httpUrl(默认脚本内 PATH)",
+ )
+ p.add_argument("--timeout", type=float, default=30.0)
+ p.add_argument("--insecure", action="store_true")
+ p.add_argument(
+ "--secret-base64-decoded",
+ action="store_true",
+ help="HMAC 密钥:对 secret-key 做 Base64 解码(对齐 encerptHMAC/decryotBase64)",
+ )
+ p.add_argument(
+ "--java-log",
+ action="store_true",
+ help="打印与 ControlCarSign.java Log 同类调试行(Encrypt/headMap2String/…)",
+ )
+ p.add_argument(
+ "--sign-debug",
+ action="store_true",
+ help="额外打印加密过程关键中间串(headMap2String / HashedCanonicalRequest 拼接串 / head2String / StringToSign)",
+ )
+
+ # 无 access-token 时用 oauth(与同仓库另一脚本一致)
+ p.add_argument("--grant-type", choices=["authorization_code", "refresh_token"], default="refresh_token")
+ p.add_argument("--code", default=None)
+ p.add_argument("--redirect-uri", default=None)
+ p.add_argument("--refresh-token", default=None)
+ p.add_argument("--client-id", default=mod.DEFAULT_CLIENT_ID)
+ p.add_argument("--oauth-client-secret", default=mod.DEFAULT_CLIENT_SECRET)
+
+ args = p.parse_args()
+
+ if not args.secret_key:
+ p.error("必须提供 --secret-key(对应 App 内 Constans.SECRETKEY)")
+
+ token = args.access_token
+ if not token:
+ token = mod.fetch_user_access_token(
+ timeout=args.timeout,
+ insecure=args.insecure,
+ grant_type=args.grant_type,
+ client_id=args.client_id,
+ client_secret=args.oauth_client_secret,
+ code=args.code,
+ redirect_uri=args.redirect_uri,
+ refresh_token=args.refresh_token,
+ )
+
+ ts = args.timestamp or str(int(time.time()))
+ nonce = args.nonce
+ if nonce.upper() == "RANDOM":
+ nonce = mod.rand_nonce(4)
+
+ query_map = {"brandCode": args.brand_code}
+ http_url = (args.api_path or mod.PATH).strip()
+
+ # Log.i(TAG, "map:" + queryMap) — 与截图类似
+ print(f"I/App: map:{query_map}")
+
+ authorization, query_wire, head_block, string_to_sign, splicing_full = mod.build_authorization_control_car(
+ client_secret=args.secret_key,
+ token=token,
+ timestamp=ts,
+ nonce=nonce,
+ query_params=query_map,
+ http_url=http_url,
+ hmac_secret_base64_decode=args.secret_base64_decoded,
+ java_style_log=args.java_log,
+ )
+
+ print(f"I/App: sign:{authorization}")
+
+ if args.sign_debug:
+ _print_sign_debug_annotated(
+ mod=mod,
+ secret_key=args.secret_key,
+ http_method="GET",
+ http_url=http_url,
+ query_map=query_map,
+ token=token,
+ timestamp=ts,
+ nonce=nonce,
+ head_block=head_block,
+ splicing_full=splicing_full,
+ string_to_sign=string_to_sign,
+ authorization=authorization,
+ )
+
+ path = mod.PATH
+ url = f"https://{mod.SERVER}{path}" + (("?" + query_wire) if query_wire else "")
+ headers = {
+ "Accept": "application/json, text/plain, */*",
+ mod.TOKEN_HEADER_NAME: token,
+ mod.X_VCS_TOKEN: token,
+ mod.X_VCS_TIMESTAMP: ts,
+ mod.X_VCS_NONCE: nonce,
+ "Authorization": authorization,
+ }
+
+ print("========== GET ==========")
+ print(f"{url}")
+ for k, v in headers.items():
+ print(f"{k}: {v}")
+ print("=========================")
+ print()
+
+ ctx = ssl.create_default_context()
+ if args.insecure:
+ ctx.check_hostname = False
+ ctx.verify_mode = ssl.CERT_NONE
+
+ req = urllib.request.Request(url, headers=headers, method="GET")
+ try:
+ with urllib.request.urlopen(req, timeout=args.timeout, context=ctx) as r:
+ status = r.getcode()
+ body = r.read()
+ except urllib.error.HTTPError as e:
+ status = e.code
+ body = e.read()
+
+ print(f"HTTP {status}")
+ print(body.decode("utf-8", errors="replace"))
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+#!/usr/bin/env python3
+"""
+openC - bdc 通过 carId 获取车辆信息(ControlCarSign)
+
+接口(文档 bdc-通过carId获取车辆信息):
+ GET https://open.iov.changan.com.cn/openc-apigw/openc-apigw/bdc/api/v1/car/get-carInfo-use-carId?carId=...
+
+Header:X-VCS-User-Access-Token、X-VCS-Token、X-VCS-Timestamp、X-VCS-Nonce、Authorization
+无 Body;Query 必填 carId。
+
+签名:query_params 参与 HashedCanonicalRequest(与同目录 GET 示例一致)。
+
+默认 httpUrl 为文档双段网关前缀;若环境为单段,请传:
+ --api-path /openc-apigw/bdc/api/v1/car/get-carInfo-use-carId
+
+示例:
+ python openc_car_get_car_info_use_carId_bdc_v1_test.py --access-token <token> --secret-key <KEY> --car-id <车辆ID>
+ python openc_car_get_car_info_use_carId_bdc_v1_test.py ... --debug
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import ssl
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+PATH = "/openc-apigw/bdc/api/v1/car/get-carInfo-use-carId"
+
+
+def _load_sign_module():
+ base = Path(__file__).resolve().parent
+ path = base / "openc_car_getCarListByBrandCode_v3_test.py"
+ if not path.is_file():
+ raise FileNotFoundError(f"找不到签名模块: {path}")
+ spec = importlib.util.spec_from_file_location("_openc_bdc_carinfo_sign", path)
+ if spec is None or spec.loader is None:
+ raise RuntimeError(f"无法加载: {path}")
+ mod = importlib.util.module_from_spec(spec)
+ sys.modules["_openc_bdc_carinfo_sign"] = mod
+ spec.loader.exec_module(mod)
+ return mod
+
+
+def main() -> None:
+ mod = _load_sign_module()
+
+ p = argparse.ArgumentParser(description="bdc get-carInfo-use-carId GET(ControlCarSign)")
+ p.add_argument("--access-token", "--accessToken", dest="access_token", default=None)
+ p.add_argument(
+ "--secret-key",
+ "--client-secret",
+ dest="secret_key",
+ default=None,
+ help="verifySign HMAC 密钥",
+ )
+ p.add_argument("--car-id", "--carId", dest="car_id", required=True, help="Query 参数 carId(车辆 ID)")
+ p.add_argument(
+ "--timestamp",
+ default=None,
+ help="X-VCS-Timestamp;未传则当前毫秒",
+ )
+ p.add_argument(
+ "--timestamp-seconds",
+ action="store_true",
+ help="未传 --timestamp 时使用当前秒",
+ )
+ p.add_argument("--nonce", default="RANDOM", help="4 位 X-VCS-Nonce;默认 RANDOM")
+ p.add_argument(
+ "--api-path",
+ default=None,
+ help="verifySign 与 GET 的 httpUrl 路径(默认双前缀 PATH)",
+ )
+ p.add_argument("--secret-base64-decoded", action="store_true")
+ p.add_argument("--java-log", action="store_true")
+ p.add_argument("--debug", action="store_true")
+ p.add_argument("--timeout", type=float, default=30.0)
+ p.add_argument("--insecure", action="store_true")
+
+ p.add_argument("--grant-type", choices=["authorization_code", "refresh_token"], default="refresh_token")
+ p.add_argument("--code", default=None)
+ p.add_argument("--redirect-uri", default=None)
+ p.add_argument("--refresh-token", default=None)
+ p.add_argument("--client-id", default=mod.DEFAULT_CLIENT_ID)
+ p.add_argument("--oauth-client-secret", default=mod.DEFAULT_CLIENT_SECRET)
+
+ args = p.parse_args()
+
+ if not args.secret_key:
+ p.error("必须提供 --secret-key")
+
+ token = args.access_token
+ if not token:
+ token = mod.fetch_user_access_token(
+ timeout=args.timeout,
+ insecure=args.insecure,
+ grant_type=args.grant_type,
+ client_id=args.client_id,
+ client_secret=args.oauth_client_secret,
+ code=args.code,
+ redirect_uri=args.redirect_uri,
+ refresh_token=args.refresh_token,
+ )
+
+ if args.timestamp_seconds:
+ ts = args.timestamp or str(int(time.time()))
+ else:
+ ts = args.timestamp or str(int(time.time() * 1000))
+ nonce = args.nonce
+ if nonce.upper() == "RANDOM":
+ nonce = mod.rand_nonce(4)
+
+ query_map = {"carId": args.car_id}
+ path_use = (args.api_path or PATH).strip()
+
+ authorization, query_wire, head_block, string_to_sign, splicing_full = mod.build_authorization_control_car(
+ client_secret=args.secret_key,
+ token=token,
+ timestamp=ts,
+ nonce=nonce,
+ query_params=query_map,
+ http_url=path_use,
+ hmac_secret_base64_decode=args.secret_base64_decoded,
+ java_style_log=args.java_log,
+ http_method="GET",
+ body_for_sign="",
+ )
+
+ url = f"https://{mod.SERVER}{path_use}"
+ if query_wire:
+ url = url + "?" + query_wire
+
+ headers = {
+ "Accept": "application/json, text/plain, */*",
+ mod.TOKEN_HEADER_NAME: token,
+ mod.X_VCS_TOKEN: token,
+ mod.X_VCS_TIMESTAMP: ts,
+ mod.X_VCS_NONCE: nonce,
+ "Authorization": authorization,
+ }
+
+ if args.debug:
+ print(">>> GET", path_use)
+ print(">>> query_map", query_map)
+ print(">>> query_wire(与 URL 查询串一致)")
+ print(query_wire)
+ print()
+ print(">>> headMap2String")
+ print(head_block, end="")
+ print()
+ print(">>> HashedCanonicalRequest splicing(含 query 与 head;body 为空串的 SHA256 摘要行)")
+ print(splicing_full)
+ print()
+ print(">>> StringToSign")
+ print(string_to_sign)
+ print()
+
+ print(">>> 请求 URL:" + url)
+ print("========== 请求报文 ==========")
+ print(f"GET {path_use} HTTP/1.1")
+ print(f"Host: {mod.SERVER}")
+ for k, v in headers.items():
+ print(f"{k}: {v}")
+ print()
+ print("==============================")
+ print()
+
+ ctx = ssl.create_default_context()
+ if args.insecure:
+ ctx.check_hostname = False
+ ctx.verify_mode = ssl.CERT_NONE
+
+ req = urllib.request.Request(url, headers=headers, method="GET")
+ try:
+ with urllib.request.urlopen(req, timeout=args.timeout, context=ctx) as r:
+ status = r.getcode()
+ body = r.read()
+ except urllib.error.HTTPError as e:
+ status = e.code
+ body = e.read()
+
+ print("========== 响应报文 ==========")
+ print(f"HTTP/1.1 {status}")
+ print(body.decode("utf-8", errors="replace"))
+ print("==============================")
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+#!/usr/bin/env python3
+"""
+openC - vrtm 解锁车门(ControlCarSign / 与 openc_car_getCarListByBrandCode_control_car_test 相同签名方式)
+
+接口:
+ POST https://open.iov.changan.com.cn/openc-apigw/openc-apigw/vrtm-agent/api/v2/open/car-control/unLockDoor
+
+Header(与 App 一致,签名用 build_authorization_control_car -> verifySign 四元头 + Authorization):
+ X-VCS-User-Access-Token、X-VCS-Token(同 token)、X-VCS-Timestamp、X-VCS-Nonce
+ Content-Type: application/json
+
+Body JSON:mapArgsJson、senderType、cmd=UnLockDoor、carId
+
+签名:同目录 openc_car_getCarListByBrandCode_v3_test.build_authorization_control_car(POST + JSON body 参与 HashedCanonicalRequest)。
+
+示例:
+ python openc_car_unlockDoor_v2_test.py --access-token <token> --secret-key <SECRETKEY> --car-id <车辆ID>
+ python openc_car_unlockDoor_v2_test.py --access-token <token> --secret-key <key> --car-id <id> --debug
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import ssl
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+PATH = "/openc-apigw/vrtm-agent/api/v2/open/car-control/unLockDoor"
+
+
+def _load_sign_module():
+ base = Path(__file__).resolve().parent
+ path = base / "openc_car_getCarListByBrandCode_v3_test.py"
+ if not path.is_file():
+ raise FileNotFoundError(f"找不到签名模块: {path}")
+ spec = importlib.util.spec_from_file_location("_openc_ctrl_sign", path)
+ if spec is None or spec.loader is None:
+ raise RuntimeError(f"无法加载: {path}")
+ mod = importlib.util.module_from_spec(spec)
+ sys.modules["_openc_ctrl_sign"] = mod
+ spec.loader.exec_module(mod)
+ return mod
+
+
+def main() -> None:
+ mod = _load_sign_module()
+
+ p = argparse.ArgumentParser(description="unLockDoor POST(ControlCarSign,对齐 control_car_test)")
+ p.add_argument("--access-token", "--accessToken", dest="access_token", default=None)
+ p.add_argument(
+ "--secret-key",
+ "--client-secret",
+ dest="secret_key",
+ default=None,
+ help="Constans.SECRETKEY / verifySign 的 key",
+ )
+ p.add_argument("--car-id", "--carId", dest="car_id", required=True, help="车辆 ID")
+ p.add_argument(
+ "--map-args-json",
+ default="{}",
+ help='mapArgsJson 字符串,如 {} 或带诊断的 JSON 串',
+ )
+ p.add_argument("--sender-type", "--senderType", dest="sender_type", default="APP")
+ p.add_argument(
+ "--timestamp",
+ default=None,
+ help="X-VCS-Timestamp;未传则当前毫秒(13 位)。也可手动传入任意字符串时间戳",
+ )
+ p.add_argument(
+ "--timestamp-seconds",
+ action="store_true",
+ help="未传 --timestamp 时使用当前秒(10 位),与部分旧脚本一致",
+ )
+ p.add_argument("--nonce", default="RANDOM", help="4 位;默认 RANDOM")
+ p.add_argument(
+ "--api-path",
+ default=None,
+ help="verifySign 的 httpUrl(默认本脚本 PATH)",
+ )
+ p.add_argument(
+ "--secret-base64-decoded",
+ action="store_true",
+ help="HMAC 密钥:对 secret-key Base64 解码(对齐 encerptHMAC)",
+ )
+ p.add_argument("--java-log", action="store_true", help="ControlCarSign.java 风格 Log 行")
+ p.add_argument(
+ "--debug",
+ action="store_true",
+ help="打印 body 原文、HashUtils.getSHA256(body)、head 块、完整 splicing、StringToSign",
+ )
+ p.add_argument("--timeout", type=float, default=30.0)
+ p.add_argument("--insecure", action="store_true")
+
+ p.add_argument("--grant-type", choices=["authorization_code", "refresh_token"], default="refresh_token")
+ p.add_argument("--code", default=None)
+ p.add_argument("--redirect-uri", default=None)
+ p.add_argument("--refresh-token", default=None)
+ p.add_argument("--client-id", default=mod.DEFAULT_CLIENT_ID)
+ p.add_argument("--oauth-client-secret", default=mod.DEFAULT_CLIENT_SECRET)
+
+ args = p.parse_args()
+
+ if not args.secret_key:
+ p.error("必须提供 --secret-key(与 control_car_test 一致)")
+
+ token = args.access_token
+ if not token:
+ token = mod.fetch_user_access_token(
+ timeout=args.timeout,
+ insecure=args.insecure,
+ grant_type=args.grant_type,
+ client_id=args.client_id,
+ client_secret=args.oauth_client_secret,
+ code=args.code,
+ redirect_uri=args.redirect_uri,
+ refresh_token=args.refresh_token,
+ )
+
+ if args.timestamp_seconds:
+ ts = args.timestamp or str(int(time.time()))
+ else:
+ ts = args.timestamp or str(int(time.time() * 1000))
+ nonce = args.nonce
+ if nonce.upper() == "RANDOM":
+ nonce = "WYYL" # mod.rand_nonce(4)
+
+ body_obj = {
+ "mapArgsJson": args.map_args_json,
+ "senderType": args.sender_type,
+ "cmd": "UnLockDoor",
+ "carId": args.car_id,
+ }
+ body_wire = json.dumps(body_obj, ensure_ascii=False, separators=(",", ":"))
+
+ path_use = (args.api_path or PATH).strip()
+
+ authorization, _query_wire, head_block, string_to_sign, splicing_full = mod.build_authorization_control_car(
+ client_secret=args.secret_key,
+ token=token,
+ timestamp=ts,
+ nonce=nonce,
+ query_params=None,
+ http_url=path_use,
+ hmac_secret_base64_decode=args.secret_base64_decoded,
+ java_style_log=args.java_log,
+ http_method="POST",
+ body_for_sign=body_wire,
+ )
+
+ url = f"https://{mod.SERVER}{path_use}"
+ headers = {
+ "Content-Type": "application/json",
+ mod.TOKEN_HEADER_NAME: token,
+ mod.X_VCS_TOKEN: token,
+ mod.X_VCS_TIMESTAMP: ts,
+ mod.X_VCS_NONCE: nonce,
+ "Authorization": authorization,
+ }
+
+ if args.debug:
+ body_sha_hex = mod.hash_utils_get_sha256_for_control_car(body_wire)
+ print(">>> 参与签名的 HTTP Body 原文(须与发包头字节一致;UTF-8)")
+ print(body_wire)
+ print()
+ print(">>> HashUtils.getSHA256(bodymap)(ControlCarSign.HashedCanonicalRequest:181,body 的 SHA-256 小写 hex)")
+ print(body_sha_hex)
+ print("说明:该摘要作为 splicing 最后一行,再对整段 splicing 做第二次 SHA256 得到 HashedCanonicalRequest 内层哈希。")
+ print()
+ print(">>> headMap2String block")
+ print(head_block, end="")
+ print()
+ print(">>> HashedCanonicalRequest 完整 splicing(method\\nurl\\n\\n 或带 query、再 head、再\\n、再上一行 body 摘要)")
+ print(splicing_full)
+ print()
+ print(">>> StringToSign(head2String)")
+ print(string_to_sign)
+ print()
+ print(">>> 请求 URL:" + url)
+ print("========== 请求报文 ==========")
+ print(f"POST {path_use} HTTP/1.1")
+ print(f"Host: {mod.SERVER}")
+ for k, v in headers.items():
+ print(f"{k}: {v}")
+ print()
+ print(body_wire)
+ print("==============================")
+ print()
+
+ ctx = ssl.create_default_context()
+ if args.insecure:
+ ctx.check_hostname = False
+ ctx.verify_mode = ssl.CERT_NONE
+
+ req = urllib.request.Request(
+ url,
+ data=body_wire.encode("utf-8"),
+ headers=headers,
+ method="POST",
+ )
+ try:
+ with urllib.request.urlopen(req, timeout=args.timeout, context=ctx) as r:
+ status = r.getcode()
+ body = r.read()
+ except urllib.error.HTTPError as e:
+ status = e.code
+ body = e.read()
+
+ print("========== 响应报文 ==========")
+ print(f"HTTP/1.1 {status}")
+ print(body.decode("utf-8", errors="replace"))
+ print("==============================")
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+#!/usr/bin/env python3
+"""
+openC - vrtm 解锁车门(ControlCarSign / 与 openc_car_getCarListByBrandCode_control_car_test 相同签名方式)
+
+接口:
+ POST https://open.iov.changan.com.cn/openc-apigw/openc-apigw/vrtm-agent/api/v2/open/car-control/unLockDoor
+
+Header(与 App 一致,签名用 build_authorization_control_car -> verifySign 四元头 + Authorization):
+ X-VCS-User-Access-Token、X-VCS-Token(同 token)、X-VCS-Timestamp、X-VCS-Nonce
+ Content-Type: application/json
+
+Body JSON:mapArgsJson、senderType、cmd=UnLockDoor、carId
+
+签名:同目录 openc_car_getCarListByBrandCode_v3_test.build_authorization_control_car(POST + JSON body 参与 HashedCanonicalRequest)。
+
+示例:
+ python openc_car_unlockDoor_v2_test.py --access-token <token> --secret-key <SECRETKEY> --car-id <车辆ID>
+ python openc_car_unlockDoor_v2_test.py --access-token <token> --secret-key <key> --car-id <id> --debug
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import ssl
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+PATH = "/openc-apigw/vrtm-agent/api/v2/open/car-control/unLockDoor"
+
+
+def _load_sign_module():
+ base = Path(__file__).resolve().parent
+ path = base / "openc_car_getCarListByBrandCode_v3_test.py"
+ if not path.is_file():
+ raise FileNotFoundError(f"找不到签名模块: {path}")
+ spec = importlib.util.spec_from_file_location("_openc_ctrl_sign", path)
+ if spec is None or spec.loader is None:
+ raise RuntimeError(f"无法加载: {path}")
+ mod = importlib.util.module_from_spec(spec)
+ sys.modules["_openc_ctrl_sign"] = mod
+ spec.loader.exec_module(mod)
+ return mod
+
+
+def main() -> None:
+ mod = _load_sign_module()
+
+ p = argparse.ArgumentParser(description="unLockDoor POST(ControlCarSign,对齐 control_car_test)")
+ p.add_argument("--access-token", "--accessToken", dest="access_token", default=None)
+ p.add_argument(
+ "--secret-key",
+ "--client-secret",
+ dest="secret_key",
+ default=None,
+ help="Constans.SECRETKEY / verifySign 的 key",
+ )
+ p.add_argument("--car-id", "--carId", dest="car_id", required=True, help="车辆 ID")
+ p.add_argument(
+ "--map-args-json",
+ default="{}",
+ help='mapArgsJson 字符串,如 {} 或带诊断的 JSON 串',
+ )
+ p.add_argument("--sender-type", "--senderType", dest="sender_type", default="APP")
+ p.add_argument(
+ "--timestamp",
+ default=None,
+ help="X-VCS-Timestamp;未传则当前毫秒(13 位)。也可手动传入任意字符串时间戳",
+ )
+ p.add_argument(
+ "--timestamp-seconds",
+ action="store_true",
+ help="未传 --timestamp 时使用当前秒(10 位),与部分旧脚本一致",
+ )
+ p.add_argument("--nonce", default="RANDOM", help="4 位;默认 RANDOM")
+ p.add_argument(
+ "--api-path",
+ default=None,
+ help="verifySign 的 httpUrl(默认本脚本 PATH)",
+ )
+ p.add_argument(
+ "--secret-base64-decoded",
+ action="store_true",
+ help="HMAC 密钥:对 secret-key Base64 解码(对齐 encerptHMAC)",
+ )
+ p.add_argument("--java-log", action="store_true", help="ControlCarSign.java 风格 Log 行")
+ p.add_argument(
+ "--debug",
+ action="store_true",
+ help="打印 body 原文、HashUtils.getSHA256(body)、head 块、完整 splicing、StringToSign",
+ )
+ p.add_argument("--timeout", type=float, default=30.0)
+ p.add_argument("--insecure", action="store_true")
+
+ p.add_argument("--grant-type", choices=["authorization_code", "refresh_token"], default="refresh_token")
+ p.add_argument("--code", default=None)
+ p.add_argument("--redirect-uri", default=None)
+ p.add_argument("--refresh-token", default=None)
+ p.add_argument("--client-id", default=mod.DEFAULT_CLIENT_ID)
+ p.add_argument("--oauth-client-secret", default=mod.DEFAULT_CLIENT_SECRET)
+
+ args = p.parse_args()
+
+ if not args.secret_key:
+ p.error("必须提供 --secret-key(与 control_car_test 一致)")
+
+ token = args.access_token
+ if not token:
+ token = mod.fetch_user_access_token(
+ timeout=args.timeout,
+ insecure=args.insecure,
+ grant_type=args.grant_type,
+ client_id=args.client_id,
+ client_secret=args.oauth_client_secret,
+ code=args.code,
+ redirect_uri=args.redirect_uri,
+ refresh_token=args.refresh_token,
+ )
+
+ if args.timestamp_seconds:
+ ts = args.timestamp or str(int(time.time()))
+ else:
+ ts = args.timestamp or str(int(time.time() * 1000))
+ nonce = args.nonce
+ if nonce.upper() == "RANDOM":
+ nonce = "WYYL" # mod.rand_nonce(4)
+
+ body_obj = {
+ "mapArgsJson": args.map_args_json,
+ "senderType": args.sender_type,
+ "cmd": "UnLockDoor",
+ "carId": args.car_id,
+ }
+ body_wire = json.dumps(body_obj, ensure_ascii=False, separators=(",", ":"))
+
+ path_use = (args.api_path or PATH).strip()
+
+ authorization, _query_wire, head_block, string_to_sign, splicing_full = mod.build_authorization_control_car(
+ client_secret=args.secret_key,
+ token=token,
+ timestamp=ts,
+ nonce=nonce,
+ query_params=None,
+ http_url=path_use,
+ hmac_secret_base64_decode=args.secret_base64_decoded,
+ java_style_log=args.java_log,
+ http_method="POST",
+ body_for_sign=body_wire,
+ )
+
+ url = f"https://{mod.SERVER}{path_use}"
+ headers = {
+ "Content-Type": "application/json",
+ mod.TOKEN_HEADER_NAME: token,
+ mod.X_VCS_TOKEN: token,
+ mod.X_VCS_TIMESTAMP: ts,
+ mod.X_VCS_NONCE: nonce,
+ "Authorization": authorization,
+ }
+
+ if args.debug:
+ body_sha_hex = mod.hash_utils_get_sha256_for_control_car(body_wire)
+ print(">>> 参与签名的 HTTP Body 原文(须与发包头字节一致;UTF-8)")
+ print(body_wire)
+ print()
+ print(">>> HashUtils.getSHA256(bodymap)(ControlCarSign.HashedCanonicalRequest:181,body 的 SHA-256 小写 hex)")
+ print(body_sha_hex)
+ print("说明:该摘要作为 splicing 最后一行,再对整段 splicing 做第二次 SHA256 得到 HashedCanonicalRequest 内层哈希。")
+ print()
+ print(">>> headMap2String block")
+ print(head_block, end="")
+ print()
+ print(">>> HashedCanonicalRequest 完整 splicing(method\\nurl\\n\\n 或带 query、再 head、再\\n、再上一行 body 摘要)")
+ print(splicing_full)
+ print()
+ print(">>> StringToSign(head2String)")
+ print(string_to_sign)
+ print()
+ print(">>> 请求 URL:" + url)
+ print("========== 请求报文 ==========")
+ print(f"POST {path_use} HTTP/1.1")
+ print(f"Host: {mod.SERVER}")
+ for k, v in headers.items():
+ print(f"{k}: {v}")
+ print()
+ print(body_wire)
+ print("==============================")
+ print()
+
+ ctx = ssl.create_default_context()
+ if args.insecure:
+ ctx.check_hostname = False
+ ctx.verify_mode = ssl.CERT_NONE
+
+ req = urllib.request.Request(
+ url,
+ data=body_wire.encode("utf-8"),
+ headers=headers,
+ method="POST",
+ )
+ try:
+ with urllib.request.urlopen(req, timeout=args.timeout, context=ctx) as r:
+ status = r.getcode()
+ body = r.read()
+ except urllib.error.HTTPError as e:
+ status = e.code
+ body = e.read()
+
+ print("========== 响应报文 ==========")
+ print(f"HTTP/1.1 {status}")
+ print(body.decode("utf-8", errors="replace"))
+ print("==============================")
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+#!/usr/bin/env python3
+"""
+openC - dg 检测结果(带检测)(ControlCarSign)
+
+接口(文档 dg-检测结果(带检测)):
+ GET https://open.iov.changan.com.cn/openc-apigw/openc-apigw/dg/api/v1/check/result?carId=...
+
+Header:X-VCS-User-Access-Token、X-VCS-Token、X-VCS-Timestamp、X-VCS-Nonce、Authorization;
+文档另列 Content-Type: application/x-www-form-urlencoded(GET 无 Body,脚本仍带上该头以贴合文档)。
+
+Query:carId(必填)。无 Body。
+
+签名:query_params 参与 HashedCanonicalRequest;GET、body_for_sign 空串。
+
+默认 httpUrl 为文档双段网关前缀;单段环境请传:
+ --api-path /openc-apigw/dg/api/v1/check/result
+
+示例:
+ python openc_dg_check_result_v1_test.py --access-token <token> --secret-key <KEY> --car-id <车辆ID>
+ python openc_dg_check_result_v1_test.py ... --debug
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import ssl
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+PATH = "/openc-apigw/dg/api/v1/check/result"
+
+
+def _load_sign_module():
+ base = Path(__file__).resolve().parent
+ path = base / "openc_car_getCarListByBrandCode_v3_test.py"
+ if not path.is_file():
+ raise FileNotFoundError(f"找不到签名模块: {path}")
+ spec = importlib.util.spec_from_file_location("_openc_dg_check_result_sign", path)
+ if spec is None or spec.loader is None:
+ raise RuntimeError(f"无法加载: {path}")
+ mod = importlib.util.module_from_spec(spec)
+ sys.modules["_openc_dg_check_result_sign"] = mod
+ spec.loader.exec_module(mod)
+ return mod
+
+
+def main() -> None:
+ mod = _load_sign_module()
+
+ p = argparse.ArgumentParser(description="dg check/result GET(ControlCarSign)")
+ p.add_argument("--access-token", "--accessToken", dest="access_token", default=None)
+ p.add_argument(
+ "--secret-key",
+ "--client-secret",
+ dest="secret_key",
+ default=None,
+ help="verifySign HMAC 密钥",
+ )
+ p.add_argument("--car-id", "--carId", dest="car_id", required=True, help="Query 参数 carId(车辆 ID)")
+ p.add_argument(
+ "--timestamp",
+ default=None,
+ help="X-VCS-Timestamp;未传则当前毫秒",
+ )
+ p.add_argument(
+ "--timestamp-seconds",
+ action="store_true",
+ help="未传 --timestamp 时使用当前秒",
+ )
+ p.add_argument("--nonce", default="RANDOM", help="4 位 X-VCS-Nonce;默认 RANDOM")
+ p.add_argument(
+ "--api-path",
+ default=None,
+ help="verifySign 与 GET 的 httpUrl(默认双前缀 PATH)",
+ )
+ p.add_argument("--secret-base64-decoded", action="store_true")
+ p.add_argument("--java-log", action="store_true")
+ p.add_argument("--debug", action="store_true")
+ p.add_argument("--timeout", type=float, default=30.0)
+ p.add_argument("--insecure", action="store_true")
+
+ p.add_argument("--grant-type", choices=["authorization_code", "refresh_token"], default="refresh_token")
+ p.add_argument("--code", default=None)
+ p.add_argument("--redirect-uri", default=None)
+ p.add_argument("--refresh-token", default=None)
+ p.add_argument("--client-id", default=mod.DEFAULT_CLIENT_ID)
+ p.add_argument("--oauth-client-secret", default=mod.DEFAULT_CLIENT_SECRET)
+
+ args = p.parse_args()
+
+ if not args.secret_key:
+ p.error("必须提供 --secret-key")
+
+ token = args.access_token
+ if not token:
+ token = mod.fetch_user_access_token(
+ timeout=args.timeout,
+ insecure=args.insecure,
+ grant_type=args.grant_type,
+ client_id=args.client_id,
+ client_secret=args.oauth_client_secret,
+ code=args.code,
+ redirect_uri=args.redirect_uri,
+ refresh_token=args.refresh_token,
+ )
+
+ if args.timestamp_seconds:
+ ts = args.timestamp or str(int(time.time()))
+ else:
+ ts = args.timestamp or str(int(time.time() * 1000))
+ nonce = args.nonce
+ if nonce.upper() == "RANDOM":
+ nonce = mod.rand_nonce(4)
+
+ query_map = {"carId": args.car_id}
+ path_use = (args.api_path or PATH).strip()
+
+ authorization, query_wire, head_block, string_to_sign, splicing_full = mod.build_authorization_control_car(
+ client_secret=args.secret_key,
+ token=token,
+ timestamp=ts,
+ nonce=nonce,
+ query_params=query_map,
+ http_url=path_use,
+ hmac_secret_base64_decode=args.secret_base64_decoded,
+ java_style_log=args.java_log,
+ http_method="GET",
+ body_for_sign="",
+ )
+
+ url = f"https://{mod.SERVER}{path_use}"
+ if query_wire:
+ url = url + "?" + query_wire
+
+ headers = {
+ "Accept": "application/json, text/plain, */*",
+ "Content-Type": "application/x-www-form-urlencoded",
+ mod.TOKEN_HEADER_NAME: token,
+ mod.X_VCS_TOKEN: token,
+ mod.X_VCS_TIMESTAMP: ts,
+ mod.X_VCS_NONCE: nonce,
+ "Authorization": authorization,
+ }
+
+ if args.debug:
+ print(">>> GET", path_use)
+ print(">>> query_map", query_map)
+ print(">>> query_wire(与 URL 查询串一致)")
+ print(query_wire)
+ print()
+ print(">>> headMap2String")
+ print(head_block, end="")
+ print()
+ print(">>> HashedCanonicalRequest splicing(含 query 与 head;body 为空串的 SHA256 摘要行)")
+ print(splicing_full)
+ print()
+ print(">>> StringToSign")
+ print(string_to_sign)
+ print()
+
+ print(">>> 请求 URL:" + url)
+ print("========== 请求报文 ==========")
+ print(f"GET {path_use} HTTP/1.1")
+ print(f"Host: {mod.SERVER}")
+ for k, v in headers.items():
+ print(f"{k}: {v}")
+ print()
+ print("==============================")
+ print()
+
+ ctx = ssl.create_default_context()
+ if args.insecure:
+ ctx.check_hostname = False
+ ctx.verify_mode = ssl.CERT_NONE
+
+ req = urllib.request.Request(url, headers=headers, method="GET")
+ try:
+ with urllib.request.urlopen(req, timeout=args.timeout, context=ctx) as r:
+ status = r.getcode()
+ body = r.read()
+ except urllib.error.HTTPError as e:
+ status = e.code
+ body = e.read()
+
+ print("========== 响应报文 ==========")
+ print(f"HTTP/1.1 {status}")
+ print(body.decode("utf-8", errors="replace"))
+ print("==============================")
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+#!/usr/bin/env python3
+"""
+download-owner-key 响应 data 中 cardInfoEnc / dkeyEnc 解密(与设备端 changan_http_sign.c 一致)。
+
+密文编码规则(与开放平台部分返回一致):
+ - 若字符串仅含 [0-9A-Fa-f] 且长度为偶数,且字节长度(len/2)为 RSA 模长(2048 位 → 256)的整数倍,
+ 则按十六进制解码为二进制密文;
+ - 否则按标准 Base64 解码。
+
+RSA:PKCS#1 v1.5 私钥解密;多块密文为各 RSA 块密文顺序拼接(Java Cipher RSA/ECB/PKCS1Padding)。
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import padding
+
+
+def _is_hex_even(s: str) -> bool:
+ t = s.strip()
+ if len(t) < 2 or len(t) % 2 != 0:
+ return False
+ try:
+ bytes.fromhex(t)
+ except ValueError:
+ return False
+ return True
+
+
+def decode_cipher_wire(s: str, rsa_bytes: int) -> tuple[bytes, str]:
+ """
+ @return (cipher_bin, "hex"|"base64")
+ """
+ t = s.strip()
+ if _is_hex_even(t) and (len(t) // 2) % rsa_bytes == 0 and len(t) // 2 > 0:
+ return bytes.fromhex(t), "hex"
+ return base64.b64decode(t, validate=False), "base64"
+
+
+def rsa_pkcs1_decrypt_blocks(private_pem: bytes, cipher_bin: bytes) -> bytes:
+ key = serialization.load_pem_private_key(private_pem, password=None, backend=default_backend())
+ rsa_bytes = (key.key_size + 7) // 8
+ if rsa_bytes == 0 or len(cipher_bin) % rsa_bytes != 0:
+ raise ValueError(f"密文长度 {len(cipher_bin)} 不是 RSA 块长 {rsa_bytes} 的整数倍")
+ out_parts: list[bytes] = []
+ for off in range(0, len(cipher_bin), rsa_bytes):
+ block = cipher_bin[off : off + rsa_bytes]
+ pt = key.decrypt(block, padding.PKCS1v15())
+ out_parts.append(pt)
+ return b"".join(out_parts)
+
+
+def print_download_owner_key_payload_decrypt(data: dict, private_pem: bytes) -> None:
+ """data 为 JSON 的 data 对象(含 cardInfoEnc、dkeyEnc 等)。"""
+ card_b64 = data.get("cardInfoEnc")
+ dkey_b64 = data.get("dkeyEnc")
+ if not isinstance(card_b64, str) or not card_b64.strip():
+ print(">>> cardInfoEnc 缺失或非字符串,跳过解密")
+ return
+ if not isinstance(dkey_b64, str) or not dkey_b64.strip():
+ print(">>> dkeyEnc 缺失或非字符串,跳过解密")
+ return
+
+ key = serialization.load_pem_private_key(private_pem, password=None, backend=default_backend())
+ rsa_bytes = (key.key_size + 7) // 8
+
+ card_cipher, card_enc = decode_cipher_wire(card_b64, rsa_bytes)
+ dkey_cipher, dkey_enc = decode_cipher_wire(dkey_b64, rsa_bytes)
+
+ print(f">>> cardInfoEnc 线编码={card_enc} 密文字节={len(card_cipher)}")
+ print(f">>> dkeyEnc 线编码={dkey_enc} 密文字节={len(dkey_cipher)}")
+
+ card_plain = rsa_pkcs1_decrypt_blocks(private_pem, card_cipher)
+ dkey_plain = rsa_pkcs1_decrypt_blocks(private_pem, dkey_cipher)
+
+ print(f">>> cardInfo 明文长度={len(card_plain)}")
+ try:
+ print(card_plain.decode("utf-8"))
+ except UnicodeDecodeError:
+ print(binascii.hexlify(card_plain).decode("ascii"))
+
+ print(f">>> dkey 明文长度={len(dkey_plain)}")
+ print(binascii.hexlify(dkey_plain).decode("ascii"))
--- /dev/null
+#!/usr/bin/env python3
+"""
+数字钥匙 2.0 — 公钥注册后立刻车主钥匙下载(同一私钥与 publicKeyId 绑定)
+
+一次进程内完成:
+ 1)本地 RSA → POST public-key-register
+ 2)从响应 JSON 的 data 读取 publicKeyId
+ 3)拼接 signData → SHA-256(UTF-8) 得 32 字节 digest → PKCS#1 type1 块尾随 digest(无 DigestInfo)→
+ NONEwithRSA(RSASP1,与 Java ``Signature.getInstance("NONEwithRSA")`` 一致)→ Base64 → POST download-owner-key
+
+privateKeySign:
+ · 字段 ASCII 排序后拼接取值 → signData;
+ · digest = SHA256(signData);PKCS#1 EM = 00 01 PS 00 || digest(非 SHA256withRSA / 非 OID 封装);
+ · 与标准 RSASSA-PKCS1-SHA256 签名字节不同;打印 hex 仅对照外挂 SHA-256。
+
+默认:若 --key-dir 下已有 *_public_spki_b64.txt 则复用最新一套密钥;需要全新密钥时请加 --force-new-key。
+
+依赖:cryptography;ControlCarSign / OAuth 来自同目录 openc_car_getCarListByBrandCode_v3_test.py(仅此一处外部模块加载)。
+
+示例:
+ python openc_dkey_register_and_download_owner_key_control_car_test.py \\
+ --access-token <token> --secret-key <SECRETKEY> \\
+ --user-id <uuid> --car-id <车辆ID>
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import hashlib
+import importlib.util
+import json
+import re
+import secrets
+import ssl
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+_SCRIPT_DIR = Path(__file__).resolve().parent
+if str(_SCRIPT_DIR) not in sys.path:
+ sys.path.insert(0, str(_SCRIPT_DIR))
+
+from http_response_print import response_from_httperror, response_from_urlopen
+from openc_dkey_download_owner_key_payload_decrypt import print_download_owner_key_payload_decrypt
+
+# ---------------------------------------------------------------------------
+# ControlCarSign / OAuth(仅此加载外部脚本)
+# ---------------------------------------------------------------------------
+
+
+def _load_sign_module():
+ path = _SCRIPT_DIR / "openc_car_getCarListByBrandCode_v3_test.py"
+ if not path.is_file():
+ raise FileNotFoundError(f"找不到签名模块: {path}")
+ spec = importlib.util.spec_from_file_location("_openc_chain_sign", path)
+ if spec is None or spec.loader is None:
+ raise RuntimeError(f"无法加载: {path}")
+ mod = importlib.util.module_from_spec(spec)
+ sys.modules["_openc_chain_sign"] = mod
+ spec.loader.exec_module(mod)
+ return mod
+
+
+# ---------------------------------------------------------------------------
+# public-key-register:密钥生成与路径(原 openc_dkey_public_key_register_*)
+# ---------------------------------------------------------------------------
+
+DEFAULT_DEVICE_ID = "8c046d6f4ed0ec77"
+DEFAULT_KEY_DIR = Path("dkey_keys_register")
+PATH_PUBLIC_KEY_REGISTER = "/openc-apigw/dkey/api/v1/secret-key/public-key-register"
+_SPKI_SUFFIX = "_public_spki_b64.txt"
+
+
+def _read_spki_b64_from_text(text: str) -> str:
+ for raw in text.splitlines():
+ line = raw.strip()
+ if not line or line.startswith("#"):
+ continue
+ return line
+ raise ValueError("文件中未找到 SPKI Base64 行(已跳过 # 注释与空行)")
+
+
+def _key_file_comment_header(*, app_id: str, file_base: str, kind_zh: str) -> str:
+ parts = [
+ "# 数字钥匙公钥注册 — 本地保存(appId 仅作说明,不参与密码学;对齐 ssh-keygen 注释用途)",
+ f"# appId: {app_id}",
+ f"# 文件基名: {file_base}",
+ f"# 文件类型: {kind_zh}",
+ "#",
+ ]
+ return "\n".join(parts) + "\n"
+
+
+def _sanitize_for_filename(s: str) -> str:
+ t = s.strip().replace(".", "_").replace(":", "_")
+ t = re.sub(r"[^0-9A-Za-z._-]+", "_", t)
+ return t[:96] if len(t) > 96 else t
+
+
+def _find_latest_public_spki_b64_file(key_dir: Path) -> Path | None:
+ if not key_dir.is_dir():
+ return None
+ candidates = list(key_dir.glob(f"*{_SPKI_SUFFIX}"))
+ if not candidates:
+ return None
+ candidates.sort(key=lambda p: p.stat().st_mtime_ns, reverse=True)
+ return candidates[0]
+
+
+def _file_base_from_spki_path(spki_path: Path) -> str:
+ name = spki_path.name
+ if name.endswith(_SPKI_SUFFIX):
+ return name[: -len(_SPKI_SUFFIX)]
+ return spki_path.stem
+
+
+def _collect_saved_paths(key_dir: Path, file_base: str) -> dict[str, Path]:
+ mapping = {
+ "private_pem": key_dir / f"{file_base}_rsa_private.pem",
+ "public_pem": key_dir / f"{file_base}_rsa_public.pem",
+ "public_spki_b64": key_dir / f"{file_base}{_SPKI_SUFFIX}",
+ }
+ return {k: v for k, v in mapping.items() if v.is_file()}
+
+
+def _generate_rsa_save_local(
+ key_dir: Path,
+ file_base: str,
+ *,
+ app_id: str,
+) -> tuple[str, dict[str, Path]]:
+ try:
+ from cryptography.hazmat.primitives import serialization
+ from cryptography.hazmat.primitives.asymmetric import rsa
+ except ImportError as e:
+ raise RuntimeError(
+ "需要安装 cryptography:pip install cryptography\n"
+ f"原始错误: {e}"
+ ) from e
+
+ private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+ public_key = private_key.public_key()
+
+ priv_pem = private_key.private_bytes(
+ encoding=serialization.Encoding.PEM,
+ format=serialization.PrivateFormat.PKCS8,
+ encryption_algorithm=serialization.NoEncryption(),
+ )
+ pub_pem = public_key.public_bytes(
+ encoding=serialization.Encoding.PEM,
+ format=serialization.PublicFormat.SubjectPublicKeyInfo,
+ )
+ pub_der = public_key.public_bytes(
+ encoding=serialization.Encoding.DER,
+ format=serialization.PublicFormat.SubjectPublicKeyInfo,
+ )
+ pub_b64 = base64.b64encode(pub_der).decode("ascii")
+
+ key_dir.mkdir(parents=True, exist_ok=True)
+ paths = {
+ "private_pem": key_dir / f"{file_base}_rsa_private.pem",
+ "public_pem": key_dir / f"{file_base}_rsa_public.pem",
+ "public_spki_b64": key_dir / f"{file_base}{_SPKI_SUFFIX}",
+ }
+ hdr_priv = _key_file_comment_header(
+ app_id=app_id,
+ file_base=file_base,
+ kind_zh="RSA 私钥 PEM(PKCS#8)",
+ ).encode("utf-8")
+ hdr_pub = _key_file_comment_header(
+ app_id=app_id,
+ file_base=file_base,
+ kind_zh="RSA 公钥 PEM(SubjectPublicKeyInfo)",
+ ).encode("utf-8")
+ paths["private_pem"].write_bytes(hdr_priv + priv_pem)
+ paths["public_pem"].write_bytes(hdr_pub + pub_pem)
+ spki_txt = _key_file_comment_header(
+ app_id=app_id,
+ file_base=file_base,
+ kind_zh="SPKI DER 的 Base64(接口 body publicKey)",
+ ) + pub_b64 + "\n"
+ paths["public_spki_b64"].write_text(spki_txt, encoding="utf-8")
+
+ return pub_b64, paths
+
+
+# ---------------------------------------------------------------------------
+# download-owner-key:privateKeySign(原 openc_dkey_download_owner_key_*)
+# ---------------------------------------------------------------------------
+
+PATH_DOWNLOAD_OWNER_KEY = "/openc-apigw/dkey/api/v1/key/download-owner-key"
+
+_FIELDS_PRIVATE_SIGN_WITH_PROTOCOL = ("carId", "nonce", "protocolType", "publicKeyId", "userId")
+_FIELDS_PRIVATE_SIGN_WITHOUT_PROTOCOL = ("carId", "nonce", "publicKeyId", "userId")
+
+DEFAULT_PROTOCOL_TYPE = 1
+
+
+def _concat_for_private_sign(values: dict[str, str], fields: tuple[str, ...]) -> str:
+ subset: dict[str, str] = {}
+ for key in fields:
+ if key not in values:
+ raise ValueError(f"缺少参与 privateKeySign 的字段: {key}")
+ subset[key] = values[key]
+ sorted_items = sorted(subset.items(), key=lambda kv: kv[0])
+ return "".join(v for _, v in sorted_items)
+
+
+def _hashutils_get_sha256_java(s: str) -> str:
+ return hashlib.sha256(s.encode("utf-8")).hexdigest()
+
+
+def _print_private_key_sign_flow(
+ sign_inputs: dict[str, str],
+ fields: tuple[str, ...],
+ sign_data: str,
+ sha256_data: str,
+ private_key_sign_b64: str,
+ *,
+ private_key_pem: Path,
+) -> None:
+ digest_hex = sha256_data
+ try:
+ sig_raw_len = len(base64.b64decode(private_key_sign_b64))
+ except Exception:
+ sig_raw_len = -1
+ print("========== privateKeySign 计算流程 ==========")
+ print(f"私钥 PEM:{private_key_pem.resolve()}")
+ print()
+ order_hint = " < ".join(sorted(fields))
+ print(
+ "步骤 1)参与字段(无 privateKeySign)sortMapByKey(String.compareTo),键序 "
+ f"{order_hint};仅拼接各字段「值」,中间无分隔符 → signData。"
+ )
+ for k in sorted(fields):
+ v = sign_inputs[k]
+ print(f" · {k}: 长度={len(v)} {v!r}")
+ print()
+ print("步骤 2)signData:")
+ print(f" {sign_data!r}")
+ print(f" UTF-8 字节长度:{len(sign_data.encode('utf-8'))}")
+ print()
+ print("步骤 3)SHA-256(signData) 小写 hex(对照):")
+ print(f" {digest_hex}")
+ print()
+ print(
+ "步骤 4)privateKeySign:digest=SHA256(signData);PKCS#1 尾随 32 字节 digest;"
+ "NONEwithRSA / RSASP1(无库内摘要算法、无 DigestInfo)"
+ )
+ print()
+ print("步骤 5)Base64 → Body.privateKeySign")
+ if sig_raw_len >= 0:
+ print(f" 签名解码后长度:{sig_raw_len} 字节(RSA-2048 多为 256)")
+ print(f" privateKeySign:{private_key_sign_b64}")
+ print("======================================================================")
+ print()
+
+
+def _pem_private_bytes_strip_comments(pem_path: Path) -> bytes:
+ pem_bytes = pem_path.read_bytes()
+ if pem_bytes.lstrip().startswith(b"#"):
+ i = pem_bytes.find(b"-----BEGIN")
+ if i == -1:
+ raise ValueError("私钥 PEM 中未找到 -----BEGIN")
+ pem_bytes = pem_bytes[i:]
+ return pem_bytes
+
+
+def _pkcs1_v15_encode_type1_raw_tail(k: int, tail: bytes) -> bytes:
+ """PKCS#1 v1.5 block type 1:00 01 PS 00 || tail(无 ASN.1 DigestInfo,用于 NONEwithRSA)。"""
+ if len(tail) > k - 11:
+ raise ValueError("tail 过长或 RSA 模长不足")
+ ps_len = k - 3 - len(tail)
+ if ps_len < 8:
+ raise ValueError("PS 长度不足 8(PKCS#1)")
+ return b"\x00\x01" + (b"\xff" * ps_len) + b"\x00" + tail
+
+
+def _rsa_private_rsasp1(em: bytes, private_key: object) -> bytes:
+ """RSASP1:EM^k mod n → 签名字节串。"""
+ pn = private_key.private_numbers()
+ n = pn.public_numbers.n
+ d = pn.d
+ key_len = (n.bit_length() + 7) // 8
+ if len(em) != key_len:
+ raise ValueError(f"EM 长度 {len(em)} != 模长 {key_len}")
+ m = int.from_bytes(em, "big")
+ if m >= n:
+ raise ValueError("EM >= n")
+ s = pow(m, d, n)
+ return s.to_bytes(key_len, "big")
+
+
+def _private_key_sign_rsa_sha256(sign_data: str, pem_path: Path) -> tuple[str, str]:
+ """拼接串 → SHA-256(外部)→ PKCS#1 块尾随 32 字节摘要 → NONEwithRSA(私钥 mod_pow,无摘要 OID)。"""
+ try:
+ from cryptography.hazmat.primitives import serialization
+ except ImportError as e:
+ raise RuntimeError(
+ "需要安装 cryptography:pip install cryptography\n"
+ f"原始错误: {e}"
+ ) from e
+
+ digest = hashlib.sha256(sign_data.encode("utf-8")).digest()
+ sha256_data = _hashutils_get_sha256_java(sign_data)
+
+ private_key = serialization.load_pem_private_key(
+ _pem_private_bytes_strip_comments(pem_path), password=None
+ )
+ n = private_key.private_numbers().public_numbers.n
+ k = (n.bit_length() + 7) // 8
+ em = _pkcs1_v15_encode_type1_raw_tail(k, digest)
+ print("========== privateKeySign(SHA256 外挂 + NONEwithRSA / 无 DigestInfo)==========")
+ print(f" pem_path: {pem_path.resolve()}")
+ print(f" sign_data len={len(sign_data)} {sign_data!r}")
+ print(f" SHA256(signData) hex(对照): {sha256_data}")
+ print(f" PKCS#1 EM:尾随原始 32 字节摘要(非 SHA256withRSA / 非 OID 封装)")
+ print("===========================================================================")
+ sig = _rsa_private_rsasp1(em, private_key)
+ b64 = base64.b64encode(sig).decode("ascii")
+ return b64, sha256_data
+
+
+def _rsa_public_modpow_recover_em(pub: object, sig: bytes) -> bytes:
+ pn = pub.public_numbers()
+ n, e = pn.n, pn.e
+ k = (n.bit_length() + 7) // 8
+ if len(sig) != k:
+ raise ValueError(f"签名长度 {len(sig)} 与模数字节长度 {k} 不一致")
+ s_int = int.from_bytes(sig, "big")
+ if s_int >= n:
+ raise ValueError("签名整数不小于模数")
+ m_int = pow(s_int, e, n)
+ return m_int.to_bytes(k, "big")
+
+
+def _pkcs1v15_em_unpad_type1(em: bytes) -> bytes:
+ if len(em) < 11:
+ raise ValueError("EM 过短")
+ if em[0] != 0:
+ raise ValueError("EM 首位应为 0x00")
+ if em[1] != 1:
+ raise ValueError("非 PKCS#1 block type 1(签名)")
+ i = 2
+ while i < len(em) and em[i] == 0xFF:
+ i += 1
+ if i >= len(em) or em[i] != 0:
+ raise ValueError("PKCS#1 填充分隔符无效")
+ return em[i + 1 :]
+
+
+def _recover_raw_tail_from_none_rsa_signature(pub: object, sig: bytes) -> bytes:
+ """公钥恢复 EM,解出 PKCS#1 type1 尾部载荷(NONEwithRSA 下的原始摘要字节)。"""
+ em = _rsa_public_modpow_recover_em(pub, sig)
+ return _pkcs1v15_em_unpad_type1(em)
+
+
+def _expected_sha256_digest_for_private_sign(sign_data: str) -> bytes:
+ return hashlib.sha256(sign_data.encode("utf-8")).digest()
+
+
+def print_public_key_decrypt_signature_digest_check(
+ sign_data: str,
+ private_key_sign_b64: str,
+ pem_path: Path,
+) -> None:
+ try:
+ from cryptography.hazmat.primitives import serialization
+ except ImportError as e:
+ raise RuntimeError(f"需要 cryptography:{e}") from e
+
+ pk = serialization.load_pem_private_key(
+ _pem_private_bytes_strip_comments(pem_path), password=None
+ )
+ pub = pk.public_key()
+ sig = base64.b64decode(private_key_sign_b64)
+ try:
+ recovered = _recover_raw_tail_from_none_rsa_signature(pub, sig)
+ except Exception as ex:
+ print("========== 公钥「解密」签名块(摘要恢复)==========")
+ print(f"!!! 解析失败:{ex}")
+ print("================================================")
+ print()
+ return
+
+ expected = _expected_sha256_digest_for_private_sign(sign_data)
+ ok = recovered == expected
+ print("========== 公钥「解密」签名块(摘要恢复)==========")
+ print(
+ "说明:NONEwithRSA 块尾为「外挂 SHA-256」的 32 字节(无 DigestInfo);"
+ "应与 SHA-256(signData) 一致。"
+ )
+ print(f" 从签名恢复的摘要 hex:{recovered.hex()}")
+ print(f" 本地期望摘要 hex: {expected.hex()}")
+ print(f" 是否一致:{'是' if ok else '否'}")
+ print("================================================")
+ print()
+
+
+def _local_verify_private_key_sign(
+ sign_data: str,
+ private_key_sign_b64: str,
+ pem_path: Path,
+) -> None:
+ try:
+ from cryptography.hazmat.primitives import serialization
+ except ImportError as e:
+ raise RuntimeError(
+ "需要安装 cryptography:pip install cryptography\n"
+ f"原始错误: {e}"
+ ) from e
+
+ digest = hashlib.sha256(sign_data.encode("utf-8")).digest()
+ private_key = serialization.load_pem_private_key(
+ _pem_private_bytes_strip_comments(pem_path), password=None
+ )
+ pub = private_key.public_key()
+ sig = base64.b64decode(private_key_sign_b64)
+ try:
+ got = _recover_raw_tail_from_none_rsa_signature(pub, sig)
+ except Exception as e:
+ raise RuntimeError(f"本地验签失败(无法解析 PKCS#1 载荷):{e}") from e
+ if got != digest:
+ raise RuntimeError(
+ "本地验签失败:NONEwithRSA 恢复的摘要与 SHA-256(signData) 不一致。"
+ )
+
+
+def _assert_spki_matches_private_pem(pub_spki_b64: str, private_pem: Path) -> None:
+ try:
+ from cryptography.hazmat.primitives import serialization
+ from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
+ except ImportError as e:
+ raise RuntimeError(f"需要 cryptography:{e}") from e
+
+ pem_bytes = _pem_private_bytes_strip_comments(private_pem)
+ private_key = serialization.load_pem_private_key(pem_bytes, password=None)
+ pub_der = private_key.public_key().public_bytes(
+ Encoding.DER,
+ PublicFormat.SubjectPublicKeyInfo,
+ )
+ got = base64.b64encode(pub_der).decode("ascii")
+ want = pub_spki_b64.strip()
+ if got != want:
+ raise RuntimeError(
+ "注册用 publicKey(SPKI Base64)与私钥 PEM 不是一对:请检查 key-dir / 是否混用了多个 pkreg_* 文件。\n"
+ f" 私钥导出 SPKI 前 48 字符: {got[:48]}...\n"
+ f" 将注册的 SPKI 前 48 字符: {want[:48]}..."
+ )
+
+
+def main() -> None:
+ mod = _load_sign_module()
+
+ p = argparse.ArgumentParser(
+ description="dkey:public-key-register → 取 publicKeyId → download-owner-key(同一私钥)"
+ )
+ p.add_argument("--access-token", "--accessToken", dest="access_token", default=None)
+ p.add_argument("--secret-key", "--client-secret", dest="secret_key", required=True)
+
+ p.add_argument("--app-id", "--appId", dest="app_id", default="cn.com.changan_1234.cvim")
+ p.add_argument(
+ "--force-new-key",
+ action="store_true",
+ help="忽略密钥目录内已有 *_public_spki_b64.txt,强制重新生成 RSA",
+ )
+ p.add_argument(
+ "--no-package-in-key-filename",
+ action="store_true",
+ help="保存密钥文件名不包含 appId 段",
+ )
+ p.add_argument("--user-id", "--userId", dest="user_id", required=True)
+ p.add_argument(
+ "--device-id",
+ "--deviceId",
+ dest="device_id",
+ default=DEFAULT_DEVICE_ID,
+ )
+ p.add_argument("--algorithm", default="RSA")
+ p.add_argument("--key-dir", type=Path, default=DEFAULT_KEY_DIR)
+ p.add_argument("--key-prefix", default=None)
+ p.add_argument("--public-key-b64-file", type=Path, default=None)
+
+ p.add_argument("--car-id", "--carId", dest="car_id", required=True, help="download-owner-key 所需车辆 ID")
+
+ p.add_argument("--body-nonce", dest="body_nonce", default=None)
+ p.add_argument("--protocol-type", "--protocolType", dest="protocol_type", type=int, default=DEFAULT_PROTOCOL_TYPE)
+ p.add_argument(
+ "--private-sign-exclude-protocol-type",
+ action="store_true",
+ help="privateKeySign 不含 protocolType",
+ )
+ p.add_argument("--no-print-private-sign", action="store_true")
+ p.add_argument(
+ "--no-public-decrypt-check",
+ action="store_true",
+ help="不执行公钥侧签名块摘要还原自检(默认执行)",
+ )
+ p.add_argument(
+ "--no-decrypt-response",
+ action="store_true",
+ help="不解密 download-owner-key 响应中的 cardInfoEnc / dkeyEnc",
+ )
+ p.add_argument(
+ "--protocol-type-json-number",
+ action="store_true",
+ help="download Body 中 protocolType 用 JSON 数字",
+ )
+ p.add_argument(
+ "--timestamp",
+ default=None,
+ help="两请求可分别需要时间戳;此处为第一段注册使用;下载段单独生成毫秒时间戳",
+ )
+ p.add_argument("--timestamp-seconds", action="store_true")
+ p.add_argument("--nonce", default="RANDOM", help="注册请求头 nonce;下载会重新随机")
+
+ p.add_argument("--api-path-register", default=None, help="覆盖注册 PATH")
+ p.add_argument("--api-path-download", default=None, help="覆盖下载 PATH")
+ p.add_argument("--secret-base64-decoded", action="store_true")
+ p.add_argument("--java-log", action="store_true")
+ p.add_argument("--debug", action="store_true")
+ p.add_argument("--timeout", type=float, default=30.0)
+ p.add_argument("--insecure", action="store_true")
+
+ p.add_argument("--grant-type", choices=["authorization_code", "refresh_token"], default="refresh_token")
+ p.add_argument("--code", default=None)
+ p.add_argument("--redirect-uri", default=None)
+ p.add_argument("--refresh-token", default=None)
+ p.add_argument("--client-id", default=mod.DEFAULT_CLIENT_ID)
+ p.add_argument("--oauth-client-secret", default=mod.DEFAULT_CLIENT_SECRET)
+
+ args = p.parse_args()
+
+ app_id_comment = (str(args.app_id).strip() if args.app_id else "") or "(未指定)"
+
+ prefix = args.key_prefix or f"pkreg_{int(time.time())}"
+ if args.no_package_in_key_filename:
+ file_base = prefix
+ else:
+ aid = str(args.app_id).strip() if args.app_id else ""
+ if aid:
+ file_base = f"{prefix}_{_sanitize_for_filename(aid)}"
+ else:
+ file_base = prefix
+
+ if args.public_key_b64_file:
+ pub_b64 = _read_spki_b64_from_text(
+ args.public_key_b64_file.read_text(encoding="utf-8")
+ )
+ saved_paths = {}
+ print(f">>> 使用已有 publicKey(文件):{args.public_key_b64_file}")
+ print(
+ "!!! 链式脚本需要本地 *_rsa_private.pem;仅用 b64 时请改用单独 register / download 并手动指定私钥。",
+ file=sys.stderr,
+ )
+ else:
+ reused: Path | None = None
+ if not args.force_new_key:
+ reused = _find_latest_public_spki_b64_file(args.key_dir)
+ if reused is not None:
+ pub_b64 = _read_spki_b64_from_text(reused.read_text(encoding="utf-8"))
+ file_base = _file_base_from_spki_path(reused)
+ saved_paths = _collect_saved_paths(args.key_dir, file_base)
+ print("========== 复用目录内已有密钥(链式仍建议新生成)==========")
+ print(f">>> {reused.resolve()}")
+ print()
+ else:
+ pub_b64, saved_paths = _generate_rsa_save_local(
+ args.key_dir, file_base, app_id=app_id_comment
+ )
+ print("========== 本地已保存密钥(本次注册将使用)==========")
+ print(f">>> 文件基名:{file_base}")
+ for name, pth in saved_paths.items():
+ print(f" {name}: {pth.resolve()}")
+ print("================================================")
+ print()
+
+ private_pem = saved_paths.get("private_pem")
+ if not private_pem or not private_pem.is_file():
+ print("错误:找不到本次对应的 *_rsa_private.pem,无法保证私钥与注册公钥一致。", file=sys.stderr)
+ sys.exit(2)
+
+ try:
+ _assert_spki_matches_private_pem(pub_b64, private_pem)
+ except RuntimeError as e:
+ print(str(e), file=sys.stderr)
+ sys.exit(2)
+ print(
+ ">>> 密钥自检:私钥 PEM 导出的 SPKI Base64 与本次注册的 publicKey 一致(同一密钥对)。"
+ )
+ print()
+
+ token = args.access_token
+ if not token:
+ token = mod.fetch_user_access_token(
+ timeout=args.timeout,
+ insecure=args.insecure,
+ grant_type=args.grant_type,
+ client_id=args.client_id,
+ client_secret=args.oauth_client_secret,
+ code=args.code,
+ redirect_uri=args.redirect_uri,
+ refresh_token=args.refresh_token,
+ )
+
+ if args.timestamp_seconds:
+ ts_reg = args.timestamp or str(int(time.time()))
+ else:
+ ts_reg = args.timestamp or str(int(time.time() * 1000))
+
+ nonce_reg = args.nonce
+ if nonce_reg.upper() == "RANDOM":
+ nonce_reg = mod.rand_nonce(4)
+
+ body_reg: dict[str, str] = {"publicKey": pub_b64, "algorithm": args.algorithm}
+ if args.app_id is not None:
+ body_reg["appId"] = args.app_id
+ body_reg["userId"] = args.user_id
+ body_reg["deviceId"] = args.device_id
+ body_wire_reg = json.dumps(body_reg, ensure_ascii=False, separators=(",", ":"))
+
+ path_reg = (args.api_path_register or PATH_PUBLIC_KEY_REGISTER).strip()
+ auth_reg, _q1, hb1, st1, sp1 = mod.build_authorization_control_car(
+ client_secret=args.secret_key,
+ token=token,
+ timestamp=ts_reg,
+ nonce=nonce_reg,
+ query_params=None,
+ http_url=path_reg,
+ hmac_secret_base64_decode=args.secret_base64_decoded,
+ java_style_log=args.java_log,
+ http_method="POST",
+ body_for_sign=body_wire_reg,
+ )
+
+ url_reg = f"https://{mod.SERVER}{path_reg}"
+ headers_reg = {
+ "Content-Type": "application/json",
+ mod.TOKEN_HEADER_NAME: token,
+ mod.X_VCS_TOKEN: token,
+ mod.X_VCS_TIMESTAMP: ts_reg,
+ mod.X_VCS_NONCE: nonce_reg,
+ "Authorization": auth_reg,
+ }
+
+ print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
+ print(">>> ① public-key-register")
+ print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
+ if args.debug:
+ print(body_wire_reg)
+ print()
+ print(f"POST {path_reg}")
+ print(f"私钥文件(下载时将使用同一文件):{private_pem.resolve()}")
+ print()
+
+ ctx = ssl.create_default_context()
+ if args.insecure:
+ ctx.check_hostname = False
+ ctx.verify_mode = ssl.CERT_NONE
+
+ req_reg = urllib.request.Request(
+ url_reg,
+ data=body_wire_reg.encode("utf-8"),
+ headers=headers_reg,
+ method="POST",
+ )
+ try:
+ with urllib.request.urlopen(req_reg, timeout=args.timeout, context=ctx) as r:
+ body_bytes_reg = r.read()
+ response_from_urlopen(r, body_bytes_reg)
+ except urllib.error.HTTPError as e:
+ body_bytes_reg = e.read()
+ response_from_httperror(e, body_bytes_reg)
+ sys.exit(1)
+
+ try:
+ reg_json = json.loads(body_bytes_reg.decode("utf-8"))
+ except json.JSONDecodeError as e:
+ print(f"注册响应非 JSON:{e}", file=sys.stderr)
+ sys.exit(1)
+
+ if reg_json.get("code") != 0 or not reg_json.get("success", False):
+ print("公钥注册未成功,已跳过 download-owner-key。", file=sys.stderr)
+ sys.exit(1)
+
+ public_key_id = reg_json.get("data")
+ if public_key_id is None:
+ print("注册响应缺少 data(publicKeyId)。", file=sys.stderr)
+ sys.exit(1)
+ public_key_id_str = str(public_key_id)
+
+ print()
+ print(f">>> 本次注册 publicKeyId(将用于下载): {public_key_id_str}")
+ print()
+
+ body_nonce = args.body_nonce
+ if not body_nonce:
+ body_nonce = secrets.token_hex(8)
+ body_nonce = body_nonce.strip().upper()
+ if len(body_nonce) != 16:
+ print(f"Body nonce 须为 16 位十六进制:{body_nonce!r}", file=sys.stderr)
+ sys.exit(1)
+
+ if args.timestamp_seconds:
+ ts_dl = str(int(time.time()))
+ else:
+ ts_dl = str(int(time.time() * 1000))
+
+ hdr_nonce_dl = mod.rand_nonce(4)
+
+ pt = args.protocol_type
+ if args.private_sign_exclude_protocol_type:
+ sign_fields = _FIELDS_PRIVATE_SIGN_WITHOUT_PROTOCOL
+ sign_inputs = {
+ "carId": args.car_id,
+ "nonce": body_nonce,
+ "publicKeyId": public_key_id_str,
+ "userId": args.user_id,
+ }
+ else:
+ sign_fields = _FIELDS_PRIVATE_SIGN_WITH_PROTOCOL
+ sign_inputs = {
+ "carId": args.car_id,
+ "nonce": body_nonce,
+ "protocolType": str(pt),
+ "publicKeyId": public_key_id_str,
+ "userId": args.user_id,
+ }
+
+ concat_str = _concat_for_private_sign(sign_inputs, sign_fields)
+ private_key_sign_b64, sha256_data = _private_key_sign_rsa_sha256(concat_str, private_pem)
+
+ _local_verify_private_key_sign(concat_str, private_key_sign_b64, private_pem)
+ print(">>> 本地验签:SHA256(拼接串) + NONEwithRSA(PKCS#1 原始摘要尾)通过。")
+ print(
+ ">>> 若服务端仍返回「验签失败」:多为平台在 publicKeyId 下保存的公钥 "
+ "不是本次请求刚注册的那把(例如 data 长期不变、后台未覆盖旧公钥)。请向平台确认注册是否覆盖该 ID,或换账号/解绑后重试。"
+ )
+ print()
+
+ if not args.no_public_decrypt_check:
+ print_public_key_decrypt_signature_digest_check(
+ concat_str,
+ private_key_sign_b64,
+ private_pem,
+ )
+
+ if not args.no_print_private_sign:
+ _print_private_key_sign_flow(
+ sign_inputs,
+ sign_fields,
+ concat_str,
+ sha256_data,
+ private_key_sign_b64,
+ private_key_pem=private_pem,
+ )
+
+ if args.protocol_type_json_number:
+ body_dl: dict[str, str | int] = {
+ "carId": args.car_id,
+ "nonce": body_nonce,
+ "privateKeySign": private_key_sign_b64,
+ "protocolType": pt,
+ "publicKeyId": public_key_id_str,
+ "userId": args.user_id,
+ }
+ else:
+ body_dl = {
+ "carId": args.car_id,
+ "nonce": body_nonce,
+ "privateKeySign": private_key_sign_b64,
+ "protocolType": str(pt),
+ "publicKeyId": public_key_id_str,
+ "userId": args.user_id,
+ }
+ body_wire_dl = json.dumps(body_dl, ensure_ascii=False, separators=(",", ":"))
+
+ path_dl = (args.api_path_download or PATH_DOWNLOAD_OWNER_KEY).strip()
+ auth_dl, _q2, hb2, st2, sp2 = mod.build_authorization_control_car(
+ client_secret=args.secret_key,
+ token=token,
+ timestamp=ts_dl,
+ nonce=hdr_nonce_dl,
+ query_params=None,
+ http_url=path_dl,
+ hmac_secret_base64_decode=args.secret_base64_decoded,
+ java_style_log=args.java_log,
+ http_method="POST",
+ body_for_sign=body_wire_dl,
+ )
+
+ url_dl = f"https://{mod.SERVER}{path_dl}"
+ headers_dl = {
+ "Content-Type": "application/json",
+ mod.TOKEN_HEADER_NAME: token,
+ mod.X_VCS_TOKEN: token,
+ mod.X_VCS_TIMESTAMP: ts_dl,
+ mod.X_VCS_NONCE: hdr_nonce_dl,
+ "Authorization": auth_dl,
+ }
+
+ print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
+ print(">>> ② download-owner-key(privateKeySign 使用上一行的私钥)")
+ print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
+ if args.debug:
+ body_sha_hex = mod.hash_utils_get_sha256_for_control_car(body_wire_dl)
+ print(">>> HTTP Body")
+ print(body_wire_dl)
+ print(">>> HashUtils.getSHA256(body) hex")
+ print(body_sha_hex)
+ print()
+ print(">>> headMap2String")
+ print(hb2, end="")
+ print()
+ print(">>> splicing")
+ print(sp2)
+ print()
+ print(">>> StringToSign")
+ print(st2)
+ print()
+
+ print("========== 请求报文 ==========")
+ print(f"POST {path_dl} HTTP/1.1")
+ print(f"Host: {mod.SERVER}")
+ for k, v in headers_dl.items():
+ print(f"{k}: {v}")
+ print()
+ print(body_wire_dl)
+ print("==============================")
+ print()
+
+ req_dl = urllib.request.Request(
+ url_dl,
+ data=body_wire_dl.encode("utf-8"),
+ headers=headers_dl,
+ method="POST",
+ )
+ body_dl_bytes = b""
+ try:
+ with urllib.request.urlopen(req_dl, timeout=args.timeout, context=ctx) as r:
+ body_dl_bytes = r.read()
+ response_from_urlopen(r, body_dl_bytes)
+ except urllib.error.HTTPError as e:
+ body_dl_bytes = e.read()
+ response_from_httperror(e, body_dl_bytes)
+
+ try:
+ dj = json.loads(body_dl_bytes.decode("utf-8"))
+ if dj.get("code") == 40000 and dj.get("msg") and "验签" in str(dj.get("msg")):
+ print(
+ ">>> 提示:HTTP 200 但业务码表示私钥验签失败时,请核对开放平台「该 userId 下 publicKeyId 绑定的公钥」"
+ "是否与本次注册请求的 publicKey 一致(可用客服/后台查询)。"
+ )
+ if (
+ not args.no_decrypt_response
+ and dj.get("code") == 0
+ and isinstance(dj.get("data"), dict)
+ ):
+ print_download_owner_key_payload_decrypt(dj["data"], private_pem)
+ except (json.JSONDecodeError, UnicodeDecodeError):
+ pass
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+#!/usr/bin/env python3
+"""
+openC - fc 消息推送信息查询(ControlCarSign)
+
+接口(文档 fc-消息推送信息查询):
+ POST https://open.iov.changan.com.cn/openc-apigw/openc-apigw/fc/api/v2/open/information/getReceiverInformations?<Query>
+
+Header:X-VCS-User-Access-Token、X-VCS-Token、X-VCS-Timestamp、X-VCS-Nonce、Authorization
+Content-Type: application/x-www-form-urlencoded
+
+Query(文档):actionType(必填,默认 1)、trackUserId(必填);可选 realReceiverId、trunkFullPath、page、limit。
+Body:无(空体)。
+
+签名:query_params 参与 HashedCanonicalRequest;POST、body_for_sign 为空串。
+
+Query 键顺序与文档表一致(仅包含实际传入的键),以便对齐 Java getUrlencodeStr 的 entry 顺序。
+
+默认 httpUrl 为双段网关前缀;单段请传:
+ --api-path /openc-apigw/fc/api/v2/open/information/getReceiverInformations
+
+示例:
+ python openc_fc_get_receiver_informations_v2_test.py --access-token <token> --secret-key <KEY> --track-user-id <用户ID>
+ python openc_fc_get_receiver_informations_v2_test.py ... --action-type 1 --page 1 --limit 20
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import ssl
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+PATH = "/openc-apigw/fc/api/v2/open/information/getReceiverInformations"
+
+
+def _load_sign_module():
+ base = Path(__file__).resolve().parent
+ path = base / "openc_car_getCarListByBrandCode_v3_test.py"
+ if not path.is_file():
+ raise FileNotFoundError(f"找不到签名模块: {path}")
+ spec = importlib.util.spec_from_file_location("_openc_fc_receiver_info_sign", path)
+ if spec is None or spec.loader is None:
+ raise RuntimeError(f"无法加载: {path}")
+ mod = importlib.util.module_from_spec(spec)
+ sys.modules["_openc_fc_receiver_info_sign"] = mod
+ spec.loader.exec_module(mod)
+ return mod
+
+
+def _query_map_from_args(args: argparse.Namespace) -> dict[str, str]:
+ q: dict[str, str] = {
+ "actionType": str(args.action_type),
+ "trackUserId": str(args.track_user_id),
+ }
+ if args.real_receiver_id:
+ q["realReceiverId"] = str(args.real_receiver_id)
+ if args.trunk_full_path:
+ q["trunkFullPath"] = str(args.trunk_full_path)
+ if args.page is not None:
+ q["page"] = str(args.page)
+ if args.limit is not None:
+ q["limit"] = str(args.limit)
+ return q
+
+
+def main() -> None:
+ mod = _load_sign_module()
+
+ p = argparse.ArgumentParser(description="fc getReceiverInformations POST(Query + 空 Body + ControlCarSign)")
+ p.add_argument("--access-token", "--accessToken", dest="access_token", default=None)
+ p.add_argument(
+ "--secret-key",
+ "--client-secret",
+ dest="secret_key",
+ default=None,
+ help="verifySign HMAC 密钥",
+ )
+ p.add_argument(
+ "--track-user-id",
+ "--trackUserId",
+ dest="track_user_id",
+ required=True,
+ help="Query trackUserId(用户 ID)",
+ )
+ p.add_argument(
+ "--action-type",
+ "--actionType",
+ dest="action_type",
+ default="1",
+ help="接收终端类型:0 车机 1 乘用车 App 2 新能源 App 3 商用车 App 4 鹏城 App;默认 1",
+ )
+ p.add_argument(
+ "--real-receiver-id",
+ "--realReceiverId",
+ dest="real_receiver_id",
+ default=None,
+ help="Query realReceiverId(可选)",
+ )
+ p.add_argument(
+ "--trunk-full-path",
+ "--trunkFullPath",
+ dest="trunk_full_path",
+ default=None,
+ help="Query trunkFullPath(可选)",
+ )
+ p.add_argument("--page", default=None, help="分页 page(可选)")
+ p.add_argument("--limit", default=None, help="分页 limit(可选)")
+ p.add_argument(
+ "--timestamp",
+ default=None,
+ help="X-VCS-Timestamp;未传则当前毫秒",
+ )
+ p.add_argument(
+ "--timestamp-seconds",
+ action="store_true",
+ help="未传 --timestamp 时使用当前秒",
+ )
+ p.add_argument("--nonce", default="RANDOM", help="4 位 X-VCS-Nonce;默认 RANDOM")
+ p.add_argument(
+ "--api-path",
+ default=None,
+ help="verifySign 与 POST 的 httpUrl 路径(不含 Query;默认双前缀 PATH)",
+ )
+ p.add_argument("--secret-base64-decoded", action="store_true")
+ p.add_argument("--java-log", action="store_true")
+ p.add_argument("--debug", action="store_true")
+ p.add_argument("--timeout", type=float, default=30.0)
+ p.add_argument("--insecure", action="store_true")
+
+ p.add_argument("--grant-type", choices=["authorization_code", "refresh_token"], default="refresh_token")
+ p.add_argument("--code", default=None)
+ p.add_argument("--redirect-uri", default=None)
+ p.add_argument("--refresh-token", default=None)
+ p.add_argument("--client-id", default=mod.DEFAULT_CLIENT_ID)
+ p.add_argument("--oauth-client-secret", default=mod.DEFAULT_CLIENT_SECRET)
+
+ args = p.parse_args()
+
+ if not args.secret_key:
+ p.error("必须提供 --secret-key")
+
+ token = args.access_token
+ if not token:
+ token = mod.fetch_user_access_token(
+ timeout=args.timeout,
+ insecure=args.insecure,
+ grant_type=args.grant_type,
+ client_id=args.client_id,
+ client_secret=args.oauth_client_secret,
+ code=args.code,
+ redirect_uri=args.redirect_uri,
+ refresh_token=args.refresh_token,
+ )
+
+ if args.timestamp_seconds:
+ ts = args.timestamp or str(int(time.time()))
+ else:
+ ts = args.timestamp or str(int(time.time() * 1000))
+ nonce = args.nonce
+ if nonce.upper() == "RANDOM":
+ nonce = mod.rand_nonce(4)
+
+ query_map = _query_map_from_args(args)
+ path_use = (args.api_path or PATH).strip()
+
+ authorization, query_wire, head_block, string_to_sign, splicing_full = mod.build_authorization_control_car(
+ client_secret=args.secret_key,
+ token=token,
+ timestamp=ts,
+ nonce=nonce,
+ query_params=query_map,
+ http_url=path_use,
+ hmac_secret_base64_decode=args.secret_base64_decoded,
+ java_style_log=args.java_log,
+ http_method="POST",
+ body_for_sign="",
+ )
+
+ url = f"https://{mod.SERVER}{path_use}"
+ if query_wire:
+ url = url + "?" + query_wire
+
+ headers = {
+ "Accept": "application/json, text/plain, */*",
+ "Content-Type": "application/x-www-form-urlencoded",
+ mod.TOKEN_HEADER_NAME: token,
+ mod.X_VCS_TOKEN: token,
+ mod.X_VCS_TIMESTAMP: ts,
+ mod.X_VCS_NONCE: nonce,
+ "Authorization": authorization,
+ }
+
+ if args.debug:
+ print(">>> POST", path_use)
+ print(">>> query_map", query_map)
+ print(">>> query_wire")
+ print(query_wire)
+ print()
+ print(">>> headMap2String")
+ print(head_block, end="")
+ print()
+ print(">>> HashedCanonicalRequest splicing")
+ print(splicing_full)
+ print()
+ print(">>> StringToSign")
+ print(string_to_sign)
+ print()
+
+ print(">>> 请求 URL:" + url)
+ print("========== 请求报文 ==========")
+ print(f"POST {path_use} HTTP/1.1")
+ print(f"Host: {mod.SERVER}")
+ for k, v in headers.items():
+ print(f"{k}: {v}")
+ print()
+ print("(empty body)")
+ print("==============================")
+ print()
+
+ ctx = ssl.create_default_context()
+ if args.insecure:
+ ctx.check_hostname = False
+ ctx.verify_mode = ssl.CERT_NONE
+
+ req = urllib.request.Request(url, data=b"", headers=headers, method="POST")
+ try:
+ with urllib.request.urlopen(req, timeout=args.timeout, context=ctx) as r:
+ status = r.getcode()
+ body = r.read()
+ except urllib.error.HTTPError as e:
+ status = e.code
+ body = e.read()
+
+ print("========== 响应报文 ==========")
+ print(f"HTTP/1.1 {status}")
+ print(body.decode("utf-8", errors="replace"))
+ print("==============================")
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+#!/usr/bin/env python3
+"""
+openC - /oauth/token 单独测试脚本
+
+用途:
+ 仅调用 https://open.iov.changan.com.cn/oauth/token,打印完整请求/响应报文,便于排查 401/invalid_client 等问题。
+
+支持的 grant_type:
+ - client_credentials(默认)
+ - authorization_code
+ - refresh_token
+
+示例:
+ python openc_oauth_token_test.py --client-id <id> --client-secret <secret>
+ python openc_oauth_token_test.py --grant-type authorization_code --code <code> --client-id <id> --client-secret <secret>
+ python openc_oauth_token_test.py --grant-type refresh_token --refresh-token <rt> --client-id <id> --client-secret <secret>
+"""
+
+from __future__ import annotations
+
+import argparse
+import ssl
+import sys
+import urllib.error
+import urllib.request
+from urllib.parse import urlencode
+
+SERVER = "open.iov.changan.com.cn"
+TOKEN_PATH = "/oauth/token"
+
+# 与仓库其它脚本保持一致的默认值(可命令行覆盖)
+DEFAULT_CLIENT_ID = "b235afd313004785bfde580c188c47bb"
+DEFAULT_CLIENT_SECRET = "YjIzNWFmZDMxMzAwNDc4NQ=="#"YbYwUsnVXZsb61pTpMy4zg=="
+
+
+def fetch_token(
+ *,
+ timeout: float,
+ insecure: bool,
+ grant_type: str,
+ client_id: str,
+ client_secret: str,
+ code: str | None,
+ redirect_uri: str | None,
+ refresh_token: str | None,
+) -> tuple[int, dict, bytes]:
+ url = f"https://{SERVER}{TOKEN_PATH}"
+ form: dict[str, str] = {
+ "client_id": client_id,
+ "client_secret": client_secret,
+ "grant_type": grant_type,
+ }
+ if grant_type == "authorization_code":
+ if not code:
+ raise RuntimeError("grant_type=authorization_code 需要 --code")
+ form["code"] = code
+ if redirect_uri:
+ form["redirect_uri"] = redirect_uri
+ elif grant_type == "refresh_token":
+ if not refresh_token:
+ raise RuntimeError("grant_type=refresh_token 需要 --refresh-token")
+ form["refresh_token"] = refresh_token
+ elif grant_type == "client_credentials":
+ pass
+ else:
+ raise RuntimeError(f"不支持的 grant_type: {grant_type}")
+
+ body = urlencode(form).encode("utf-8")
+ headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+ print("========== 获取 Token 请求 ==========")
+ print(f"POST {TOKEN_PATH} HTTP/1.1")
+ print(f"Host: {SERVER}")
+ for k, v in headers.items():
+ print(f"{k}: {v}")
+ print()
+ print(body.decode("utf-8", errors="replace"))
+ print("=====================================")
+ print()
+
+ ctx = ssl.create_default_context()
+ if insecure:
+ ctx.check_hostname = False
+ ctx.verify_mode = ssl.CERT_NONE
+
+ req = urllib.request.Request(url, data=body, headers=headers, method="POST")
+ try:
+ with urllib.request.urlopen(req, timeout=timeout, context=ctx) as r:
+ status = r.getcode()
+ resp_headers = dict(r.headers)
+ raw = r.read()
+ return status, resp_headers, raw
+ except urllib.error.HTTPError as e:
+ status = e.code
+ resp_headers = dict(e.headers)
+ raw = e.read()
+ return status, resp_headers, raw
+
+
+def main() -> None:
+ p = argparse.ArgumentParser(description="openC oauth/token 单独测试")
+ p.add_argument(
+ "--grant-type",
+ choices=["client_credentials", "authorization_code", "refresh_token"],
+ default="client_credentials",
+ help="默认 client_credentials;传 --code 且未显式指定时自动切到 authorization_code",
+ )
+ p.add_argument("--client-id", default=DEFAULT_CLIENT_ID)
+ p.add_argument("--client-secret", default=DEFAULT_CLIENT_SECRET)
+ p.add_argument("--code", default=None, help="authorization_code 的 code")
+ p.add_argument("--redirect-uri", default=None, help="authorization_code 的 redirect_uri")
+ p.add_argument("--refresh-token", default=None, help="refresh_token 模式的 refresh_token")
+ p.add_argument("--timeout", type=float, default=30.0)
+ p.add_argument("--insecure", action="store_true", help="跳过 HTTPS 证书校验(仅测试)")
+ args = p.parse_args()
+
+ # 兼容常用手感:只传 --code 时,自动认为要走 authorization_code
+ grant_type = args.grant_type
+ if args.code and grant_type == "client_credentials":
+ grant_type = "authorization_code"
+ if args.code and grant_type != "authorization_code":
+ print(f">>> 提示:当前 --grant-type={grant_type},--code 将不会参与入参。", file=sys.stderr)
+
+ status, resp_headers, raw = fetch_token(
+ timeout=args.timeout,
+ insecure=args.insecure,
+ grant_type=grant_type,
+ client_id=args.client_id,
+ client_secret=args.client_secret,
+ code=args.code,
+ redirect_uri=args.redirect_uri,
+ refresh_token=args.refresh_token,
+ )
+
+ text = raw.decode("utf-8", errors="replace")
+ print("========== 获取 Token 响应 ==========")
+ print(f"HTTP/1.1 {status}")
+ for k, v in resp_headers.items():
+ print(f"{k}: {v}")
+ print()
+ print(text)
+ print("=====================================")
+ print()
+
+ if status >= 400:
+ if grant_type == "authorization_code" and "Unauthorized grant type" in text:
+ print(
+ ">>> 提示:该 client_id 在服务端未允许 authorization_code。请改用 --grant-type client_credentials,"
+ "或换用已开通授权码模式的应用。",
+ file=sys.stderr,
+ )
+ sys.exit(1)
+
+
+if __name__ == "__main__":
+ main()
+
--- /dev/null
+#!/usr/bin/env python3
+# """
+# openC - 获取二维码(oauth/api/qrcode/generate)接口验证脚本
+
+# 接口:
+# POST https://open.iov.changan.com.cn/oauth/api/qrcode/generate
+# Content-Type:
+# application/x-www-form-urlencoded
+
+# v1 入参(与截图一致):
+# client_id
+# device_id
+# nonce
+# size
+# state
+# timestamp (截图为毫秒 13 位)
+# appKey
+# appCode
+# sign (本脚本默认使用你截图里的 sign;如需重新计算可再扩展)
+
+# 使用:
+# cd D:\log\usr
+# python qrcode_generate_v1_test.py
+# 或覆盖参数:
+# python qrcode_generate_v1_test.py --device_id xxx --nonce WYYL --sign ABCD...
+# """
+
+import argparse
+import hashlib
+import random
+import ssl
+import string
+import sys
+import time
+import urllib.request
+import urllib.error
+from urllib.parse import urlencode
+
+SERVER = "https://open.iov.changan.com.cn"
+API_PATH = "/oauth/api/qrcode/generate"
+
+# ====== 默认使用你截图里的参数(timestamp/sign 默认改为运行时生成) ======
+DEFAULT_CLIENT_ID = "b235afd313004785bfde580c188c47bb"
+DEFAULT_DEVICE_ID = "8c046d6f4ed0ec77"
+DEFAULT_NONCE = "WYYL"
+DEFAULT_SIZE = "L"
+DEFAULT_STATE = "OPPOWATCH"
+DEFAULT_APP_KEY = "YjIzNWFmZDMxMzAwNDc4NQ=="#"YbYwUsnVXZsb61pTpMy4zg=="
+DEFAULT_APP_CODE = "usercenter"
+
+
+def sha256_hex_upper(s: str) -> str:
+ return hashlib.sha256(s.encode("utf-8")).hexdigest().upper()
+
+
+def build_v1_sign_source_java_like(params: dict) -> str:
+ """
+ 对齐 d:\\log\\usr\\SignUtil.java 的签名拼串方式:
+ - 参数放入 TreeMap(按 key ASCII 升序)
+ - 跳过 key 为空 或 key == 'sign'
+ - 拼接:key=value& (注意:末尾保留 '&')
+ - 不做 URL 编码
+ """
+ items = []
+ for k, v in params.items():
+ if k is None:
+ continue
+ ks = str(k).strip()
+ if not ks or ks == "sign":
+ continue
+ vs = "" if v is None else str(v)
+ items.append((ks, vs))
+
+ items.sort(key=lambda x: x[0]) # TreeMap by key
+ return "".join([f"{k}={v}&" for k, v in items])
+
+
+def main():
+ p = argparse.ArgumentParser(description="openC qrcode generate test")
+ p.add_argument("--client_id", default=DEFAULT_CLIENT_ID)
+ p.add_argument("--device_id", default=DEFAULT_DEVICE_ID)
+ p.add_argument("--nonce", default=DEFAULT_NONCE, help="随机串;不传用默认 WYYL")
+ p.add_argument("--size", default=DEFAULT_SIZE)
+ p.add_argument("--state", default=DEFAULT_STATE)
+ p.add_argument(
+ "--timestamp",
+ default=None,
+ help="timestamp(毫秒13位);不传则运行时实时生成",
+ )
+ p.add_argument("--appKey", default=DEFAULT_APP_KEY)
+ p.add_argument("--appCode", default=DEFAULT_APP_CODE)
+ p.add_argument(
+ "--exclude-appCode",
+ action="store_true",
+ help="签名时不包含 appCode(如后端未参与签名可打开)",
+ )
+ p.add_argument("--insecure", action="store_true", help="跳过 HTTPS 证书校验(仅测试)")
+ p.add_argument("--timeout", type=float, default=30.0)
+ args = p.parse_args()
+
+ url = SERVER + API_PATH
+
+ timestamp_ms = args.timestamp or str(int(time.time() * 1000))
+
+ data = {
+ "client_id": args.client_id,
+ "device_id": args.device_id,
+ "nonce": args.nonce,
+ "size": args.size,
+ "state": args.state,
+ "timestamp": timestamp_ms,
+ "appKey": args.appKey,
+ "appCode": args.appCode,
+ }
+ sign_params = dict(data)
+ if args.exclude_appCode:
+ sign_params.pop("appCode", None)
+ sign_source = build_v1_sign_source_java_like(sign_params)
+ sign = sha256_hex_upper(sign_source)
+ data["sign"] = sign
+
+ headers = {"Content-Type": "application/x-www-form-urlencoded"}
+ body = urlencode(data).encode("utf-8")
+
+ print("========== 请求报文 ==========")
+ print("POST", API_PATH)
+ for k, v in headers.items():
+ print(f"{k}: {v}")
+ print()
+ print(body.decode("utf-8", errors="replace"))
+ print()
+ print(">>> v1 sign_source (before sha256, sorted)")
+ print(sign_source)
+ print(f">>> sign: {sign}")
+ print("==============================")
+
+ ctx = ssl.create_default_context()
+ if args.insecure:
+ ctx.check_hostname = False
+ ctx.verify_mode = ssl.CERT_NONE
+
+ req = urllib.request.Request(url, data=body, headers=headers, method="POST")
+ try:
+ with urllib.request.urlopen(req, timeout=args.timeout, context=ctx) as r:
+ status = r.getcode()
+ resp_headers = dict(r.headers)
+ resp_body = r.read()
+ print("========== 响应报文 ==========")
+ print(f"HTTP/1.1 {status} {r.reason}")
+ for k, v in resp_headers.items():
+ print(f"{k}: {v}")
+ print()
+ content_type = (resp_headers.get("Content-Type") or resp_headers.get("content-type") or "").lower()
+ qrcode_id = resp_headers.get("qrcode_id") or resp_headers.get("qrcode-id") or ""
+ if qrcode_id:
+ # 让下游脚本可稳定解析
+ print(f"qrcode_id: {qrcode_id}")
+ if content_type.startswith("image/png"):
+ suffix = qrcode_id if qrcode_id else timestamp_ms
+ out_name = f"qrcode_{suffix}.png"
+ with open(out_name, "wb") as f:
+ f.write(resp_body)
+ print(f"[saved] {out_name}")
+ else:
+ try:
+ print(resp_body.decode("utf-8"))
+ except Exception:
+ print(resp_body)
+ print("==============================")
+ except urllib.error.HTTPError as e:
+ err_body = e.read()
+ print("========== 响应报文(HTTPError) ==========", file=sys.stderr)
+ print(f"HTTP/1.1 {e.code} {e.reason}", file=sys.stderr)
+ for k, v in e.headers.items():
+ print(f"{k}: {v}", file=sys.stderr)
+ print(file=sys.stderr)
+ try:
+ print(err_body.decode("utf-8", errors="replace"), file=sys.stderr)
+ except Exception:
+ print(err_body, file=sys.stderr)
+ print("==========================================", file=sys.stderr)
+ sys.exit(1)
+ except urllib.error.URLError as e:
+ print(f"请求失败: {e.reason}", file=sys.stderr)
+ sys.exit(1)
+ except Exception as e:
+ print(f"错误: {e}", file=sys.stderr)
+ sys.exit(1)
+
+
+if __name__ == "__main__":
+ main()
+
--- /dev/null
+#!/usr/bin/env python3
+"""
+openC - 查询二维码状态(getQrcodeStatusNoBackend)测试脚本
+
+流程:
+1) 先调用上一脚本生成二维码:
+ python .\\qrcode_generate_v1_test.py --exclude-appCode
+ 并从输出中解析响应头里的 qrcode_id
+2) 再调用接口:
+ GET https://open.iov.changan.com.cn/oauth/api/qrcode/getQrcodeStatusNoBackend
+ 参数(按你截图):
+ nonce、timestamp(秒)、qrcodeId、sign
+
+签名方式:参考 d:\\log\\usr\\SignUtil.java 的 v1 规则
+- TreeMap 按 key ASCII 升序
+- 拼 key=value&(末尾保留 &)
+- SHA256 后转大写
+
+运行:
+ cd D:\\log\\usr
+ python qrcode_status_no_backend_v1_test.py
+"""
+
+import argparse
+import hashlib
+import re
+import ssl
+import subprocess
+import sys
+import time
+import os
+from urllib.parse import urlencode
+import urllib.request
+import urllib.error
+
+
+SERVER = "open.iov.changan.com.cn"
+STATUS_PATH = "/oauth/api/qrcode/getQrcodeStatusNoBackend"
+
+# 与生成二维码脚本保持一致(作为 appKey 默认值;若接口不需要,可用 --no-appKey)
+DEFAULT_APP_KEY = "YjIzNWFmZDMxMzAwNDc4NQ=="
+
+
+def sha256_hex_upper(s: str) -> str:
+ return hashlib.sha256(s.encode("utf-8")).hexdigest().upper()
+
+
+def build_v1_sign_source_java_like(params: dict) -> str:
+ items = []
+ for k, v in params.items():
+ if k is None:
+ continue
+ ks = str(k).strip()
+ if not ks or ks == "sign":
+ continue
+ vs = "" if v is None else str(v)
+ items.append((ks, vs))
+ items.sort(key=lambda x: x[0])
+ return "".join([f"{k}={v}&" for k, v in items])
+
+
+def run_generate_and_get_qrcode_id(timeout: float) -> str:
+ cmd = [sys.executable, ".\\qrcode_generate_v1_test.py", "--exclude-appCode"]
+ # 确保在脚本所在目录执行,避免相对路径问题
+ cwd = os.path.dirname(os.path.abspath(__file__))
+ p = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout, cwd=cwd)
+ out = (p.stdout or "") + "\n" + (p.stderr or "")
+ # 更宽松地提取:只要输出中出现 qrcode_id/qrcode-id 就抓取
+ m = re.search(r"(?is)qrcode[_-]?id\\s*:\\s*([0-9a-f]{16,})", out)
+ if not m:
+ # 兜底:从保存文件名中提取(例如:[saved] qrcode_<id>.png)
+ m2 = re.search(r"(?is)qrcode_([0-9a-f]{16,})\\.png", out)
+ if m2:
+ return m2.group(1)
+
+ # 打印子进程输出帮助定位
+ raise RuntimeError(
+ "未在生成二维码输出中找到 qrcode_id。\n"
+ "=== generate stdout/stderr begin ===\n"
+ f"{out}\n"
+ "=== generate stdout/stderr end ===\n"
+ "请确认生成脚本输出包含 `qrcode_id: ...` 或 `[saved] qrcode_<id>.png`。"
+ )
+ return m.group(1)
+
+
+def main():
+ ap = argparse.ArgumentParser(description="qrcode getQrcodeStatusNoBackend v1 test")
+ ap.add_argument("--timeout", type=float, default=30.0, help="超时秒数(含生成二维码+查询)")
+ ap.add_argument("--insecure", action="store_true", help="跳过 HTTPS 证书校验(仅测试)")
+ ap.add_argument("--nonce", default="WYYL", help="nonce(默认 WYYL)")
+ ap.add_argument("--timestamp", default=None, help="timestamp(秒);不传则取当前 UNIX 秒")
+ ap.add_argument("--appKey", default=DEFAULT_APP_KEY, help="参与签名的 appKey(默认与生成脚本一致)")
+ ap.add_argument("--no-appKey", action="store_true", help="不在请求参数和签名中包含 appKey")
+ ap.add_argument("--qrcodeId", default=None, help="手动指定 qrcodeId(指定后不再调用生成脚本)")
+ ap.add_argument("--interval", type=float, default=10.0, help="轮询间隔秒(默认10s)")
+ ap.add_argument("--max-wait", type=float, default=600.0, help="最大轮询总时长秒(默认600s)")
+ args = ap.parse_args()
+
+ qrcode_id = args.qrcodeId or run_generate_and_get_qrcode_id(timeout=args.timeout)
+ headers = {"Content-Type": "application/x-www-form-urlencoded"}
+ print(">>> start polling qrcode status")
+ print(">>> qrcode_id:", qrcode_id)
+ print(f">>> interval={args.interval}s max_wait={args.max_wait}s (Ctrl+C 可停止)")
+ print()
+
+ ctx = ssl.create_default_context()
+ if args.insecure:
+ ctx.check_hostname = False
+ ctx.verify_mode = ssl.CERT_NONE
+
+ start = time.time()
+ attempt = 0
+ while True:
+ attempt += 1
+ now = time.time()
+ if now - start > args.max_wait:
+ print(f">>> 超时:已轮询 {attempt-1} 次,超过 max_wait={args.max_wait}s")
+ sys.exit(2)
+
+ ts = args.timestamp or str(int(time.time()))
+ params = {
+ "nonce": args.nonce,
+ "timestamp": ts,
+ "qrcodeId": qrcode_id,
+ }
+ if not args.no_appKey:
+ params["appKey"] = args.appKey
+
+ sign_source = build_v1_sign_source_java_like(params)
+ sign = sha256_hex_upper(sign_source)
+ params["sign"] = sign
+
+ query = urlencode(params)
+ url = f"https://{SERVER}{STATUS_PATH}?{query}"
+
+ print(f"========== 第 {attempt} 次查询 ==========")
+ print(f"GET {STATUS_PATH}?{query} HTTP/1.1")
+ print(f"Host: {SERVER}")
+ for k, v in headers.items():
+ print(f"{k}: {v}")
+ print()
+ print(">>> v1 sign_source")
+ print(sign_source)
+ print(">>> sign:", sign)
+ print()
+
+ try:
+ req = urllib.request.Request(url, headers=headers, method="GET")
+ with urllib.request.urlopen(req, timeout=args.timeout, context=ctx) as r:
+ status = r.getcode()
+ resp_headers = dict(r.headers)
+ body = r.read()
+ text = body.decode("utf-8", errors="replace")
+ print("========== 响应 ==========")
+ print(f"HTTP/1.1 {status}")
+ for k, v in resp_headers.items():
+ print(f"{k}: {v}")
+ print()
+ print(text)
+ print("==========================")
+
+ # 解析是否成功(截图示例:data 是一个 JSON 字符串,包含 result/code)
+ try:
+ import json
+
+ j = json.loads(text)
+ data = j.get("data")
+ inner = None
+ if isinstance(data, str):
+ try:
+ inner = json.loads(data)
+ except Exception:
+ inner = None
+ result = inner.get("result") if isinstance(inner, dict) else None
+ if result == "authorized":
+ print(">>> 成功:result=authorized,停止轮询")
+ return
+ except Exception:
+ pass
+ except KeyboardInterrupt:
+ print("\n>>> 已手动停止轮询")
+ return
+ except urllib.error.HTTPError as e:
+ err_body = e.read()
+ print("HTTPError:", e.code, e.reason, file=sys.stderr)
+ print(err_body.decode("utf-8", errors="replace"), file=sys.stderr)
+ except Exception as e:
+ print(f"请求失败: {e}", file=sys.stderr)
+
+ time.sleep(args.interval)
+
+
+if __name__ == "__main__":
+ main()
+
--- /dev/null
+000100010290007781c95a09000000002f88b7c0899f3b100069dde0e715eafc5f6f3acd849c326a9f3e0800000000000000009f057b0069dde0e715eafc5f6f3acd849c326a0000002f88b7c08970a26f2301c3b1dd0219b5204c53354132444b453053413230333233362463303636616433622d346336302d343563612d616430652d32633830376631633863396302d0a3097707efc21de3abc3c1c9dc6be8c8fb992ad388184a2776e982da555c8e73200000000000000000000000000000000000000000000000000000000000000000
--- /dev/null
+/* 210 bytes from icce_auth_fw_golden.hex; regen: python3 gen_icce_auth_fw_golden.py */
+static const uint8_t k_expected_fw_tlv_auth_payload[] = {
+ 0x00, 0x01, 0x00, 0x01, 0x02, 0x90, 0x00, 0x77, 0x81, 0xc8, 0x5a, 0x08,
+ 0x00, 0x00, 0x00, 0x2f, 0x88, 0xb7, 0xc0, 0x89, 0x9f, 0x3b, 0x10, 0x00,
+ 0x69, 0xdd, 0xe0, 0xe7, 0x15, 0xea, 0xfc, 0x5f, 0x6f, 0x3a, 0xcd, 0x84,
+ 0x9c, 0x32, 0x6a, 0x9f, 0x3e, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x9f, 0x05, 0x7b, 0x00, 0x69, 0xdd, 0xe0, 0xe7, 0x15, 0xea,
+ 0xfc, 0x5f, 0x6f, 0x3a, 0xcd, 0x84, 0x9c, 0x32, 0x6a, 0x00, 0x00, 0x00,
+ 0x2f, 0x88, 0xb7, 0xc0, 0x89, 0x70, 0xa2, 0x6f, 0x23, 0x01, 0xc3, 0xb1,
+ 0xdd, 0x02, 0x19, 0xb5, 0x20, 0x4c, 0x53, 0x35, 0x41, 0x32, 0x44, 0x4b,
+ 0x45, 0x30, 0x53, 0x41, 0x32, 0x30, 0x33, 0x32, 0x33, 0x36, 0x24, 0x63,
+ 0x30, 0x36, 0x36, 0x61, 0x64, 0x33, 0x62, 0x2d, 0x34, 0x63, 0x36, 0x30,
+ 0x2d, 0x34, 0x35, 0x63, 0x61, 0x2d, 0x61, 0x64, 0x30, 0x65, 0x2d, 0x32,
+ 0x63, 0x38, 0x30, 0x37, 0x66, 0x31, 0x63, 0x38, 0x63, 0x39, 0x63, 0x02,
+ 0xd0, 0xa3, 0x09, 0x77, 0x07, 0xef, 0xc2, 0x1d, 0xe3, 0xab, 0xc3, 0xc1,
+ 0xc9, 0xdc, 0x6b, 0xe8, 0xc8, 0xfb, 0x99, 0x2a, 0xd3, 0x88, 0x18, 0x4a,
+ 0x27, 0x76, 0xe9, 0x82, 0xda, 0x55, 0x5c, 0x8e, 0x73, 0x20, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+#define K_EXPECTED_FW_TLV_AUTH_PAYLOAD_LEN ((uint16_t)210u)
--- /dev/null
+/*
+ * 认证响应 Payload(仅 message_id/command_id 之后 TLV 段)自测:
+ * - icce_tlv_build 与 bleICCE.c:769-813 逐行一致(修改时请同步两处);
+ * - 组包顺序与 icce_auth_send_sync_response() 一致:Status(0x00) + 01(90 00) + 77(inner);
+ * inner:5A(CardSEID 8B) + 9F3B + 9F3E + 9F05 + 73(本测使用 32B 全 0 密文占位).
+ *
+ * 金样由同目录 gen_icce_auth_fw_golden.py 生成(8B SEID 与 bleICCE.c 演示数据一致;73 为占位非实网密文).
+ *
+ * 编译: make -C code/sdk/zhihui/ChangAan icce_auth_payload_selftest && ./icce_auth_payload_selftest
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "icce_auth_fw_golden_data.inc"
+
+#define ICCE_LENGTH_SHORT_FORM_MAX 0x7FU
+#define ICCE_LENGTH_INDICATOR_ONE_BYTE 0x81U
+
+#define ICCE_TAG_STATUS 0x00U
+#define ICCE_TAG_MSG_CMD_ID_1 0x01U
+#define ICCE_TAG_RESP_TEMPLATE 0x77U
+#define ICCE_TAG_CARD_SEID 0x5AU
+#define ICCE_TAG_9F3B_CARD_ID 0x9F3BU
+#define ICCE_TAG_9F3E_CARD_RND 0x9F3EU
+#define ICCE_TAG_9F05_CARD_INFO1 0x9F05U
+#define ICCE_TAG_ICCE_VAR_CIPHER 0x73U
+
+#define ICCE_TAG_LEN_CARD_SEID 8U
+#define ICCE_TAG_LEN_CARD_ID 16U
+#define ICCE_TAG_LEN_CARD_RND 8U
+#define ICCE_CARD_INFO1_TEST_LEN 123U
+
+/* 与 bleICCE.c: icce_tlv_build 同步 */
+static uint16_t icce_tlv_build(uint8_t *dst, uint16_t dst_cap, uint16_t tag_number,
+ const uint8_t *value, uint16_t value_len)
+{
+ uint16_t off = 0;
+ if (dst == NULL) {
+ return 0;
+ }
+ if (tag_number <= 0xFFU) {
+ if (dst_cap < 1) {
+ return 0;
+ }
+ dst[off++] = (uint8_t)tag_number;
+ } else {
+ if (dst_cap < 2) {
+ return 0;
+ }
+ dst[off++] = (uint8_t)((tag_number >> 8) & 0xFFU);
+ dst[off++] = (uint8_t)(tag_number & 0xFFU);
+ }
+
+ if (value_len <= ICCE_LENGTH_SHORT_FORM_MAX) {
+ if (dst_cap < off + 1U) {
+ return 0;
+ }
+ dst[off++] = (uint8_t)value_len;
+ } else if (value_len <= 0xFFU) {
+ if (dst_cap < off + 2U) {
+ return 0;
+ }
+ dst[off++] = ICCE_LENGTH_INDICATOR_ONE_BYTE;
+ dst[off++] = (uint8_t)value_len;
+ } else {
+ return 0;
+ }
+
+ if (value_len > 0) {
+ if (value == NULL || dst_cap < off + value_len) {
+ return 0;
+ }
+ memcpy(dst + off, value, value_len);
+ off = (uint16_t)(off + value_len);
+ }
+ return off;
+}
+
+static int test_tlv_unit_vectors(void)
+{
+ uint8_t buf[32];
+ uint16_t n;
+
+ n = icce_tlv_build(buf, sizeof(buf), 0x00U, (const uint8_t *)"\xab", 1U);
+ if (n != 3U || buf[0] != 0x00U || buf[1] != 0x01U || buf[2] != 0xABU) {
+ printf("FAIL: tlv tag 00\n");
+ return -1;
+ }
+
+ n = icce_tlv_build(buf, sizeof(buf), ICCE_TAG_9F3B_CARD_ID,
+ (const uint8_t *)"1234567890123456", ICCE_TAG_LEN_CARD_ID);
+ if (n != (uint16_t)(2U + 1U + ICCE_TAG_LEN_CARD_ID) || buf[0] != 0x9FU || buf[1] != 0x3BU) {
+ printf("FAIL: tlv 9F3B\n");
+ return -1;
+ }
+
+ /* 长长度 0x81 LL(value 长 128) */
+ {
+ uint8_t v[128];
+ uint8_t big[256];
+ memset(v, 0x5AU, sizeof(v));
+ n = icce_tlv_build(big, sizeof(big), 0x77U, v, 128U);
+ if (n != (uint16_t)(1U + 2U + 128U) || big[1] != ICCE_LENGTH_INDICATOR_ONE_BYTE || big[2] != 128U) {
+ printf("FAIL: tlv long length\n");
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+static int build_fw_auth_payload_like_bleICCE(uint8_t *out, uint16_t cap, uint16_t *out_len)
+{
+ static const uint8_t g_seid[ICCE_TAG_LEN_CARD_SEID] = {
+ 0x00, 0x00, 0x00, 0x2f, 0x88, 0xb7, 0xc0, 0x89,
+ };
+ static const uint8_t g_card_id[ICCE_TAG_LEN_CARD_ID] = {
+ 0x00, 0x69, 0xdd, 0xe0, 0xe7, 0x15, 0xea, 0xfc,
+ 0x5f, 0x6f, 0x3a, 0xcd, 0x84, 0x9c, 0x32, 0x6a,
+ };
+ static const uint8_t g_card_info1[ICCE_CARD_INFO1_TEST_LEN] = {
+ 0x00, 0x69, 0xdd, 0xe0, 0xe7, 0x15, 0xea, 0xfc, 0x5f, 0x6f, 0x3a, 0xcd, 0x84, 0x9c, 0x32, 0x6a,
+ 0x00, 0x00, 0x00, 0x2f, 0x88, 0xb7, 0xc0, 0x89, 0x70, 0xa2, 0x6f, 0x23, 0x01, 0xc3, 0xb1, 0xdd,
+ 0x02, 0x19, 0xb5, 0x20, 0x4c, 0x53, 0x35, 0x41, 0x32, 0x44, 0x4b, 0x45, 0x30, 0x53, 0x41, 0x32,
+ 0x30, 0x33, 0x32, 0x33, 0x36, 0x24, 0x63, 0x30, 0x36, 0x36, 0x61, 0x64, 0x33, 0x62, 0x2d, 0x34,
+ 0x63, 0x36, 0x30, 0x2d, 0x34, 0x35, 0x63, 0x61, 0x2d, 0x61, 0x64, 0x30, 0x65, 0x2d, 0x32, 0x63,
+ 0x38, 0x30, 0x37, 0x66, 0x31, 0x63, 0x38, 0x63, 0x39, 0x63, 0x02, 0xd0, 0xa3, 0x09, 0x77, 0x07,
+ 0xef, 0xc2, 0x1d, 0xe3, 0xab, 0xc3, 0xc1, 0xc9, 0xdc, 0x6b, 0xe8, 0xc8, 0xfb, 0x99, 0x2a, 0xd3,
+ 0x88, 0x18, 0x4a, 0x27, 0x76, 0xe9, 0x82, 0xda, 0x55, 0x5c, 0x8e,
+ };
+ uint8_t card_rnd[ICCE_TAG_LEN_CARD_RND];
+ uint8_t inner[400];
+ uint8_t apdu_ok[2] = { 0x90, 0x00 };
+ uint8_t status_ok = 0x00;
+ uint8_t cipher73[32];
+ uint16_t in = 0;
+ uint16_t n;
+ uint16_t p = 0;
+
+ memset(card_rnd, 0, sizeof(card_rnd));
+ memset(cipher73, 0, sizeof(cipher73));
+
+ n = icce_tlv_build(inner + in, (uint16_t)(sizeof(inner) - in), ICCE_TAG_CARD_SEID, g_seid, ICCE_TAG_LEN_CARD_SEID);
+ if (n == 0) {
+ return -1;
+ }
+ in = (uint16_t)(in + n);
+ n = icce_tlv_build(inner + in, (uint16_t)(sizeof(inner) - in), ICCE_TAG_9F3B_CARD_ID,
+ g_card_id, ICCE_TAG_LEN_CARD_ID);
+ if (n == 0) {
+ return -1;
+ }
+ in = (uint16_t)(in + n);
+ n = icce_tlv_build(inner + in, (uint16_t)(sizeof(inner) - in), ICCE_TAG_9F3E_CARD_RND,
+ card_rnd, ICCE_TAG_LEN_CARD_RND);
+ if (n == 0) {
+ return -1;
+ }
+ in = (uint16_t)(in + n);
+ n = icce_tlv_build(inner + in, (uint16_t)(sizeof(inner) - in), ICCE_TAG_9F05_CARD_INFO1,
+ g_card_info1, ICCE_CARD_INFO1_TEST_LEN);
+ if (n == 0) {
+ return -1;
+ }
+ in = (uint16_t)(in + n);
+ n = icce_tlv_build(inner + in, (uint16_t)(sizeof(inner) - in), ICCE_TAG_ICCE_VAR_CIPHER,
+ cipher73, (uint16_t)sizeof(cipher73));
+ if (n == 0) {
+ return -1;
+ }
+ in = (uint16_t)(in + n);
+
+ n = icce_tlv_build(out + p, (uint16_t)(cap - p), ICCE_TAG_STATUS, &status_ok, 1U);
+ if (n == 0) {
+ return -1;
+ }
+ p = (uint16_t)(p + n);
+ n = icce_tlv_build(out + p, (uint16_t)(cap - p), ICCE_TAG_MSG_CMD_ID_1, apdu_ok, (uint16_t)sizeof(apdu_ok));
+ if (n == 0) {
+ return -1;
+ }
+ p = (uint16_t)(p + n);
+ n = icce_tlv_build(out + p, (uint16_t)(cap - p), ICCE_TAG_RESP_TEMPLATE, inner, in);
+ if (n == 0) {
+ return -1;
+ }
+ p = (uint16_t)(p + n);
+ *out_len = p;
+ return 0;
+}
+
+int main(void)
+{
+ uint8_t got[320];
+ uint16_t glen = 0;
+
+ if (test_tlv_unit_vectors() != 0) {
+ return 1;
+ }
+
+ if (build_fw_auth_payload_like_bleICCE(got, (uint16_t)sizeof(got), &glen) != 0) {
+ printf("FAIL: build\n");
+ return 1;
+ }
+
+ if (glen != K_EXPECTED_FW_TLV_AUTH_PAYLOAD_LEN) {
+ printf("FAIL: length got=%u expected=%u (golden stale or build drift)\n",
+ (unsigned)glen, (unsigned)K_EXPECTED_FW_TLV_AUTH_PAYLOAD_LEN);
+ return 1;
+ }
+
+ if (memcmp(got, k_expected_fw_tlv_auth_payload, (size_t)glen) != 0) {
+ size_t i;
+ printf("FAIL: payload mismatch at firmware-style auth TLV build\n");
+ for (i = 0; i < (size_t)glen && i < 32U; i++) {
+ if (got[i] != k_expected_fw_tlv_auth_payload[i]) {
+ printf(" first diff offset %u got %02x exp %02x\n", (unsigned)i, got[i],
+ k_expected_fw_tlv_auth_payload[i]);
+ break;
+ }
+ }
+ return 1;
+ }
+
+ printf("PASS: icce_tlv_build + icce_auth_send_sync_response TLV layout (%u bytes, 73=32x0 selftest)\n",
+ (unsigned)glen);
+ printf(" (real firmware fills 0x73 via icce_auth_encrypt_73_inner; see icce_session_key_selftest for SessionKey)\n");
+ return 0;
+}
--- /dev/null
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+ICCE 认证响应 Payload 拼包与校验(对齐 bleICCE.c icce_auth_send_sync_response,并支持抓包形态):
+
+1) 固件 bleICCE.c: 三个顶级 TLV — Status(00) + APDU(01: 90 00) + 响应模板(77, inner)
+
+2) 抓包常见: 两个顶级 TLV — Status(常为 01) + APDU(01),且 01 的 value = **完整 77 TLV** + 常见尾随 **90 00**
+ (与固件「独立 01=90 00 + 77」等价布局不同;车端常把状态字接在 77 编码后共占 01 value)
+
+inner 顺序: 5A(CardSEID) + 9F3B(CardID) + 9F3E(CardRnd) + 9F05(CardInfo) + 73(密文)
+
+用法:
+ python icce_auth_response_payload_build.py
+ python icce_auth_response_payload_build.py --ref "00010001...."
+
+依赖: 无(纯标准库)
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+
+ICCE_LENGTH_SHORT_FORM_MAX = 0x7F
+ICCE_LENGTH_INDICATOR_ONE_FOLLOWING_BYTE = 0x81
+
+TAG_STATUS = 0x00
+TAG_APDU = 0x01
+TAG_77 = 0x77
+TAG_5A = 0x5A
+TAG_9F3B = 0x9F3B
+TAG_9F3E = 0x9F3E
+TAG_9F05 = 0x9F05
+TAG_73 = 0x73
+
+
+def normalize_hex(s: str) -> str:
+ return re.sub(r"[^0-9a-fA-F]", "", s)
+
+
+def tlv_build(tag_number: int, value: bytes) -> bytes:
+ out = bytearray()
+ if tag_number <= 0xFF:
+ out.append(tag_number)
+ else:
+ out.append((tag_number >> 8) & 0xFF)
+ out.append(tag_number & 0xFF)
+ vl = len(value)
+ if vl <= ICCE_LENGTH_SHORT_FORM_MAX:
+ out.append(vl)
+ elif vl <= 0xFF:
+ out.append(ICCE_LENGTH_INDICATOR_ONE_FOLLOWING_BYTE)
+ out.append(vl)
+ else:
+ raise ValueError("length > 255 not supported")
+ out.extend(value)
+ return bytes(out)
+
+
+def tlv_parse_one(buf: bytes, off: int = 0) -> tuple[int, bytes, int] | None:
+ """返回 (tag_number, value, total_bytes)."""
+ if off + 2 > len(buf):
+ return None
+ b0 = buf[off]
+ if (b0 & 0x1F) != 0x1F:
+ tag = b0
+ tlen = 1
+ else:
+ if off + 3 > len(buf):
+ return None
+ tag = (buf[off] << 8) | buf[off + 1]
+ tlen = 2
+ lb = buf[off + tlen]
+ if (lb & 0x80) == 0:
+ vlen = lb & 0x7F
+ llen = 1
+ elif lb == ICCE_LENGTH_INDICATOR_ONE_FOLLOWING_BYTE:
+ if off + tlen + 2 > len(buf):
+ return None
+ vlen = buf[off + tlen + 1]
+ llen = 2
+ else:
+ return None
+ vstart = off + tlen + llen
+ if vstart + vlen > len(buf):
+ return None
+ return tag, buf[vstart : vstart + vlen], tlen + llen + vlen
+
+
+def extract_inner_from_apdu_value(v1: bytes) -> bytes:
+ """从 Tag 01 的 value 中取出 77 的 inner(5A..73 串联字节)。"""
+ if len(v1) >= 3 and v1[0] == 0x90 and v1[1] == 0x00 and v1[2] == 0x77:
+ r77 = tlv_parse_one(v1, 2)
+ if r77 is None:
+ raise ValueError("after 90 00 expected 77 TLV")
+ tag77, inner, _ = r77
+ if tag77 != 0x77:
+ raise ValueError("expected tag 77")
+ return inner
+ r = tlv_parse_one(v1, 0)
+ if r is not None and r[0] == 0x77:
+ return r[1]
+ raise ValueError(f"cannot parse 77 from APDU value, head={v1[:8].hex()}")
+
+
+def apdu_value_tail_after_first_77(v1: bytes) -> bytes:
+ """Tag 01 的 value 中,紧随第一个完整 77 TLV 之后的字节(常见为 R-APDU 状态字 90 00)。"""
+ r = tlv_parse_one(v1, 0)
+ if r is None or r[0] != 0x77:
+ return b""
+ _tg, _inner, total = r
+ return v1[total:]
+
+
+def build_inner_tlvs(
+ card_seid: bytes,
+ card_id: bytes,
+ card_rnd: bytes,
+ card_info1: bytes,
+ cipher_73: bytes,
+) -> bytes:
+ """5A + 9F3B + 9F3E + 9F05 + 73(不含外层 77)。"""
+ if len(card_seid) != 16:
+ raise ValueError("CardSEID per capture uses len 0x10 (16 bytes)")
+ if len(card_id) != 16 or len(card_rnd) != 8:
+ raise ValueError("CardID 16B, CardRnd 8B")
+ inner = bytearray()
+ inner.extend(tlv_build(TAG_5A, card_seid))
+ inner.extend(tlv_build(TAG_9F3B, card_id))
+ inner.extend(tlv_build(TAG_9F3E, card_rnd))
+ inner.extend(tlv_build(TAG_9F05, card_info1))
+ inner.extend(tlv_build(TAG_73, cipher_73))
+ return bytes(inner)
+
+
+def build_auth_response_payload(
+ card_seid: bytes,
+ card_id: bytes,
+ card_rnd: bytes,
+ card_info1: bytes,
+ cipher_73: bytes,
+) -> bytes:
+ """固件 bleICCE.c 式:顶级 Status + 01(90 00) + 77(inner),共三个 TLV。"""
+ inner = build_inner_tlvs(card_seid, card_id, card_rnd, card_info1, cipher_73)
+ pl = bytearray()
+ pl.extend(tlv_build(TAG_STATUS, bytes([0x00])))
+ pl.extend(tlv_build(TAG_APDU, bytes([0x90, 0x00])))
+ pl.extend(tlv_build(TAG_77, inner))
+ return bytes(pl)
+
+
+def build_auth_response_payload_capture_two_tlv(
+ card_seid: bytes,
+ card_id: bytes,
+ card_rnd: bytes,
+ card_info1: bytes,
+ cipher_73: bytes,
+ status_byte: int = 0x01,
+ tail_after_77: bytes = b"\x90\x00",
+) -> bytes:
+ """抓包/车端常见式:两个顶级 TLV — Status(status_byte) + 01。
+
+ 01 的 value = 完整 77 TLV + tail_after_77(默认 **90 00**,与 R-APDU 状态字一致;REF 中 81 D5 = 213 = 211+2)。
+
+ 固件 bleICCE 为三独立 TLV(Status + 小 01(90 00) + 77),字节序不同;对齐车端日志用本函数。
+ """
+ inner = build_inner_tlvs(card_seid, card_id, card_rnd, card_info1, cipher_73)
+ tlv77 = tlv_build(TAG_77, inner)
+ apdu_payload = tlv77 + bytes(tail_after_77)
+ pl = bytearray()
+ pl.extend(tlv_build(TAG_STATUS, bytes([status_byte & 0xFF])))
+ pl.extend(tlv_build(TAG_APDU, apdu_payload))
+ return bytes(pl)
+
+
+# 你提供的参考(去掉末尾可能的换行/空格)
+REF_PAYLOAD_DEFAULT = (
+ "0001000181d57781d05a1018fe13ac01140546a1f6a820b9d12d299f3b100069dde0e715eafc5f6f3acd849c326a9f3e08a8c1"
+ "f94537b988259f057b0069dde0e715eafc5f6f3acd849c326a0000002f88b7c08970a26f2301c3b1dd0219b5204c533541324"
+ "44b453053413230333233362463303636616433622d346336302d343563612d616430652d32633830376631633863396302d0"
+ "a3097707efc21de3abc3c1c9dc6be8c8fb992ad388184a2776e982da555c8e73200c254b2b31a9541868602325e024e349"
+ "3f3d2c1de32f29b19a6fd06203f22d809000"
+)
+
+
+def analyze_ref(raw: bytes) -> None:
+ print("=== 参考 payload 结构解析 ===\n")
+ off = 0
+ step = 0
+ while off < len(raw):
+ r = tlv_parse_one(raw, off)
+ if r is None:
+ print(f"[stop] leftover offset={off} len={len(raw)-off}")
+ if off < len(raw):
+ print(f" hex: {raw[off:].hex()}")
+ break
+ tag, value, total = r
+ step += 1
+ lab = {
+ 0x00: "Status",
+ 0x01: "APDU/01",
+ 0x77: "77 template",
+ 0x5A: "5A CardSEID",
+ 0x9F3B: "9F3B CardID",
+ 0x9F3E: "9F3E CardRnd",
+ 0x9F05: "9F05 CardInfo",
+ 0x73: "73 cipher",
+ }.get(tag, f"tag 0x{tag:04x}")
+ print(f"[{step}] @{off:04d} {lab}: tag={tag:04x} val_len={len(value)}")
+ if tag == 0x01:
+ print(f" 01 value len={len(value)} 前8字节: {value[:8].hex()}")
+ if len(value) >= 3 and value[0] == 0x90 and value[1] == 0x00 and value[2] == 0x77:
+ print(" (嵌套: 90 00 || 完整 77 TLV,与固件拆成 01+90 00 / 77 两段等价)")
+ tail = apdu_value_tail_after_first_77(value)
+ if tail:
+ print(f" 第一个 77 之后尾随: {tail.hex()} ({len(tail)}B)")
+ try:
+ inn = extract_inner_from_apdu_value(value)
+ print(f" 解析出 77 inner 长度={len(inn)}")
+ except ValueError as e:
+ print(f" inner 解析: {e}")
+ if tag == 0x77:
+ print(" --- inner of 77 ---")
+ ioff = 0
+ while ioff < len(value):
+ ir = tlv_parse_one(value, ioff)
+ if ir is None:
+ break
+ it, iv, itu = ir
+ ilab = {
+ 0x5A: "5A SEID",
+ 0x9F3B: "9F3B",
+ 0x9F3E: "9F3E",
+ 0x9F05: "9F05",
+ 0x73: "73",
+ }.get(it, "?")
+ print(f" inner @{ioff}: {ilab} len={len(iv)}")
+ ioff += itu
+ off += total
+ print()
+
+
+def main() -> None:
+ ap = argparse.ArgumentParser(description="ICCE 认证响应 payload 拼包与对比")
+ ap.add_argument("--ref", default=REF_PAYLOAD_DEFAULT, help="参考 payload hex")
+ ap.add_argument("--no-build", action="store_true", help="只解析 ref,不拼包")
+ args = ap.parse_args()
+
+ ref_hex = normalize_hex(args.ref)
+ raw_ref = bytes.fromhex(ref_hex)
+ print(f"参考 payload 长度: {len(raw_ref)} 字节\n")
+ analyze_ref(raw_ref)
+
+ p = 0
+ r0 = tlv_parse_one(raw_ref, p)
+ if r0 is None or r0[0] != 0x00:
+ print("expect Status first")
+ return
+ _t0, _v0, u0 = r0
+ p += u0
+ r1 = tlv_parse_one(raw_ref, p)
+ if r1 is None or r1[0] != 0x01:
+ print("expect APDU tag 01")
+ return
+ _t1, v1, u1 = r1
+ p += u1
+
+ inner_77: bytes
+ if len(v1) == 2 and v1 == bytes([0x90, 0x00]):
+ t77, inner_77, _ = tlv_parse_one(raw_ref, p)
+ if t77 != 0x77:
+ print("固件式后应跟 77")
+ return
+ else:
+ try:
+ inner_77 = extract_inner_from_apdu_value(v1)
+ except ValueError as e:
+ print(e)
+ return
+
+ # 从 inner 解析各段用于重拼
+ parts: dict[int, bytes] = {}
+ ioff = 0
+ while ioff < len(inner_77):
+ ir = tlv_parse_one(inner_77, ioff)
+ if ir is None:
+ break
+ tg, vb, ut = ir
+ parts[tg] = vb
+ ioff += ut
+
+ seid = parts.get(0x5A)
+ cid = parts.get(0x9F3B)
+ crnd = parts.get(0x9F3E)
+ cinfo = parts.get(0x9F05)
+ ciph = parts.get(0x73)
+ if not all((seid, cid, crnd, cinfo, ciph)):
+ print("inner 缺少字段", {k: bool(v) for k, v in parts.items()})
+ return
+
+ def first_diff(a: bytes, b: bytes) -> str | None:
+ n = min(len(a), len(b))
+ for i in range(n):
+ if a[i] != b[i]:
+ return f"offset {i}: ref={a[i]:02x} other={b[i]:02x}"
+ if len(a) != len(b):
+ return f"length ref={len(a)} other={len(b)}"
+ return None
+
+ tail_01 = apdu_value_tail_after_first_77(v1)
+ rebuilt_fw = build_auth_response_payload(seid, cid, crnd, cinfo, ciph)
+ st0 = raw_ref[2] if len(raw_ref) >= 3 and raw_ref[0] == 0x00 else 0x01
+ rebuilt_cap = build_auth_response_payload_capture_two_tlv(
+ seid,
+ cid,
+ crnd,
+ cinfo,
+ ciph,
+ status_byte=st0,
+ tail_after_77=tail_01 if tail_01 else b"\x90\x00",
+ )
+
+ # 两 TLV:01 的 value = 90 00 || 完整 77(总长比「仅 77」多 2 字节)
+ inner77_tlv_encoding = tlv_build(0x77, inner_77)
+ nested_01_embeds_90 = tlv_build(TAG_STATUS, bytes([0x00])) + tlv_build(
+ TAG_APDU, bytes([0x90, 0x00]) + inner77_tlv_encoding
+ )
+
+ print("=== 拼包对比 ===\n")
+ print(f"参考长度: {len(raw_ref)} 字节")
+ print(f"固件三 TLV (bleICCE): {len(rebuilt_fw)} 字节")
+ print(f"抓包两 TLV (01=仅77): {len(rebuilt_cap)} 字节")
+ print(f"两 TLV (01=90 00||77): {len(nested_01_embeds_90)} 字节\n")
+
+ if rebuilt_cap == raw_ref:
+ print("RESULT: 与参考 **完全一致**(抓包式:Status + 01,且 01 的 value 仅为完整 77 TLV)。\n")
+ elif rebuilt_fw == raw_ref:
+ print("RESULT: 与参考 **完全一致**(固件式三 TLV:Status(00) + 01(90 00) + 77)。\n")
+ elif nested_01_embeds_90 == raw_ref:
+ print("RESULT: 与参考 **完全一致**(两 TLV:01 value = 90 00||完整77)。\n")
+ else:
+ print("RESULT: 与参考 **不完全一致**。\n")
+ for name, bb in (
+ ("抓包两 TLV", rebuilt_cap),
+ ("固件三 TLV", rebuilt_fw),
+ ("两 TLV 01=90||77", nested_01_embeds_90),
+ ):
+ if (d := first_diff(raw_ref, bb)):
+ print(f" [{name}] {d}")
+ print(
+ " 说明: 你提供的 219B 样本为 Status=01 + 01(81D5)=仅 77…,"
+ "与 bleICCE.c 三 TLV 在 offset 2(Status) 与 offset 3 起(APDU) 均不同。"
+ )
+
+ print("\n抓包式重拼 hex (前 120 字符):")
+ print(rebuilt_cap.hex()[:120], "...")
+ print("\n参考 hex (前 120 字符):")
+ print(ref_hex[:120], "...")
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+模拟 bleICCE.c 对「认证数据 msg/cmd=0x01/0x01」同步请求的响应组帧,并打印响应十六进制。
+
+依赖: pip install pycryptodome
+
+用法:
+ python icce_auth_response_sim.py
+ python icce_auth_response_sim.py --hex "5A003C10..."
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+
+try:
+ from Crypto.Cipher import AES
+except ImportError:
+ print("需要: pip install pycryptodome", file=sys.stderr)
+ sys.exit(1)
+
+# ---------- 与 bleICCE.c / bleICCE.h 一致 ----------
+ICCE_FRAME_SOF = 0x5A
+ICCE_CTRL_FRAGMENT_FULL = 0x00
+ICCE_LENGTH_SHORT_FORM_MAX = 0x7F
+ICCE_LENGTH_INDICATOR_ONE_FOLLOWING_BYTE = 0x81
+
+ICCE_TAG_STATUS = 0x00
+ICCE_TAG_MSG_CMD_ID_1 = 0x01
+ICCE_TAG_RESP_TEMPLATE = 0x77
+ICCE_TAG_CARD_SEID = 0x5A
+ICCE_TAG_9F05_CARD_INFO1 = 0x9F05
+ICCE_TAG_9F3B_CARD_ID = 0x9F3B
+ICCE_TAG_9F3E_CARD_RND = 0x9F3E
+ICCE_TAG_9F36_CARD_ATC = 0x9F36
+ICCE_TAG_9F37_READER_RND = 0x9F37
+ICCE_TAG_9F0C_READER_KEY_PARAM = 0x9F0C
+ICCE_TAG_ICCE_VAR_CIPHER_TEMPLATE = 0x73
+
+ICCE_TAG_LEN_CARD_SEID = 8
+ICCE_TAG_LEN_CARD_ID = 16
+ICCE_TAG_LEN_CARD_ATC = 4
+ICCE_TAG_LEN_READER_RND = 8
+ICCE_TAG_LEN_CARD_RND = 8
+ICCE_TAG_LEN_READER_KEY_PARAM = 16
+
+ICCE_LEN_SESSION_KEY_PLAIN = ICCE_TAG_LEN_READER_RND + ICCE_TAG_LEN_CARD_RND + ICCE_TAG_LEN_READER_KEY_PARAM
+
+ICCE_MSG_AUTH_DATA = 0x01
+ICCE_CMD_AUTH_DATA = 0x01
+
+# 默认 DKey(与 bleICCE.c 联调)
+DKEY_DEFAULT = bytes(
+ [
+ 0x70,
+ 0x32,
+ 0x6E,
+ 0x21,
+ 0xEA,
+ 0xD7,
+ 0x5C,
+ 0x76,
+ 0xD4,
+ 0x67,
+ 0x42,
+ 0xDE,
+ 0x64,
+ 0x4A,
+ 0x2F,
+ 0xC5,
+ ]
+)
+
+# 与默认 DKey 配对的 card info(前 16B CardID;字节 16–23=SEID),与 bleICCE.c g_icce_auth_card_info1 一致
+CARD_INFO1_TEST = bytes.fromhex(
+ "0069dde0e715eafc5f6f3acd849c326a0000002f88b7c08970a26f2301c3b1dd0219b5204c53354132444b45305341323033323336"
+ "2463303636616433622d346336302d343563612d616430652d32633830376631633863396302d0a3097707efc21de3abc3c1c9dc6be8c8fb992ad388184a2776e982da555c8e"
+)
+
+
+def crc16_ccitt(buf: bytes) -> int:
+ crc = 0xFFFF
+ for b in buf:
+ crc ^= b << 8
+ for _ in range(8):
+ if crc & 0x8000:
+ crc = ((crc << 1) ^ 0x1021) & 0xFFFF
+ else:
+ crc = (crc << 1) & 0xFFFF
+ return crc
+
+
+def put_be16(v: int) -> bytes:
+ return bytes([(v >> 8) & 0xFF, v & 0xFF])
+
+
+def iso9797_m2_pad(data: bytes) -> bytes:
+ need = len(data) + 1
+ while need % 16 != 0:
+ need += 1
+ out = bytearray(data)
+ out.append(0x80)
+ while len(out) < need:
+ out.append(0)
+ return bytes(out)
+
+
+def tlv_parse_one(buf: bytes, off: int = 0) -> tuple[int, int, bytes, int] | None:
+ """返回 (tag_number, value_len, value, total_consumed) 或 None。"""
+ if off + 2 > len(buf):
+ return None
+ b0 = buf[off]
+ if (b0 & 0x1F) != 0x1F:
+ tag_number = b0
+ tag_len = 1
+ else:
+ if off + 3 > len(buf):
+ return None
+ tag_number = (buf[off] << 8) | buf[off + 1]
+ tag_len = 2
+ lb = buf[off + tag_len]
+ if (lb & 0x80) == 0:
+ value_len = lb & 0x7F
+ len_len = 1
+ elif lb == ICCE_LENGTH_INDICATOR_ONE_FOLLOWING_BYTE:
+ if off + tag_len + 2 > len(buf):
+ return None
+ value_len = buf[off + tag_len + 1]
+ len_len = 2
+ else:
+ return None
+ vstart = off + tag_len + len_len
+ if vstart + value_len > len(buf):
+ return None
+ value = buf[vstart : vstart + value_len]
+ total = tag_len + len_len + value_len
+ return tag_number, value_len, value, total
+
+
+def tlv_build(tag_number: int, value: bytes) -> bytes:
+ out = bytearray()
+ if tag_number <= 0xFF:
+ out.append(tag_number)
+ else:
+ out.append((tag_number >> 8) & 0xFF)
+ out.append(tag_number & 0xFF)
+ vl = len(value)
+ if vl <= ICCE_LENGTH_SHORT_FORM_MAX:
+ out.append(vl)
+ elif vl <= 0xFF:
+ out.append(ICCE_LENGTH_INDICATOR_ONE_FOLLOWING_BYTE)
+ out.append(vl)
+ else:
+ raise ValueError("value too long for TLV builder")
+ out.extend(value)
+ return bytes(out)
+
+
+def extract_9f37_9f0c_from_payload(payload: bytes) -> tuple[bytes | None, bytes | None]:
+ """从 payload 中解析或搜索 9F37 / 9F0C(兼容嵌套在 01 内且前有 80 CA 00 00 31 前缀)。"""
+ reader_rnd = None
+ key_param = None
+
+ def scan_buf(b: bytes) -> None:
+ nonlocal reader_rnd, key_param
+ pos = 0
+ while pos < len(b):
+ r = tlv_parse_one(b, pos)
+ if r is None:
+ break
+ tag, _vl, val, total = r
+ if tag == ICCE_TAG_9F37_READER_RND and len(val) == ICCE_TAG_LEN_READER_RND:
+ reader_rnd = val
+ if tag == ICCE_TAG_9F0C_READER_KEY_PARAM and len(val) == ICCE_TAG_LEN_READER_KEY_PARAM:
+ key_param = val
+ if tag in (ICCE_TAG_MSG_CMD_ID_1, ICCE_TAG_RESP_TEMPLATE, 0x3C, ICCE_TAG_ICCE_VAR_CIPHER_TEMPLATE):
+ scan_buf(val)
+ pos += total
+
+ scan_buf(payload)
+ if reader_rnd is None or key_param is None:
+ # 子串匹配(嵌套或非标准前缀)
+ i = payload.find(bytes([0x9F, 0x37, 0x08]))
+ if i >= 0 and i + 3 + ICCE_TAG_LEN_READER_RND <= len(payload):
+ reader_rnd = payload[i + 3 : i + 3 + ICCE_TAG_LEN_READER_RND]
+ j = payload.find(bytes([0x9F, 0x0C, 0x10]))
+ if j >= 0 and j + 3 + ICCE_TAG_LEN_READER_KEY_PARAM <= len(payload):
+ key_param = payload[j + 3 : j + 3 + ICCE_TAG_LEN_READER_KEY_PARAM]
+ return reader_rnd, key_param
+
+
+def derive_session_key(
+ dkey: bytes,
+ card_iv: bytes,
+ reader_rnd: bytes,
+ card_rnd: bytes,
+ reader_key_param: bytes,
+) -> bytes:
+ plain = reader_rnd + card_rnd + reader_key_param
+ assert len(plain) == ICCE_LEN_SESSION_KEY_PLAIN
+ padded = iso9797_m2_pad(plain)
+ iv = bytearray(card_iv)
+ cipher = AES.new(dkey, AES.MODE_CBC, iv=bytes(iv))
+ ct = cipher.encrypt(padded)
+ return ct[-16:]
+
+
+def encrypt_73_inner(
+ session_key: bytes,
+ reader_rnd: bytes,
+ card_rnd: bytes,
+ card_atc_le: bytes,
+ reader_rnd_echo: bytes,
+) -> bytes:
+ """0x73:M2( TLV(9F36)||TLV(9F37) ) 再 AES-128-CBC,IV=ReaderRnd||CardRnd。"""
+ inner = tlv_build(ICCE_TAG_9F36_CARD_ATC, card_atc_le) + tlv_build(
+ ICCE_TAG_9F37_READER_RND, reader_rnd_echo
+ )
+ padded = iso9797_m2_pad(inner)
+ iv = bytearray(reader_rnd + card_rnd)
+ cipher = AES.new(session_key, AES.MODE_CBC, iv=bytes(iv))
+ return cipher.encrypt(padded)
+
+
+def generate_local_card_rnd(
+ card_seid: bytes,
+ card_id: bytes,
+ salt: int,
+ atc_counter: int,
+) -> bytes:
+ out = bytearray(ICCE_TAG_LEN_CARD_RND)
+ for i in range(ICCE_TAG_LEN_CARD_RND):
+ out[i] = (
+ card_seid[i % ICCE_TAG_LEN_CARD_SEID]
+ ^ card_id[i]
+ ^ ((salt >> ((i % 4) * 8)) & 0xFF)
+ ^ ((atc_counter >> (i * 4)) & 0xFF)
+ ^ (0x5A + i)
+ ) & 0xFF
+ return bytes(out)
+
+
+def parse_icce_request(raw: bytes) -> tuple[bytes, bytes, int]:
+ """返回 (msg/cmd 后 payload, 头部 ctrl/fsn/msg/cmd 四字节, fsn)。"""
+ if len(raw) < 12 or raw[0] != ICCE_FRAME_SOF:
+ raise ValueError("invalid SOF or too short")
+ length_field = (raw[1] << 8) | raw[2]
+ body_end = 3 + length_field
+ if len(raw) < body_end + 2:
+ raise ValueError("truncated frame")
+ crc_expect = (raw[body_end] << 8) | raw[body_end + 1]
+ crc_calc = crc16_ccitt(raw[:body_end])
+ if crc_calc != crc_expect:
+ raise ValueError(f"CRC mismatch: got {crc_expect:04X}, expect {crc_calc:04X}")
+ ctrl = raw[3]
+ fsn = raw[4]
+ msg = raw[5]
+ cmd = raw[6]
+ payload = raw[7:body_end]
+ return payload, bytes([ctrl, fsn, msg, cmd]), fsn
+
+
+def build_auth_response(
+ reader_rnd_echo: bytes,
+ card_rnd: bytes,
+ card_seid: bytes,
+ card_id: bytes,
+ card_atc_le: bytes,
+ session_key: bytes | None,
+ include_card_info1: bool,
+ fsn: int,
+) -> bytes:
+ inner = bytearray()
+ inner.extend(tlv_build(ICCE_TAG_CARD_SEID, card_seid))
+ inner.extend(tlv_build(ICCE_TAG_9F3B_CARD_ID, card_id))
+ inner.extend(tlv_build(ICCE_TAG_9F3E_CARD_RND, card_rnd))
+ if include_card_info1:
+ inner.extend(tlv_build(ICCE_TAG_9F05_CARD_INFO1, CARD_INFO1_TEST))
+ if session_key is not None:
+ ciph = encrypt_73_inner(session_key, reader_rnd_echo, card_rnd, card_atc_le, reader_rnd_echo)
+ inner.extend(tlv_build(ICCE_TAG_ICCE_VAR_CIPHER_TEMPLATE, ciph))
+
+ pl = bytearray()
+ pl.extend(tlv_build(ICCE_TAG_STATUS, bytes([0x00])))
+ pl.extend(tlv_build(ICCE_TAG_MSG_CMD_ID_1, bytes([0x90, 0x00])))
+ pl.extend(tlv_build(ICCE_TAG_RESP_TEMPLATE, bytes(inner)))
+
+ off = 0
+ frame = bytearray()
+ frame.append(ICCE_FRAME_SOF)
+ len_pos = len(frame)
+ frame.extend(b"\x00\x00")
+ control = ICCE_CTRL_FRAGMENT_FULL
+ frame.append(control)
+ frame.append((fsn + 1) & 0xFF)
+ frame.append(ICCE_MSG_AUTH_DATA)
+ frame.append(ICCE_CMD_AUTH_DATA)
+ frame.extend(pl)
+ len_field = len(frame) - 3
+ frame[len_pos : len_pos + 2] = put_be16(len_field)
+ crc = crc16_ccitt(bytes(frame))
+ frame.extend(put_be16(crc))
+ return bytes(frame)
+
+
+def normalize_hex(s: str) -> str:
+ return re.sub(r"[^0-9a-fA-F]", "", s)
+
+
+DEFAULT_HEX = (
+ "5A003C10000101013680CA0000319F1E10600010012505283300000069259514069F3708F018C99F2F8EDADA"
+ "9F0C1060001001250528330000006925951406FB1B"
+)
+
+
+def main() -> None:
+ ap = argparse.ArgumentParser(description="ICCE 认证请求 → 响应十六进制(对齐 bleICCE.c)")
+ ap.add_argument("--hex", dest="hex_data", default=DEFAULT_HEX, help="请求帧 hex(可含空格)")
+ ap.add_argument("--dkey", default=None, help="DKey hex 32 字符,默认与固件联调一致")
+ ap.add_argument("--no-card-info", action="store_true", help="不组 9F05 Card Info1")
+ ap.add_argument("--card-rnd-salt", type=lambda x: int(x, 0), default=0x3C96A1B5, help="CardRnd 盐(与 g_icce_auth_card_rnd_salt)")
+ ap.add_argument("--atc", type=int, default=0, help="当前 CardATC 计数(小端四字节)")
+ args = ap.parse_args()
+
+ raw = bytes.fromhex(normalize_hex(args.hex_data))
+ payload, _hdr, fsn = parse_icce_request(raw)
+
+ reader_rnd, key_param = extract_9f37_9f0c_from_payload(payload)
+ if reader_rnd is None or key_param is None:
+ print("错误: 未能从 payload 解析 9F37(8B) 与 9F0C(16B)", file=sys.stderr)
+ sys.exit(2)
+
+ dkey = DKEY_DEFAULT if args.dkey is None else bytes.fromhex(normalize_hex(args.dkey))
+ if len(dkey) != 16:
+ print("DKey 须 16 字节", file=sys.stderr)
+ sys.exit(2)
+
+ card_id = CARD_INFO1_TEST[:ICCE_TAG_LEN_CARD_ID]
+ card_seid = CARD_INFO1_TEST[ICCE_TAG_LEN_CARD_ID : ICCE_TAG_LEN_CARD_ID + ICCE_TAG_LEN_CARD_SEID]
+ card_rnd = generate_local_card_rnd(card_seid, card_id, args.card_rnd_salt, args.atc)
+ atc_le = args.atc.to_bytes(4, "little")
+
+ session_key = derive_session_key(dkey, key_param, reader_rnd, card_rnd, key_param)
+
+ resp = build_auth_response(
+ reader_rnd_echo=reader_rnd,
+ card_rnd=card_rnd,
+ card_seid=card_seid,
+ card_id=card_id,
+ card_atc_le=atc_le,
+ session_key=session_key,
+ include_card_info1=not args.no_card_info,
+ fsn=fsn,
+ )
+
+ print("--- 从请求中解析 ---")
+ print(f"ReaderRnd (9F37): {reader_rnd.hex()}")
+ print(f"ReaderKey/CardIV (9F0C): {key_param.hex()}")
+ print(f"SessionKey (派生): {session_key.hex()}")
+ print(f"CardRnd (9F3E 本地): {card_rnd.hex()}")
+ print()
+ print("--- 响应帧 (hex) ---")
+ h = resp.hex()
+ # 每 2 字符一字节,可选空格分组
+ spaced = " ".join(h[i : i + 2] for i in range(0, len(h), 2))
+ print(spaced)
+ print()
+ print("--- 连续 hex(无空格)---")
+ print(h)
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+/*
+ * SessionKey 派生自测:逻辑与 bleICCE.c 中 icce_iso9797_m2_pad + icce_auth_derive_session_key 保持一致。
+ * 测试向量:长安 ZhixingApp 日志(sessionKey 应与 App 一致)。
+ *
+ * 编译(推荐,见同目录 Makefile):
+ * make -C code/sdk/zhihui/ChangAan
+ * ./icce_session_key_selftest
+ *
+ * 或手动(WSL / Linux,已安装 libmbedtls-dev):
+ * gcc -O2 -Wall -o icce_session_key_selftest icce_session_key_selftest.c -lmbedcrypto
+ *
+ * 或使用 SDK 内 mbedtls(按本机路径调整):
+ * gcc -O2 -Wall -I ../../../open_source/mbedtls/mbedtls_v3.6.0/include \
+ * -o icce_session_key_selftest icce_session_key_selftest.c \
+ * ../../../open_source/mbedtls/mbedtls_v3.6.0/library/aes.c \
+ * ../../../open_source/mbedtls/mbedtls_v3.6.0/library/platform_util.c \
+ * -I ../../../open_source/mbedtls/mbedtls_v3.6.0/include
+ * (若链接失败,请按 mbedtls 3.x 补齐 aes.c 依赖的其它 .c,或优先用 -lmbedcrypto)
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "mbedtls/aes.h"
+
+#define ICCE_TAG_LEN_READER_RND 8u
+#define ICCE_TAG_LEN_CARD_RND 8u
+#define ICCE_TAG_LEN_READER_KEY_PARAM 16u
+#define ICCE_LEN_SESSION_KEY_PLAIN (ICCE_TAG_LEN_READER_RND + ICCE_TAG_LEN_CARD_RND + ICCE_TAG_LEN_READER_KEY_PARAM)
+
+/* 与 bleICCE.c icce_iso9797_m2_pad 一致 */
+static uint16_t icce_iso9797_m2_pad(const uint8_t *in, uint16_t in_len, uint8_t *out, uint16_t out_cap)
+{
+ uint32_t i;
+ uint16_t need = (uint16_t)(in_len + 1u);
+ while ((need % 16u) != 0u) {
+ need++;
+ }
+ if (need > out_cap || need == 0) {
+ return 0;
+ }
+ if (in_len > 0 && in != NULL) {
+ memcpy(out, in, in_len);
+ }
+ out[in_len] = 0x80;
+ for (i = (uint32_t)in_len + 1u; i < need; i++) {
+ out[i] = 0x00;
+ }
+ return need;
+}
+
+static int hex_nibble(char c)
+{
+ if (c >= '0' && c <= '9') {
+ return c - '0';
+ }
+ if (c >= 'a' && c <= 'f') {
+ return c - 'a' + 10;
+ }
+ if (c >= 'A' && c <= 'F') {
+ return c - 'A' + 10;
+ }
+ return -1;
+}
+
+static int parse_hex(const char *s, uint8_t *out, size_t out_len)
+{
+ size_t i;
+ size_t slen = strlen(s);
+ if (slen != out_len * 2u) {
+ return -1;
+ }
+ for (i = 0; i < out_len; i++) {
+ int hi = hex_nibble(s[i * 2u]);
+ int lo = hex_nibble(s[i * 2u + 1u]);
+ if (hi < 0 || lo < 0) {
+ return -1;
+ }
+ out[i] = (uint8_t)((unsigned)hi << 4 | (unsigned)lo);
+ }
+ return 0;
+}
+
+static void icce_hex_dump(const char *title, const uint8_t *data, size_t len)
+{
+ size_t i;
+ printf("%s (%u bytes):\n ", title, (unsigned)len);
+ for (i = 0; i < len; i++) {
+ printf("%02x", data[i]);
+ if (i + 1u < len) {
+ printf((i % 16u) == 15u ? "\n " : " ");
+ }
+ }
+ printf("\n");
+}
+
+/* 打印完整派生过程后写入 session_key_out;逻辑与 icce_auth_derive_session_key 相同 */
+static int icce_auth_derive_session_key_verbose(const uint8_t dkey[16],
+ const uint8_t card_iv[ICCE_TAG_LEN_READER_KEY_PARAM],
+ const uint8_t reader_rnd[ICCE_TAG_LEN_READER_RND],
+ const uint8_t card_rnd[ICCE_TAG_LEN_CARD_RND],
+ const uint8_t reader_key_param[ICCE_TAG_LEN_READER_KEY_PARAM],
+ uint8_t session_key_out[16])
+{
+ uint8_t plain[ICCE_LEN_SESSION_KEY_PLAIN];
+ uint8_t padded[64];
+ uint8_t cipher[64];
+ uint8_t iv_work[16];
+ uint8_t iv_before[16];
+
+ printf("=== SessionKey 派生过程 (ALG_AES_CBC_ISO9797_M2, 同 bleICCE.c) ===\n\n");
+
+ printf("[1] DKey (16B AES-128 key)\n");
+ icce_hex_dump(" ", dkey, 16u);
+
+ printf("[2] CardIV / ReaderKeyParameter 9F0C(作 CBC IV,与明文第三段同源)\n");
+ icce_hex_dump(" ", card_iv, 16u);
+
+ memcpy(plain, reader_rnd, ICCE_TAG_LEN_READER_RND);
+ memcpy(plain + ICCE_TAG_LEN_READER_RND, card_rnd, ICCE_TAG_LEN_CARD_RND);
+ memcpy(plain + ICCE_TAG_LEN_READER_RND + ICCE_TAG_LEN_CARD_RND, reader_key_param,
+ ICCE_TAG_LEN_READER_KEY_PARAM);
+
+ printf("[3] 派生明文 M = ReaderRnd(8) || CardRnd(8) || ReaderKeyParameter(16),共 %u 字节\n",
+ (unsigned)ICCE_LEN_SESSION_KEY_PLAIN);
+ printf(" ReaderRnd:\n");
+ icce_hex_dump(" ", reader_rnd, ICCE_TAG_LEN_READER_RND);
+ printf(" CardRnd:\n");
+ icce_hex_dump(" ", card_rnd, ICCE_TAG_LEN_CARD_RND);
+ printf(" ReaderKeyParameter:\n");
+ icce_hex_dump(" ", reader_key_param, ICCE_TAG_LEN_READER_KEY_PARAM);
+ icce_hex_dump(" M (concat)", plain, ICCE_LEN_SESSION_KEY_PLAIN);
+
+ uint16_t plen = icce_iso9797_m2_pad(plain, ICCE_LEN_SESSION_KEY_PLAIN, padded, (uint16_t)sizeof(padded));
+ if (plen == 0 || plen > sizeof(cipher)) {
+ return -1;
+ }
+
+ printf("[4] ISO/IEC 9797-1 Method 2 填充后,plen=%u,送入 AES-CBC\n", (unsigned)plen);
+ icce_hex_dump(" padded", padded, plen);
+
+ memcpy(iv_work, card_iv, sizeof(iv_work));
+ memcpy(iv_before, iv_work, sizeof(iv_before));
+ printf("[5] CBC IV(加密前拷贝自 CardIV;mbedtls 加密后会改写 IV 缓冲区)\n");
+ icce_hex_dump(" IV before encrypt", iv_before, 16u);
+
+ mbedtls_aes_context aes;
+ mbedtls_aes_init(&aes);
+ if (mbedtls_aes_setkey_enc(&aes, dkey, 128) != 0) {
+ mbedtls_aes_free(&aes);
+ return -1;
+ }
+ if (mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_ENCRYPT, plen, iv_work, padded, cipher) != 0) {
+ mbedtls_aes_free(&aes);
+ return -1;
+ }
+ mbedtls_aes_free(&aes);
+
+ printf("[6] AES-128-CBC 密文(全 plen 字节)\n");
+ icce_hex_dump(" cipher", cipher, plen);
+
+ printf("[7] IV after encrypt (mbedtls 内部链值,仅作参考)\n");
+ icce_hex_dump(" ", iv_work, 16u);
+
+ memcpy(session_key_out, cipher + plen - 16u, 16u);
+ printf("[8] SessionKey = 密文最后一个 16 字节块(cipher[plen-16 .. plen-1])\n");
+ icce_hex_dump(" SessionKey", session_key_out, 16u);
+ printf("\n");
+
+ return 0;
+}
+
+int main(void)
+{
+ /* 长安 App 日志(ZhixingApp initBlueKey) */
+ static const char *hex_dkey = "70326e21ead75c76d46742de644a2fc5";
+ static const char *hex_rkp = "60001001250528330000006925951406";
+ static const char *hex_rr = "9d57cc53a4daca84";
+ static const char *hex_cr = "a8c1f94537b98825";
+ static const char *hex_expect_sk = "b6335322f215b85d51845994f2a2862a";
+
+ uint8_t dkey[16];
+ uint8_t rkp[16];
+ uint8_t rr[8];
+ uint8_t cr[8];
+ uint8_t expect[16];
+ uint8_t sk[16];
+
+ if (parse_hex(hex_dkey, dkey, sizeof(dkey)) != 0 ||
+ parse_hex(hex_rkp, rkp, sizeof(rkp)) != 0 ||
+ parse_hex(hex_rr, rr, sizeof(rr)) != 0 ||
+ parse_hex(hex_cr, cr, sizeof(cr)) != 0 ||
+ parse_hex(hex_expect_sk, expect, sizeof(expect)) != 0) {
+ printf("FAIL: hex parse\n");
+ return 1;
+ }
+
+ if (icce_auth_derive_session_key_verbose(dkey, rkp, rr, cr, rkp, sk) != 0) {
+ printf("FAIL: derive\n");
+ return 1;
+ }
+
+ if (memcmp(sk, expect, 16u) != 0) {
+ printf("FAIL: session key mismatch\n");
+ printf(" got: ");
+ for (unsigned i = 0; i < 16u; i++) {
+ printf("%02x", sk[i]);
+ }
+ printf("\n expected: %s\n", hex_expect_sk);
+ return 1;
+ }
+
+ printf("PASS: SessionKey matches ZhixingApp log (%s)\n", hex_expect_sk);
+ return 0;
+}
--- /dev/null
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+SessionKey 派生测试(与 bleICCE.c icce_auth_derive_session_key 一致;算法名常写作 ALG_AES_CBC_ISO9797_M2):
+
+ SessionKey = AES-128-CBC(DKey, CardIV, ISO9797-M2(ReaderRnd||CardRnd||ReaderKeyParameter)) 的最后一格
+
+固定:DKey、ReaderKeyParameter(与 9F0C/CardIV 同源,16B)
+参数:车侧 ReaderRnd(8B)、钥匙侧 CardRnd(8B),均为 hex 字符串
+
+依赖: pip install pycryptodome
+
+示例:
+ python icce_session_key_test.py -r F018C99F2F8EDADA -c EF9317AE845CDC28
+ python icce_session_key_test.py --reader-rnd f018c99f2f8edada --card-rnd ef9317ae845cdc28
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+
+try:
+ from Crypto.Cipher import AES
+except ImportError:
+ print("需要: pip install pycryptodome", file=sys.stderr)
+ sys.exit(1)
+
+# ---------- 写死:与 bleICCE.c 联调 DKey 一致 ----------
+DKEY = bytes(
+ [
+ 0x70,
+ 0x32,
+ 0x6E,
+ 0x21,
+ 0xEA,
+ 0xD7,
+ 0x5C,
+ 0x76,
+ 0xD4,
+ 0x67,
+ 0x42,
+ 0xDE,
+ 0x64,
+ 0x4A,
+ 0x2F,
+ 0xC5,
+ ]
+)
+
+# 9F0C ReaderKeyParameter / CardIV(与 CBC IV 同源字节);联调车端示例,可按实车改
+READER_KEY_PARAM_CARD_IV = bytes.fromhex("60001001250528330000006925951406")
+
+# 可选:完整 card info 仅作打印/对照(不参与 SessionKey 计算,计算只用上面 16B)
+CARD_INFO_HEX = (
+ "0069dde0e715eafc5f6f3acd849c326a0000002f88b7c08970a26f2301c3b1dd0219b5204c53354132444b45305341323033323336"
+ "2463303636616433622d346336302d343563612d616430652d32633830376631633863396302d0a3097707efc21de3abc3c1c9dc6be8c8fb992ad388184a2776e982da555c8e"
+)
+
+
+def normalize_hex(s: str) -> str:
+ return re.sub(r"[^0-9a-fA-F]", "", s)
+
+
+def iso9797_m2_pad(data: bytes) -> bytes:
+ need = len(data) + 1
+ while need % 16 != 0:
+ need += 1
+ out = bytearray(data)
+ out.append(0x80)
+ while len(out) < need:
+ out.append(0)
+ return bytes(out)
+
+
+def derive_session_key(
+ dkey: bytes,
+ card_iv: bytes,
+ reader_rnd: bytes,
+ card_rnd: bytes,
+ reader_key_param: bytes,
+) -> bytes:
+ if len(dkey) != 16 or len(card_iv) != 16 or len(reader_key_param) != 16:
+ raise ValueError("DKey/CardIV/ReaderKeyParam 须各 16 字节")
+ if len(reader_rnd) != 8 or len(card_rnd) != 8:
+ raise ValueError("ReaderRnd/CardRnd 须各 8 字节")
+ plain = reader_rnd + card_rnd + reader_key_param
+ padded = iso9797_m2_pad(plain)
+ iv = bytearray(card_iv)
+ cipher = AES.new(dkey, AES.MODE_CBC, iv=bytes(iv))
+ ct = cipher.encrypt(padded)
+ return ct[-16:]
+
+
+def main() -> None:
+ ap = argparse.ArgumentParser(description="ICCE SessionKey 派生测试(DKey+9F0C 写死)")
+ ap.add_argument(
+ "-r",
+ "--reader-rnd",
+ required=True,
+ help="车侧 ReaderRnd,16 个 hex 字符(8 字节)",
+ )
+ ap.add_argument(
+ "-c",
+ "--card-rnd",
+ required=True,
+ help="钥匙侧 CardRnd,16 个 hex 字符(8 字节)",
+ )
+ ap.add_argument(
+ "--show-card-info",
+ action="store_true",
+ help="打印写死的 card info 长度与 hex 前缀(不参与计算)",
+ )
+ args = ap.parse_args()
+
+ rr = bytes.fromhex(normalize_hex(args.reader_rnd))
+ cr = bytes.fromhex(normalize_hex(args.card_rnd))
+ if len(rr) != 8 or len(cr) != 8:
+ print("ReaderRnd / CardRnd 须为 8 字节(16 hex 字符)", file=sys.stderr)
+ sys.exit(2)
+
+ sk = derive_session_key(DKEY, READER_KEY_PARAM_CARD_IV, rr, cr, READER_KEY_PARAM_CARD_IV)
+
+ print("--- 固定(与固件联调一致)---")
+ print(f"DKey: {DKEY.hex()}")
+ print(f"ReaderKey/CardIV: {READER_KEY_PARAM_CARD_IV.hex()}")
+ if args.show_card_info:
+ ci = bytes.fromhex(CARD_INFO_HEX)
+ print(f"card info (固定): {len(ci)} bytes, {CARD_INFO_HEX[:64]}...")
+ print()
+ print("--- 输入 ---")
+ print(f"ReaderRnd (9F37): {rr.hex()}")
+ print(f"CardRnd (9F3E): {cr.hex()}")
+ print()
+ print("--- 输出 ---")
+ print(f"SessionKey: {sk.hex()}")
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+ <TargetFramework>net8.0-windows10.0.17763.0</TargetFramework>
+ <Nullable>enable</Nullable>
+ <ImplicitUsings>enable</ImplicitUsings>
+ <RootNamespace>IcceCarSim</RootNamespace>
+ <AssemblyName>IcceCarSim</AssemblyName>
+ <Description>模拟车端:BLE GATT 从机,ICCE 服务 FFF5 / FFFD / FFFE(与 ble_icce_client.h 一致)</Description>
+ </PropertyGroup>
+</Project>
--- /dev/null
+// ICCE 车端模拟:Windows BLE GATT 从机(Peripheral)。
+// UUID 与 ble_icce_client.h / ble_icce_client.c 中 128-bit 定义一致。
+//
+// 要求:Windows 10 1703+,本机蓝牙开启,适配器支持 Peripheral(多数 USB BLE 适配器不支持从机,笔记本内置蓝牙通常支持)。
+// 运行:dotnet run
+//
+// 手表/手机作为 Central 连接本机后:向 FFFD 写入 ICCE 线帧(0x5A 开头),车端打印 hex;
+// FFFE 可订阅通知;按 n+Enter 发送一条示例 Notify。
+
+using Windows.Devices.Bluetooth;
+using Windows.Devices.Bluetooth.GenericAttributeProfile;
+using Windows.Security.Cryptography;
+using Windows.Storage.Streams;
+
+static class Program
+{
+ // 与 ble_icce_client.c 中 icce_service_uuid / icce_ctrl_point_uuid / icce_status_uuid 一致
+ private static readonly Guid UuidIcceService = Guid.Parse("0000fff5-0000-1000-8000-00805f9b34fb");
+ private static readonly Guid UuidIcceWrite = Guid.Parse("0000fffd-0000-1000-8000-00805f9b34fb"); // Control Point
+ private static readonly Guid UuidIcceStatus = Guid.Parse("0000fffe-0000-1000-8000-00805f9b34fb"); // Read + Notify
+
+ private static GattServiceProvider? s_provider;
+ private static GattLocalCharacteristic? s_statusChar;
+ private static readonly object s_notifyLock = new();
+
+ public static async Task<int> Main(string[] args)
+ {
+ Console.WriteLine("IccCarSim — 车端 ICCE GATT 从机 (FFF5 / FFFD / FFFE)");
+ Console.WriteLine("按 Ctrl+C 退出;连接订阅后按 n+Enter 发送测试 Notify。\n");
+
+ BluetoothAdapter? adapter = await BluetoothAdapter.GetDefaultAsync();
+ if (adapter is null)
+ {
+ Console.Error.WriteLine("未找到蓝牙适配器。");
+ return 1;
+ }
+
+ if (!adapter.IsPeripheralRoleSupported)
+ {
+ Console.Error.WriteLine("当前适配器不支持 BLE 从机 (Peripheral)。请换用支持 Peripheral 的蓝牙(多为本机内置)。");
+ return 2;
+ }
+
+ GattServiceProviderResult spResult = await GattServiceProvider.CreateAsync(UuidIcceService);
+ if (spResult.Error != BluetoothError.Success || spResult.ServiceProvider is null)
+ {
+ Console.Error.WriteLine($"创建服务失败: {spResult.Error}");
+ return 3;
+ }
+
+ GattServiceProvider provider = spResult.ServiceProvider;
+
+ var writeParams = new GattLocalCharacteristicParameters
+ {
+ CharacteristicProperties =
+ GattCharacteristicProperties.Write |
+ GattCharacteristicProperties.WriteWithoutResponse,
+ };
+
+ GattLocalCharacteristicResult wRet = await provider.Service.CreateCharacteristicAsync(UuidIcceWrite, writeParams);
+ if (wRet.Error != BluetoothError.Success || wRet.Characteristic is null)
+ {
+ Console.Error.WriteLine($"创建写特征 FFFD 失败: {wRet.Error}");
+ return 4;
+ }
+
+ GattLocalCharacteristic writeChar = wRet.Characteristic;
+ writeChar.WriteRequested += OnFfFdWriteRequestedAsync;
+
+ var statusParams = new GattLocalCharacteristicParameters
+ {
+ CharacteristicProperties =
+ GattCharacteristicProperties.Read |
+ GattCharacteristicProperties.Notify,
+ StaticValue = CryptographicBuffer.CreateFromByteArray(Array.Empty<byte>()),
+ };
+
+ GattLocalCharacteristicResult sRet = await provider.Service.CreateCharacteristicAsync(UuidIcceStatus, statusParams);
+ if (sRet.Error != BluetoothError.Success || sRet.Characteristic is null)
+ {
+ Console.Error.WriteLine($"创建状态特征 FFFE 失败: {sRet.Error}");
+ return 5;
+ }
+
+ s_statusChar = sRet.Characteristic;
+ s_statusChar.ReadRequested += OnFfFeReadRequestedAsync;
+ s_statusChar.SubscribedClientsChanged += OnFfFeSubscribedClientsChanged;
+
+ var adv = new GattServiceProviderAdvertisingParameters
+ {
+ IsConnectable = true,
+ IsDiscoverable = true,
+ };
+
+ provider.AdvertisementStatusChanged += (_, e) =>
+ {
+ Console.WriteLine($"[广告] {provider.AdvertisementStatus}");
+ };
+
+ try
+ {
+ provider.StartAdvertising(adv);
+ }
+ catch (Exception ex)
+ {
+ Console.Error.WriteLine($"StartAdvertising 异常: {ex.Message}");
+ return 6;
+ }
+
+ s_provider = provider;
+ Console.WriteLine("已开始广播 ICCE 服务 (FFF5),等待中央设备连接…");
+
+ _ = Task.Run(ConsoleNotifyLoopAsync);
+
+ using var cts = new CancellationTokenSource();
+ Console.CancelKeyPress += (_, e) =>
+ {
+ e.Cancel = true;
+ cts.Cancel();
+ };
+
+ try
+ {
+ await Task.Delay(Timeout.Infinite, cts.Token);
+ }
+ catch (OperationCanceledException)
+ {
+ // ctrl+c
+ }
+
+ try
+ {
+ provider.StopAdvertising();
+ }
+ catch
+ {
+ // ignore
+ }
+
+ Console.WriteLine("已停止。");
+ return 0;
+ }
+
+ private static async void OnFfFdWriteRequestedAsync(
+ GattLocalCharacteristic sender,
+ GattWriteRequestedEventArgs args)
+ {
+ try
+ {
+ using (args.GetDeferral())
+ {
+ GattWriteRequest? request = await args.GetRequestAsync();
+ if (request is null)
+ {
+ return;
+ }
+
+ try
+ {
+ byte[] data = ReadBuffer(request.Value);
+ string hex = BitConverter.ToString(data).Replace("-", " ");
+ Console.WriteLine($"[车←终端 FFFD 写] len={data.Length} {hex}");
+ }
+ finally
+ {
+ if (request.Option == GattWriteOption.WriteWithResponse)
+ {
+ request.Respond();
+ }
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ Console.Error.WriteLine($"FFFD 处理异常: {ex.Message}");
+ }
+ }
+
+ private static async void OnFfFeReadRequestedAsync(GattLocalCharacteristic sender, GattReadRequestedEventArgs args)
+ {
+ using (args.GetDeferral())
+ {
+ try
+ {
+ GattReadRequest? request = await args.GetRequestAsync();
+ if (request is null)
+ {
+ return;
+ }
+
+ request.RespondWithValue(CryptographicBuffer.CreateFromByteArray(Array.Empty<byte>()));
+ }
+ catch (Exception ex)
+ {
+ Console.Error.WriteLine($"FFFE Read 异常: {ex.Message}");
+ }
+ }
+ }
+
+ private static void OnFfFeSubscribedClientsChanged(GattLocalCharacteristic sender, object args)
+ {
+ Console.WriteLine($"[FFFE] 订阅变化,当前订阅数: {sender.SubscribedClients.Count}");
+ }
+
+ private static async Task ConsoleNotifyLoopAsync()
+ {
+ while (s_provider is not null)
+ {
+ string? line = await Task.Run(Console.ReadLine);
+ if (line is null)
+ {
+ break;
+ }
+
+ if (line.Trim().Equals("n", StringComparison.OrdinalIgnoreCase))
+ {
+ await SendTestNotifyAsync();
+ }
+ }
+ }
+
+ private static async Task SendTestNotifyAsync()
+ {
+ GattLocalCharacteristic? ch = s_statusChar;
+ if (ch is null)
+ {
+ return;
+ }
+
+ // 示例 2 字节,仅作连通性;真实向手表下发为完整 ICCE 帧
+ byte[] payload = { 0x5A, 0x00 };
+
+ lock (s_notifyLock)
+ {
+ // avoid concurrent notify from UI thread
+ }
+
+ try
+ {
+ var writer = new DataWriter();
+ writer.WriteBytes(payload);
+ var buf = writer.DetachBuffer();
+ var results = await ch.NotifyValueAsync(buf);
+ Console.WriteLine($"[车→终端 FFFE Notify] 已发送 len={payload.Length}");
+ foreach (GattClientNotificationResult r in results)
+ {
+ Console.WriteLine($" 通知结果: status={r.Status} bytesSent={r.BytesSent} protocolErr={r.ProtocolError}");
+ }
+ }
+ catch (Exception ex)
+ {
+ Console.Error.WriteLine($"Notify 失败(可能尚未订阅): {ex.Message}");
+ }
+ }
+
+ private static byte[] ReadBuffer(IBuffer buffer)
+ {
+ if (buffer.Length == 0)
+ {
+ return Array.Empty<byte>();
+ }
+
+ var reader = DataReader.FromBuffer(buffer);
+ byte[] data = new byte[buffer.Length];
+ reader.ReadBytes(data);
+ return data;
+ }
+}
--- /dev/null
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Windows BLE GATT 主机(Central):连接对端外设上的 ICCE 服务。
+
+UUID 与 code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/include/ble_icce_client.h
+及 ble_icce_client.c 中 128-bit 定义一致(SIG 基 UUID 0000xxxx-...-00805f9b34fb)。
+
+依赖:Python 3.8+、pip install -r requirements.txt
+运行:以管理员或当前用户权限即可;需本机蓝牙已开启,且 Windows 10 1803+ 对 BLE 支持正常。
+
+用法示例:
+ python icce_windows_central.py --scan
+ python icce_windows_central.py --address AA:BB:CC:DD:EE:FF
+ python icce_windows_central.py --address AA:BB:CC:DD:EE:FF --notify-only
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+try:
+ from bleak import BleakClient, BleakScanner
+except ImportError:
+ print("请先安装: pip install -r requirements.txt", file=sys.stderr)
+ raise SystemExit(1)
+
+# 与 ble_icce_client.c 中 icce_service_uuid / icce_ctrl_point_uuid / icce_status_uuid 一致
+ICCE_SERVICE_UUID = "0000fff5-0000-1000-8000-00805f9b34fb"
+BLE_ICCE_CHAR_WRITE_UUID = "0000fffd-0000-1000-8000-00805f9b34fb" # Control Point 写
+BLE_ICCE_CHAR_STATUS_UUID = "0000fffe-0000-1000-8000-00805f9b34fb" # Read + Notify(Status)
+# CCCD 0x2902:Bleak 对 FFFE 调 start_notify 时会写 CCC,无需手写 2902
+
+
+def _hex(data: bytearray | bytes) -> str:
+ return " ".join(f"{b:02X}" for b in data)
+
+
+def _notification_handler(_sender: object, data: bytearray) -> None:
+ print(f"[NOTIFY] len={len(data)} {_hex(data)}")
+
+
+async def _scan(timeout_s: float) -> None:
+ print(f"扫描 BLE 设备({timeout_s}s)…")
+ devices = await BleakScanner.discover(timeout=timeout_s)
+ if not devices:
+ print("未发现设备")
+ return
+ for d in devices:
+ name = d.name or "(无名称)"
+ print(f" {d.address} {name} rssi={getattr(d, 'rssi', '?' )}")
+
+
+async def _run_client(address: str, notify_only: bool) -> None:
+ print(f"连接 {address} …")
+ async with BleakClient(address) as client:
+ if not client.is_connected:
+ print("连接失败", file=sys.stderr)
+ return
+ print("已连接,服务列表(节选含 ICCE):")
+ for su in client.services:
+ suid = str(su.uuid).lower()
+ mark = " <-- ICCE" if "fff5" in suid else ""
+ print(f" service {suid}{mark}")
+
+ def _uuid_norm(u: object) -> str:
+ return str(u).lower().replace("-", "")
+
+ icce_ok = any(
+ _uuid_norm(s.uuid) == _uuid_norm(ICCE_SERVICE_UUID) for s in client.services
+ )
+ if not icce_ok:
+ print(f"警告:未发现服务 {ICCE_SERVICE_UUID},仍尝试访问特征…")
+
+ await client.start_notify(BLE_ICCE_CHAR_STATUS_UUID, _notification_handler)
+ print(f"已订阅 Notify:{BLE_ICCE_CHAR_STATUS_UUID}")
+
+ if not notify_only:
+ # 最小写示例:单字节占位(真实业务为整帧 ICCE,以 0x5A 开头,见 ble_icce_client_send_icce_frame_raw)
+ test_payload = bytes([0x5A]) # 仅作连通性探测,非完整协议帧
+ print(f"写入 Control Point 测试 {len(test_payload)} B: {_hex(test_payload)}")
+ await client.write_gatt_char(BLE_ICCE_CHAR_WRITE_UUID, test_payload, response=False)
+
+ print("按 Ctrl+C 结束;或等待 300s …")
+ try:
+ await asyncio.sleep(300.0)
+ except asyncio.CancelledError:
+ pass
+
+
+def main() -> None:
+ ap = argparse.ArgumentParser(description="Windows ICCE BLE Central(FFF5/FFFD/FFFE)")
+ ap.add_argument("--scan", action="store_true", help="仅扫描周边 BLE 设备")
+ ap.add_argument("--scan-time", type=float, default=8.0, help="扫描时长(秒)")
+ ap.add_argument("--address", type=str, default=None, help="外设蓝牙地址,如 AA:BB:CC:DD:EE:FF")
+ ap.add_argument(
+ "--notify-only",
+ action="store_true",
+ help="只订阅 FFFE 通知,不写 FFFD",
+ )
+ args = ap.parse_args()
+
+ if args.scan:
+ asyncio.run(_scan(args.scan_time))
+ return
+
+ if not args.address:
+ print("请指定 --address,或先用 --scan 查看地址", file=sys.stderr)
+ raise SystemExit(2)
+
+ addr = args.address.strip()
+ if len(addr) == 17 and addr.count(":") == 5:
+ pass
+ else:
+ # Windows 有时用 AA-BB-... 形式
+ addr = addr.replace("-", ":")
+
+ asyncio.run(_run_client(addr, args.notify_only))
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+bleak>=0.21.0
--- /dev/null
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+ICCE / 长安联调:用已知字节串计算 SHA-256,与对端/日志中的 32B hash 对比。
+
+用法:
+ python icce_sha256_verify.py
+ 按提示输入「待 hash 的十六进制」与「期望的 32 字节 hash(可选)」
+
+或命令行:
+ python icce_sha256_verify.py --msg "9F3708A8F430CB6BEE1518"
+ python icce_sha256_verify.py --msg "A8F430CB6BEE1518" --expect "7F188B264248218B934C2BEB66F3835CE3C42634ED3F302DA568CF4254A9CDDA"
+
+消息 hex 可含空格;大小写不敏感。
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import re
+import sys
+
+
+def hex_to_bytes(s: str) -> bytes:
+ s = re.sub(r"\s+", "", s.strip())
+ if len(s) % 2 != 0:
+ raise ValueError("hex 长度须为偶数")
+ return bytes.fromhex(s)
+
+
+def main() -> int:
+ ap = argparse.ArgumentParser(description="SHA-256 验证(ICCE/联调)")
+ ap.add_argument(
+ "--msg",
+ type=str,
+ default=None,
+ help="待哈希数据的十六进制(不含 0x)",
+ )
+ ap.add_argument(
+ "--expect",
+ type=str,
+ default=None,
+ help="期望的 32 字节 SHA-256 输出(64 hex 字符)",
+ )
+ ap.add_argument(
+ "--file",
+ type=str,
+ default=None,
+ help="从文件读入原始字节(二进制),与 --msg 二选一",
+ )
+ args = ap.parse_args()
+
+ if args.file:
+ with open(args.file, "rb") as f:
+ data = f.read()
+ elif args.msg:
+ data = hex_to_bytes(args.msg)
+ else:
+ print("交互模式:逐行输入,空行结束「消息」部分。")
+ print(" 例:粘贴 9F 37 08 A8 F4 30 CB 6B EE 15 18 后回车,再空行。")
+ lines: list[str] = []
+ while True:
+ try:
+ line = input()
+ except EOFError:
+ break
+ if line.strip() == "" and lines:
+ break
+ if line.strip():
+ lines.append(line)
+ if not lines:
+ print("未输入数据", file=sys.stderr)
+ return 1
+ data = hex_to_bytes("".join(lines))
+
+ h = hashlib.sha256(data).digest()
+ hex_out = h.hex().upper()
+ print("---- 输入 ----")
+ print(f" 长度: {len(data)} 字节")
+ print(f" hex: {data.hex().upper()}")
+ print("---- SHA-256 ----")
+ print(f" {hex_out}")
+ print(f" 分组: {' '.join(hex_out[i : i + 2] for i in range(0, len(hex_out), 2))}")
+
+ if args.expect:
+ try:
+ exp = hex_to_bytes(args.expect)
+ except ValueError as e:
+ print("期望 hash 解析失败:", e, file=sys.stderr)
+ return 1
+ if len(exp) != 32:
+ print("期望 hash 须为 32 字节 (64 hex)", file=sys.stderr)
+ return 1
+ match = h == exp
+ print("---- 对比 ----")
+ print(f" 期望: {exp.hex().upper()}")
+ print(f" 结果: {'MATCH' if match else 'MISMATCH'}")
+
+ # 常见拆分:你日志里的 9F37(ReaderRnd 8B)
+ if len(data) == 11 and data[0:2] == bytes([0x9F, 0x37]) and data[2] == 0x08:
+ inner = data[3:]
+ h2 = hashlib.sha256(inner).digest()
+ print("---- 仅对 9F37 Value(8B) 再算一次(不含 Tag/Length)----")
+ print(f" value hex: {inner.hex().upper()}")
+ print(f" SHA-256: {h2.hex().upper()}")
+
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
--- /dev/null
+#!/usr/bin/env python3
+"""一次性验证:ZhixingApp 日志中的 sessionKey 与派生是否一致。"""
+from Crypto.Cipher import AES
+
+
+def iso9797_m2_pad(data: bytes) -> bytes:
+ need = len(data) + 1
+ while need % 16 != 0:
+ need += 1
+ out = bytearray(data)
+ out.append(0x80)
+ while len(out) < need:
+ out.append(0)
+ return bytes(out)
+
+
+def derive(dkey: bytes, card_iv: bytes, rr: bytes, cr: bytes, rkp_tail: bytes) -> bytes:
+ plain = rr + cr + rkp_tail
+ padded = iso9797_m2_pad(plain)
+ iv = bytearray(card_iv)
+ c = AES.new(dkey, AES.MODE_CBC, iv=bytes(iv))
+ return c.encrypt(padded)[-16:]
+
+
+def main() -> None:
+ dkey = bytes.fromhex("70326e21ead75c76d46742de644a2fc5")
+ rkp = bytes.fromhex("60001001250528330000006925951406")
+ cr_log = bytes.fromhex("a8c1f94537b98825")
+ expected = bytes.fromhex("b6335322f215b85d51845994f2a2862a")
+ sd = bytes.fromhex(
+ "9d57cc53a4daca84a8c1f94537b988256000100125052833000000692595140680000000000000000000000000000000"
+ )
+
+ cases = [
+ ("A: rr=sd[0:8], cr=日志cardRnd, rkp=日志(IV与明文尾同)", sd[:8], cr_log, rkp, rkp),
+ ("B: rr=sd[0:8], cr=sd[8:16], rkp=日志", sd[:8], sd[8:16], rkp, rkp),
+ ("C: rr/sd[8:16]/sd[16:32], IV=日志rkp(明文尾用 sd 内 rkp)", sd[:8], sd[8:16], sd[16:32], rkp),
+ ]
+ for name, rr, cr, rkp_plain, iv in cases:
+ sk = derive(dkey, iv, rr, cr, rkp_plain)
+ ok = sk == expected
+ print(name)
+ print(f" rr={rr.hex()} cr={cr.hex()} rkp_plain={rkp_plain.hex()} iv={iv.hex()}")
+ print(f" SK={sk.hex()} expected={expected.hex()} match={ok}\n")
+
+
+if __name__ == "__main__":
+ main()
{
(void)arg;
mqtt_queue_msg_t *msg = NULL;
-
+
MQTT_INFO("Main thread started\n");
-
+
/* 尝试首次连接(mqtt_try_connect内部会初始化) */
mqtt_try_connect();
int cur_state = (int)g_mqtt_connection_state;
bool status_changed = (cur_status != g_mqtt_conn_last.last_status);
bool state_changed = (cur_state != g_mqtt_conn_last.last_state);
-
+
if (status_changed) {
- MQTT_DEBUG("Connection status changed in main thread: %d -> %d\n",
+ MQTT_DEBUG("Connection status changed in main thread: %d -> %d\n",
g_mqtt_conn_last.last_status, cur_status);
g_mqtt_conn_last.last_status = cur_status;
printf("mqtt_main_thread current_status:%d\n", cur_status);
- if (g_mqtt_callbacks.connect_callback != NULL) {
+ if (g_mqtt_callbacks.connect_callback != NULL) {
g_mqtt_callbacks.connect_callback(g_mqtt_callbacks.user_arg, cur_status);
} else {
MQTT_DEBUG("No connect callback registered\n");
}
}
if (state_changed) {
- MQTT_DEBUG("Connection state changed: %d -> %d\n",
+ MQTT_DEBUG("Connection state changed: %d -> %d\n",
g_mqtt_conn_last.last_state, cur_state);
g_mqtt_conn_last.last_state = cur_state;
}
#include "uapi_Mqtt_api.h"
/* MQTT 日志等级变量(默认设置为 DEBUG) */
-mqtt_log_level_t g_mqtt_log_level =0;
+mqtt_log_level_t g_mqtt_log_level =MQTT_LOG_DEBUG;
/**
* @brief 设置MQTT日志等级
${CMAKE_CURRENT_SOURCE_DIR}/..
)
set(PRIVATE_HEADER
+ ${ROOT_DIR}/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/include
${ROOT_DIR}/open_source/openharmony/drivers/peripheral/display/interfaces/include
${ROOT_DIR}/middleware/utils/update/inner_include
${ROOT_DIR}/middleware/services/gui/uikit/utils/interfaces/kits
#include "components/ui_image_view.h"
#include "components/ui_label_button_ext.h"
-//#include "cmsis_os.h"
#include <iostream>
namespace OHOS
{
-
+
class testBTView
{
public:
- struct ButtonConfig_ext_t
+ struct ButtonConfig_ext_t
{
int x;
int y;
const char *ViewId;
const char *ImageSrc;
- //label
+ /* label */
int label_x;
int label_y;
uint8_t ALIGN;
- int Fontsize;
-
+ int Fontsize;
};
-
+
struct LabelConfig
{
int16_t left;
int16_t top;
int16_t width;
int16_t height;
- int16_t fontSize; // 字体大小
- int16_t lineHeigh; // 行高
- char *text; // 文本
- uint8_t lineBreakMode; // 断行模式。
+ int16_t fontSize; /* 字体大小 */
+ int16_t lineHeigh; /* 行高 */
+ char *text; /* 文本 */
+ uint8_t lineBreakMode; /* 断行模式。 */
};
-
testBTView();
virtual ~testBTView();
static testBTView *GetInstance(void);
UIScrollView *testBTInitIView(uint8_t);
void ClearAll(void);
-
- // 获取测试结果按钮的函数
- UILabelButton* GetOKTestBtn() { return oktestBtn; }
- UILabelButton* GetFailTestBtn() { return failtestBtn; }
+
+ UILabelButton *GetOKTestBtn() { return nullptr; }
+ UILabelButton *GetFailTestBtn() { return nullptr; }
void set_BR_connect(char *);
- bool br_scan_set_text(unsigned char *name ,unsigned char *addr,int16_t rssi,int i);
- UILabelButtonExt* button{NULL};
+ bool br_scan_set_text(unsigned char *name, unsigned char *addr, int16_t rssi, int i);
+ UILabelButtonExt *button_icce_connect{nullptr};
private:
- UILabelButtonExt *SetTheButton_ext(ButtonConfig_ext_t &buttonconfig);//, UIView::OnTouchListener *clickListener);
- UILabel *InitLabel(LabelConfig &labelConfig);
+ UILabelButtonExt *SetTheButton_ext(ButtonConfig_ext_t &buttonconfig);
bool testBTScrollViewcrollViewinit(uint8_t);
UIScrollView *testBTScrollView{nullptr};
-
-
- UILabelButtonExt* labelButton_next = nullptr;
- UILabel *label_BR_SCAN[5]{nullptr};
-
- bool initViewStatus{false};
- UILabel *Title{nullptr}; // 标题
-
- // 添加成功失败按钮
- UILabelButton *oktestBtn{nullptr};
- UILabelButton *failtestBtn{nullptr};
};
}
-#endif
\ No newline at end of file
+#endif
#include "custom_runtime.h"
+#include "cmsis_os2.h"
+
+#ifdef SUPPORT_BLE_SERVICE
+#include "bts_def.h"
+/* bleICCE.h 会依赖 ble_icce_client.h,producttest 未配置该路径;仅声明 GAP 连接封装 */
+extern "C" bool ble_icce_connect_to_device(bd_addr_t *addr);
+#endif
#if defined(SUPPORT_GNSS)
#include "gnss_ctl.h"
}
}
+
+#ifdef SUPPORT_BLE_SERVICE
+ /* 提前处理:避免落入下方通用 view.GetViewId() 日志;800ms 内重复点击忽略(防双击/多点) */
+ if (strcmp(view.GetViewId(), "icce_connect_fixed") == 0) {
+ static uint32_t s_icce_last_tick;
+ uint32_t now = osKernelGetTickCount();
+ uint32_t hz = osKernelGetTickFreq();
+ uint32_t gap_ticks = (hz > 0u) ? (hz * 800u / 1000u) : 800u;
+ if (s_icce_last_tick != 0u && (now - s_icce_last_tick) < gap_ticks) {
+ return true;
+ }
+ s_icce_last_tick = now;
+
+ /*
+ * 须与 AT^CHANGAN_ICCE_CONNECT 一致:ChangAan/changan_api_at.c changan_parse_bt_address
+ * 对人看到的 AA:BB:...:FF 作反序写入 bd_addr_t(addr[0] 为串中最右字节)。
+ * 显示 F8:6F:DE:84:DE:30 → addr {30,DE,84,DE,6F,F8}
+ */
+ bd_addr_t icce_addr = { 0 };
+ icce_addr.addr[0] = 0x30;
+ icce_addr.addr[1] = 0xDE;
+ icce_addr.addr[2] = 0x84;
+ icce_addr.addr[3] = 0xDE;
+ icce_addr.addr[4] = 0x6F;
+ icce_addr.addr[5] = 0xF8;
+ icce_addr.type = BT_ADDRESS_TYPE_PUBLIC_DEVICE_ADDRESS;
+ bool ok = ble_icce_connect_to_device(&icce_addr);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ICCE_CONNECT F8:6F:DE:84:DE:30 ret=%d", ok ? 1 : 0);
+ return true;
+ }
+#endif
// 处理各测试界面的 成功/失败 按钮
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"view.GetViewId() %s ",view.GetViewId());
testhrsenson1View::GetInstance()->leeklight_test(true);
}
- if(strcmp(view.GetViewId(),"discovery") == 0)
- {
-
- testBTView::GetInstance()->BT_discovery_callback();
- }
if(strcmp(view.GetViewId(),"addvolume") == 0)
{
testmicrohoneView::GetInstance()->addvolumebuttoncallback();
#include "wearable_log.h"
#include "custom_utils.h"
#include "producttest/include/testPresenter.h"
-#include "producttest/include/testbt.h"
-#include "alarm/include/AlarmClockModel.h"
+#include "producttest/include/testbt.h"
#include "cmsis_os2.h"
-#ifdef SUPPORT_CAT1_SERVICE
-#include "cat1_server.h"
-#include "cat1_ctl.h"
-#include "cat1_server_hal.h"
-#endif
#include "custom_runtime.h"
-#include "bts_br_gap.h"
-#include "bts_le_gap.h"
#ifdef SUPPORT_BLE_SERVICE
#include "bleService.h"
#include "producttest/include/testView.h"
#include "producttest/include/testModel.h"
#include "uicomponents/UIComponents.h"
-#ifdef __cplusplus
-#if __cplusplus
-extern "C"
-{
-#endif
-#endif
- #include "pm_veto.h"
- #include "pm.h"
-#ifdef __cplusplus
-#if __cplusplus
-}
-#endif
-#endif
namespace OHOS
{
- // #define BLE_scan
static testBTView *g_pSystemAboutTheWatchView{nullptr};
testBTView::testBTView()
{
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "testBTView::~testBTView");
ClearAll();
- //g_pSystemAboutTheWatchView = nullptr;
}
testBTView *testBTView::GetInstance()
{
-
return g_pSystemAboutTheWatchView;
}
- static osTimerId_t BR_TEST_timer=NULL;
- void testBTView::ClearAll()
- {
- if(testBTScrollView)
- {
- BluetoothModel::GetInstance()->SetCaseListClear();
-
- testBTScrollView->RemoveAll();
-
- if (BR_TEST_timer != NULL) {
- osTimerStop(BR_TEST_timer);
- osTimerDelete(BR_TEST_timer);
- BR_TEST_timer = NULL;
- return ;
- }
- if(button)
- {
- delete button;
- button=nullptr;
- }
-
- if(labelButton_next)
- {
- delete labelButton_next;
- labelButton_next=nullptr;
- }
-
-
- if(Title)
- {
- delete Title;
- Title=nullptr;
- }
-
- // 清理成功失败按钮
- if (oktestBtn)
- {
- delete oktestBtn;
- oktestBtn = nullptr;
- }
- if (failtestBtn)
- {
- delete failtestBtn;
- failtestBtn = nullptr;
- }
-
- for(int i=0;i<5;i++)
- {
- if(label_BR_SCAN[i])
- {
- delete label_BR_SCAN[i];
- label_BR_SCAN[i]=nullptr;
- }
- }
-
- bool ret = gap_br_cancel_discovery();
- #ifdef CUSTOM_ZHIHUI
- BluetoothModel::GetInstance()->set_test_bt_falg(false);
- #endif
-
- // uint8_t cnt = pm_veto_get_id_cnt(PM_ID_P_TEST);
- // if (cnt == 1) {
- // uapi_pm_remove_sleep_veto(PM_ID_P_TEST);
- // } else {
- // // WEARABLE_LOGE(WEARABLE_LOG_MODULE_MAIN_SERVICE,"CAT1 SERVICE MCU has got pm_id_cat1 vote\r\n");
- // }
-
-
- delete testBTScrollView;
- testBTScrollView=nullptr;
- }
- }
-
-
- UILabelButtonExt *testBTView::SetTheButton_ext(ButtonConfig_ext_t &buttonconfig)
+ void testBTView::ClearAll()
{
- UILabelButtonExt *button = new UILabelButtonExt();
- if (button == nullptr)
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, " SystemView::SetTheButton: button new fail!");
- return nullptr;
+ if (testBTScrollView == nullptr) {
+ return;
}
- button->SetPosition(buttonconfig.x, buttonconfig.y, buttonconfig.w, buttonconfig.h);
- button->SetViewId(buttonconfig.ViewId);
- button->SetStyle(STYLE_BACKGROUND_COLOR, Color::Blue().full);
- //button->SetStyle(STYLE_BORDER_RADIUS,0);
- button->SetStyleForState(STYLE_BACKGROUND_COLOR, Color::Black().full, UIButton::PRESSED);
- //button->SetStyleForState(STYLE_BORDER_RADIUS,0, UIButton::PRESSED);
- button->SetTouchable(true);
- button->SetStyle(STYLE_BACKGROUND_OPA, 0x80);
- button->SetText(buttonconfig.str);
- button->SetAlign(TEXT_ALIGNMENT_LEFT);
- button->SetLabelPosition(buttonconfig.label_x,buttonconfig.label_y );
- button->SetFont(DEFAULT_VECTOR_FONT_FILENAME_EN, buttonconfig.Fontsize);
- UIView:: OnClickListener *touchListener = static_cast<UIView::OnClickListener *>(testPresenter::GetInstance());
- button->SetOnClickListener(touchListener);
-
- // UIView::OnDragListener *drgListener = static_cast<UIView::OnDragListener *>(testPresenter::GetInstance());
- // button->SetOnDragListener(drgListener);
-
- // button->SetDraggable(false);
- return button;
- }
- static bool speakfalg=false;
-
- static bool discovery_falg=false;
-
- void testBTView:: BT_discovery_callback( void)
- {
-
- bool reT_gap;
- if(discovery_falg==false)
- {
-
- #ifdef BLE_scan
- srv_ble_start_scan();
- #else
- uint32_t device_classes =
- DEVICE_MAJOR_CLASS_AUDIO_VIDEO|DEVICE_MAJOR_CLASS_PHONE|SERVICE_AUDIO
- |SERVICE_LIMITED_DISCOVERABILITY|SERVICE_POSITIONING|SERVICE_NETWORKING
- |SERVICE_RENDER|SERVICE_CAPTURE|SERVICE_OBJECT_TRANSFER|SERVICE_TELEPHONY
- |SERVICE_INFORMATION;
- // errcode_t err = gap_br_set_inquiry_paramters(device_classes, 5);
- errcode_t err = gap_br_set_inquiry_paramters(0,20);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"gap_br_set_inquiry_paramters errcode_t %d!\n",err);
+ BluetoothModel::GetInstance()->SetCaseListClear();
+ testBTScrollView->RemoveAll();
- bool ret = gap_br_start_discovery();
- BluetoothModel::GetInstance()->SortScansCaseRssi();
- #ifdef CUSTOM_ZHIHUI
- BluetoothModel::GetInstance()->set_test_bt_falg(true);
- #endif
-
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"gap_br_start_discovery bool %d!\n",ret);
- #endif
- button->SetText("scaning");
- button->SetStyle(STYLE_BACKGROUND_COLOR, Color::Green().full);
- discovery_falg=true;
+ if (button_icce_connect != nullptr) {
+ delete button_icce_connect;
+ button_icce_connect = nullptr;
}
- else
- {
- #ifdef BLE_scan
- srv_ble_stop_scan();
- #else
- bool ret = gap_br_cancel_discovery();
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"gap_br_cancel_discovery bool %d!\n",ret);
-
- #endif
- button->SetText("discovery");
- button->SetStyle(STYLE_BACKGROUND_COLOR, Color::Blue().full);
+ delete testBTScrollView;
+ testBTScrollView = nullptr;
- discovery_falg=false;
- }
+#ifdef CUSTOM_ZHIHUI
+ BluetoothModel::GetInstance()->set_test_bt_falg(false);
+#endif
}
-
- UILabel *testBTView::InitLabel(LabelConfig &labelConfig)
+ UILabelButtonExt *testBTView::SetTheButton_ext(ButtonConfig_ext_t &buttonconfig)
{
- UILabel *label = new UILabel();
- if (label == nullptr)
- {
+ UILabelButtonExt *b = new UILabelButtonExt();
+ if (b == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "testBTView::SetTheButton_ext: new fail");
return nullptr;
}
- label->SetPosition(labelConfig.left, labelConfig.top, labelConfig.width, labelConfig.height); // 位置大小
- label->SetStyle(STYLE_TEXT_FONT, labelConfig.fontSize); // 字体大小
- label->SetStyle(STYLE_LINE_HEIGHT, labelConfig.lineHeigh); // 字体行高
- label->SetText(labelConfig.text); // 内容
- label->SetLineBreakMode(labelConfig.lineBreakMode); // 断行模式。
- label->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_TOP);
- label->SetFont(DEFAULT_VECTOR_FONT_FILENAME_EN, labelConfig.fontSize);
- label->SetAlign(TEXT_ALIGNMENT_LEFT);
- return label;
+ b->SetPosition(buttonconfig.x, buttonconfig.y, buttonconfig.w, buttonconfig.h);
+ b->SetViewId(buttonconfig.ViewId);
+ b->SetStyle(STYLE_BACKGROUND_COLOR, Color::Blue().full);
+ b->SetStyleForState(STYLE_BACKGROUND_COLOR, Color::Black().full, UIButton::PRESSED);
+ b->SetTouchable(true);
+ b->SetStyle(STYLE_BACKGROUND_OPA, 0x80);
+ b->SetText(buttonconfig.str);
+ b->SetAlign(TEXT_ALIGNMENT_CENTER);
+ b->SetLabelPosition(buttonconfig.label_x, buttonconfig.label_y);
+ b->SetFont(DEFAULT_VECTOR_FONT_FILENAME_EN, buttonconfig.Fontsize);
+ UIView::OnClickListener *touchListener = static_cast<UIView::OnClickListener *>(testPresenter::GetInstance());
+ b->SetOnClickListener(touchListener);
+ return b;
}
-
- static bd_addr_t bd_addr;
- static unsigned char addr[6] = {0};
- static uint8_t number =0;
- static uint8_t scan_i=0;
-
- static void sample_gap_discovery_result_callback(const bd_addr_t *bd_addr)
+ void testBTView::dial_112(bool)
{
- unsigned char length = BD_NAME_LEN;
- unsigned char *device_name = (unsigned char *)(void *)malloc(length);
- if (device_name == NULL) {
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"gap_discovery_result_callback malloc error!\n");
- return;
- }
- (void)memset_s(device_name, length, 0, length);
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RemovePair gap_get_paired_devices_list ret = %s %s", device_name,bd_addr);
- number++;
-
- free(device_name);
}
- static void sample_gap_discovery_state_changed_callback(int status)
+ void testBTView::set_BR_connect(char *)
{
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "ap_discovery_state_changed_callback status: %d\n", status);
}
- static char device_name_buf[64];
- static void mgdataTimerCallBack(int data)
+ void testBTView::BT_discovery_callback(void)
{
+ /* 已取消 discovery,仅保留 ICCE 产测键;保留空实现以免旧代码链接 */
+ }
- if(is_bt_discovering(BT_TRANSPORT_INVALID))
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, " BT_TRANSPORT_INVALID is_bt_discovering %d",number);
- }
- else if(is_bt_discovering(BT_TRANSPORT_BR_EDR))
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, " BT_TRANSPORT_BR_EDR is_bt_discovering %d",number);
- }
- else if(is_bt_discovering(BT_TRANSPORT_LE))
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, " BT_TRANSPORT_LE is_bt_discovering %d",number);
- }
- else
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "no bt_discovering %d",number);
- }
-
- std::list<BluetoothCaseInfo> btScansDevicesList_ =BluetoothModel::GetInstance()->GetCase();
- std::list<BluetoothCaseInfo>::iterator node = btScansDevicesList_.begin();
- if (btScansDevicesList_.empty()) {
- return;
- }
- int i=0;
- while (node != btScansDevicesList_.end()) {
-
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, " name %s %d %d",node->deviceName,node->index,node->temp);
-
- BluetoothModel::GetInstance()->SortScansCaseRssi();
-
- testBTView::GetInstance()->br_scan_set_text(node->deviceName,node->addr,node->temp,i);
- i++;
- node++;
- }
-
- }
-
- bool testBTView::br_scan_set_text(unsigned char *name ,unsigned char *addr,int16_t rssi,int i)
+ bool testBTView::br_scan_set_text(unsigned char *name, unsigned char *addr, int16_t rssi, int i)
{
- if(i>=5)
- {
- return false;
- }
- char buf[128]={0};
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "rssi %d",rssi);
-
- sprintf_s(buf,128,"addr:%02X %02X %02X %02X %02X %02X\nRssi:%d",addr[0],addr[1],addr[2],addr[3],addr[4],addr[5],rssi);
- label_BR_SCAN[i]->SetText(buf);
- RootView::GetInstance()->Invalidate();
-
- return true;
+ (void)name;
+ (void)addr;
+ (void)rssi;
+ (void)i;
+ return false;
}
bool testBTView::testBTScrollViewcrollViewinit(uint8_t id)
{
-
+ (void)id;
testBTScrollView = new UIScrollView();
- if (testBTScrollView == nullptr)
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SystemAboutTheWatchView::testBTScrollView new fail!");
+ if (testBTScrollView == nullptr) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "testBTView::testBTScrollView new fail");
return false;
}
testBTScrollView->SetPosition(0, 0, Screen::GetInstance().GetWidth(), Screen::GetInstance().GetHeight());
testBTScrollView->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
testBTScrollView->SetStyle(STYLE_BORDER_RADIUS, 0);
testBTScrollView->SetStyle(STYLE_BACKGROUND_COLOR, Color::Black().full);
- testBTScrollView->SetStyle(STYLE_BORDER_COLOR, Color::Yellow().blue);
testBTScrollView->SetScrollBlankSize(50);
testBTScrollView->SetReboundSize(50);
testBTScrollView->SetDirection(1);
-
- LabelConfig Config = {
- .left = 33,
- .top = 80,
- .width = 400,
- .height = 44,
- .fontSize = 30,
- .lineHeigh = 0,
- .text = "",
- .lineBreakMode = UILabel::LINE_BREAK_WRAP,
- };
-
-
- for(int i=0 ;i<5;i++)
- {
- Config.top+=100;
- label_BR_SCAN[i]= InitLabel(Config);
- testBTScrollView->Add(label_BR_SCAN[i]);
- }
-
+#ifdef SUPPORT_BLE_SERVICE
+ /* 单键:AT^CHANGAN_ICCE_CONNECT=F8:6F:DE:84:DE:30(见 testPresenter icce_connect_fixed) */
ButtonConfig_ext_t buttonconfig;
- buttonconfig.x = 55;
- buttonconfig.y = 80;
- buttonconfig.w = 180;
- buttonconfig.h = 88;
- buttonconfig.label_x=40;
- buttonconfig.label_y=0;
- buttonconfig.Fontsize=30;
- buttonconfig.ViewId="discovery";
- buttonconfig.str="discovery";
- buttonconfig.ALIGN=TEXT_ALIGNMENT_LEFT;
-
- button=SetTheButton_ext(buttonconfig);
- testBTScrollView->Add(button);
-
-
- UIView::OnDragListener *draglistener = static_cast<UIView::OnDragListener *>(testPresenter::GetInstance());
- if (draglistener == nullptr)
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SystemView::draglistener can not be nullptr!");
+ int sw = Screen::GetInstance().GetWidth();
+ int sh = Screen::GetInstance().GetHeight();
+ buttonconfig.w = 220;
+ buttonconfig.h = 96;
+ buttonconfig.x = (sw - buttonconfig.w) / 2;
+ buttonconfig.y = sh / 2 - buttonconfig.h / 2;
+ buttonconfig.label_x = 0;
+ buttonconfig.label_y = 0;
+ buttonconfig.Fontsize = 28;
+ buttonconfig.ViewId = "icce_connect_fixed";
+ buttonconfig.str = "ICCE Conn";
+ buttonconfig.ALIGN = TEXT_ALIGNMENT_CENTER;
+
+ button_icce_connect = SetTheButton_ext(buttonconfig);
+ if (button_icce_connect == nullptr) {
return false;
}
- testBTScrollView->SetOnDragListener(draglistener);
-
-
-
- labelButton_next= testAboutView::GetInstance()->init_button_next(270,80,Test_ViewMapper_t[id].viewid_str_next);
- testBTScrollView->Add(labelButton_next);
-
- Title= testAboutView::GetInstance()->init_title(165,45,"BT_TEST");
- testBTScrollView->Add(Title);
+ testBTScrollView->Add(button_icce_connect);
+#else
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "testBTView: SUPPORT_BLE_SERVICE off, no ICCE button");
+#endif
+ UIView::OnDragListener *draglistener = static_cast<UIView::OnDragListener *>(testPresenter::GetInstance());
+ if (draglistener != nullptr) {
+ testBTScrollView->SetOnDragListener(draglistener);
+ }
testBTScrollView->SetTouchable(true);
testBTScrollView->SetDraggable(true);
- uint32_t tick;
- osStatus_t retTimer;
- BR_TEST_timer = osTimerNew((osTimerFunc_t)mgdataTimerCallBack, osTimerPeriodic, NULL, NULL);
- tick =5000;// osMs2Tick(1000);
- retTimer = osTimerStart(BR_TEST_timer, tick);
- if (retTimer != osOK && BR_TEST_timer != NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"StartCallTimer osTimerStart failed, ret = %lx!!", retTimer);
- osTimerDelete(BR_TEST_timer);
- BR_TEST_timer = NULL;
- return false;
- }
-
- discovery_falg=false;
-
-#if ENABLE_TEST_RESULT_BUTTONS
- // 使用通用的InitLabelButton函数初始化按钮,避免viewId地址过期问题
- // 获取BT测试界面的按钮推荐位置
- int okX, okY, failX, failY;
- bool isScrollable;
- testView::GetInstance()->GetTestButtonPosition("Bluetooth", okX, okY, failX, failY, isScrollable);
-
- if (!InitLabelButton(oktestBtn, okX, okY, 135, 88, "TestOKBluetooth", "成功", 30))
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "InitLabelButton for OK button failed");
- return false;
- }
-
- if (!InitLabelButton(failtestBtn, failX, failY, 135, 88, "TestNOBluetooth", "失败", 30))
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "InitLabelButton for Fail button failed");
- return false;
- }
-
- // 设置按钮样式和监听器
- oktestBtn->SetAlign(TEXT_ALIGNMENT_CENTER);
- failtestBtn->SetAlign(TEXT_ALIGNMENT_CENTER);
-
- // 设置点击监听器
- oktestBtn->SetOnClickListener(testPresenter::GetInstance());
- failtestBtn->SetOnClickListener(testPresenter::GetInstance());
-
- // 添加到滚动视图
- testBTScrollView->Add(oktestBtn);
- testBTScrollView->Add(failtestBtn);
-
- // 根据当前测试状态更新按钮颜色和状态
- testView::GetInstance()->UpdateResultButtonStatus(BT_TEST, oktestBtn, failtestBtn);
-#endif
-
- // uint8_t cnt = pm_veto_get_id_cnt(PM_ID_P_TEST);
- // if (cnt == 0) {
- // uapi_pm_add_sleep_veto(PM_ID_P_TEST);
- // } else {
- // // WEARABLE_LOGE(WEARABLE_LOG_MODULE_MAIN_SERVICE,"CAT1 SERVICE MCU has got pm_id_cat1 vote\r\n");
- // }
-
-
-
-
return true;
}
UIScrollView *testBTView::testBTInitIView(uint8_t id)
{
- if (!testBTScrollViewcrollViewinit(id))
- {
+ if (!testBTScrollViewcrollViewinit(id)) {
return nullptr;
}
return testBTScrollView;
}
-}
\ No newline at end of file
+}
#else
const uint32_t AI_VOICE_QUEUE_SIZE = 32; // 队列大小
#endif
+
// OGG封装相关常量
const uint32_t MILLSECOND_TO_SECOND = 1000;
const uint32_t HEADER_STRLEN = 8;
// 当比特率更高时,延迟时间更短
// 公式:延迟(微秒)= (size * 8 * 1000000) / bit_rate
uint32_t delay_us = (uint32_t)((uint64_t)(size-(size/10*5)) * 8 * 1000000ULL / g_tts_audio_bit_rate);
- MEDIA_DEBUG_LOG("delay_us %d\r\n",delay_us);
+ MEDIA_INFO_LOG("delay_us %d\r\n",delay_us);
// 确保延迟时间在合理范围内(最小10微秒)
if (delay_us < 20) {
// 宏定义:选择使用 AudioStreamInInit 还是 AudioCapturer
// 定义 USE_AUDIO_STREAM_IN 则使用 AudioStreamInInit,否则使用 AudioCapturer
#ifndef USE_AUDIO_STREAM_IN
-#define USE_AUDIO_STREAM_IN 1
+#define USE_AUDIO_STREAM_IN 0
#endif
#if USE_AUDIO_STREAM_IN
// data_pass 保存项
CONFIGMODEL_ITEM_DMP_DATA_PASS,
+ /** 个人中心:是否已完成声明+登录引导(false 则冷启动从声明页开始) */
+ CONFIGMODEL_ITEM_PERSONAL_CENTER_ONBOARDING_DONE,
CONFIGMODEL_ITEM_MAX,
void SetDmpDataPass(const char *str);
std::string GetDmpDataPass(void);
+ void SetPersonalCenterOnboardingDone(bool value);
+ bool GetPersonalCenterOnboardingDone(void);
+
// flash light config data
void GetFlashLightConfigData(uint8_t * ColorIndex, int64_t * ColorValue, uint8_t * FlashingLevel);
void SetFlashLightConfigData(uint8_t ColorIndex, int64_t ColorValue, uint8_t FlashingLevel);
#if defined(SUPPORT_CHINA_MOBILE_DMP) || defined(SUPPORT_A5133_SERVICE) || defined(SUPPORT_CHINA_MOBILE_AI_REGULATION) //移动入库软件要求默认开启4G
{ConfigDataType::DATATYPE_BOOL, "cat1_service_on", "true" },//CONFIGMODEL_ITEM_CAT1_SERVICE_ON, // 关机前Cat1 Service启动着,则重启仍然启动,反之亦然
#else
- {ConfigDataType::DATATYPE_BOOL, "cat1_service_on", "false" },//CONFIGMODEL_ITEM_CAT1_SERVICE_ON, // 关机前Cat1 Service启动着,则重启仍然启动,反之亦然
+ {ConfigDataType::DATATYPE_BOOL, "cat1_service_on", "true" },//CONFIGMODEL_ITEM_CAT1_SERVICE_ON, // 关机前Cat1 Service启动着,则重启仍然启动,反之亦然
#endif
{ConfigDataType::DATATYPE_STRING, "cat1_imei", "pls poweron 4G first" },//CONFIGMODEL_ITEM_CAT1_IMEI,
{ConfigDataType::DATATYPE_STRING, "cat1_modemver", "pls poweron 4G first" },//CONFIGMODEL_ITEM_CAT1_MODEMVER,
// data_pass key
{ConfigDataType::DATATYPE_STRING, "dmp_data_pass", ""},//CONFIGMODEL_ITEM_DMP_DATA_PASS
-
+ {ConfigDataType::DATATYPE_BOOL, "personal_center_onboarding_done", "false"},//CONFIGMODEL_ITEM_PERSONAL_CENTER_ONBOARDING_DONE
};
ConfigModel(); // 私有构造函数,确保无法在外部实例化
return get_configData_bool(CONFIGMODEL_ITEM_FIRSTTIMESTART);
}
+ void ConfigModel::SetPersonalCenterOnboardingDone(bool value)
+ {
+ set_condigData_Bool(CONFIGMODEL_ITEM_PERSONAL_CENTER_ONBOARDING_DONE, value);
+ }
+
+ bool ConfigModel::GetPersonalCenterOnboardingDone(void)
+ {
+ return get_configData_bool(CONFIGMODEL_ITEM_PERSONAL_CENTER_ONBOARDING_DONE);
+ }
+
/*设置API Keys*/
void ConfigModel::SetOpenAIAPIKeys(const char * value)
{
void cm_initScreenBrightness(void)
{
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "cm_initScreenBrightness");
- int brightness = OHOS::ConfigModel::GetInstance()->GetBrightness();
- #ifdef BOARD_LEINIAO
- OHOS::ConfigModel::GetInstance()->SetBrightness(5);
- #endif
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "cm_initScreenBrightness");
+ int brightness = OHOS::ConfigModel::GetInstance()->GetBrightness();
+ uapi_setScreenBrightness(brightness);
}
int cm_getScreenBrightness(void)
int select_ret = lwip_select(g_tcp_socket + 1, &read_fds, NULL, NULL, &timeout);
if (select_ret > 0 && FD_ISSET(g_tcp_socket, &read_fds)) {
- ssize_t recv_len = lwip_recv(g_tcp_socket, recv_buf,TCP_RECV_BUFFER_SIZE, 0);
+ ssize_t recv_len = lwip_recv(g_tcp_socket, recv_buf, sizeof(recv_buf), 0);
if (recv_len > 0) {
if ((frame_len + (uint32_t)recv_len) > sizeof(frame_buf)) {
frame_len = 0;
* Copyright (c) Zhihui Technologies Co., Ltd. 2025-2025. All rights reserved.
*/
- #include "ln_mqtt_api.h"
- #include "ln_api.h"
- #include "custom_utils.h"
- #include "cmsis_os2.h"
- #include "soc_osal.h"
- #include <stdio.h>
- #include <stdlib.h>
- #include <string.h>
- #include <stdbool.h>
- #include <stdint.h>
- #include <errno.h>
- #include "lwip/sockets.h"
- #include "lwip/netdb.h"
- #include "lwip/inet.h"
- #include <time.h>
- #include "opus_frame_to_pcm.h"
- #include "ai_media.h"
- #include "ln_data_decode.h"
-
- /* OGG 封装相关前向声明(不透明句柄,避免依赖 ogg.h) */
- /* OGG 上下文句柄(不透明指针,实际类型在 ai_media_service_mqtt.cpp 中定义) */
- typedef void* MqttOggContextHandle;
-
- /* OGG 封装接口声明(使用不透明句柄) */
- extern void* MqttOggGetContext(void);
- extern int32_t MqttOggEncapsulationInitHandle(MqttOggContextHandle oggCtxHandle, FILE *pfd, uint32_t sampleRate, uint32_t channelCount);
- extern int32_t MqttOggEncapsulationWriteHandle(MqttOggContextHandle oggCtxHandle, const uint8_t *buffer, uint32_t bufferLen, FILE *pfd, bool isEos);
- extern int32_t MqttOggEncapsulationFinishHandle(MqttOggContextHandle oggCtxHandle, FILE *pfd);
-
- /* MQTT 播放接口声明 */
- typedef void (*MqttPlayerCallback)(int32_t event, void* userData);
- extern int32_t MQTT_PlayAudioFile(const char* filePath, MqttPlayerCallback callback, void* userData);
-
- /* UDP接收缓冲区大小 */
- #define UDP_RECV_BUFFER_SIZE 4096
-
- /* UDP数据包头部大小 */
- #define UDP_PACKET_HEADER_SIZE 16 // 1+1+2+4+4+4 = 16 bytes
-
- /* UDP数据包结构体 */
- typedef struct {
- uint8_t type; // 类型 (1 byte)
- uint8_t flags; // 标志 (1 byte)
- uint16_t payload_len; // 负载长度 (2 bytes, 网络字节序)
- uint32_t ssrc; // SSRC (4 bytes, 网络字节序)
- uint32_t timestamp; // 时间戳 (4 bytes, 网络字节序)
- uint32_t sequence; // 序列号 (4 bytes, 网络字节序)
- uint8_t *payload; // 加密负载数据指针
- uint16_t payload_size; // 负载数据大小
- } ln_udp_packet_t;
-
- /* UDP套接字全局变量 */
- static int g_udp_socket = -1;
- static volatile bool g_udp_thread_running = false;
- static uint32_t g_udp_thread_handle = 0;
-
- /* UDP数据包序列号和SSRC管理 */
-uint32_t g_udp_ssrc = 0; // SSRC标识
-uint32_t g_udp_sequence = 0; // 序列号(自动递增)
-
-void set_udp_sequence(uint32_t sequence)
+#include "ln_mqtt_api.h"
+#include "ln_api.h"
+#include "custom_utils.h"
+#include "cmsis_os2.h"
+#include "soc_osal.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <errno.h>
+#include "lwip/sockets.h"
+#include "lwip/netdb.h"
+#include "lwip/inet.h"
+#include <time.h>
+#include "opus_frame_to_pcm.h"
+#include "ai_media.h"
+#include "ln_data_decode.h"
+
+/* OGG 封装相关前向声明(不透明句柄,避免依赖 ogg.h) */
+/* OGG 上下文句柄(不透明指针,实际类型在 ai_media_service_mqtt.cpp 中定义) */
+typedef void* MqttOggContextHandle;
+
+/* OGG 封装接口声明(使用不透明句柄) */
+extern void* MqttOggGetContext(void);
+extern int32_t MqttOggEncapsulationInitHandle(MqttOggContextHandle oggCtxHandle, FILE *pfd, uint32_t sampleRate, uint32_t channelCount);
+extern int32_t MqttOggEncapsulationWriteHandle(MqttOggContextHandle oggCtxHandle, const uint8_t *buffer, uint32_t bufferLen, FILE *pfd, bool isEos);
+extern int32_t MqttOggEncapsulationFinishHandle(MqttOggContextHandle oggCtxHandle, FILE *pfd);
+
+/* MQTT 播放接口声明 */
+typedef void (*MqttPlayerCallback)(int32_t event, void* userData);
+extern int32_t MQTT_PlayAudioFile(const char* filePath, MqttPlayerCallback callback, void* userData);
+
+/* UDP接收缓冲区大小 */
+#define UDP_RECV_BUFFER_SIZE 4096
+
+/* UDP数据包头部大小 */
+#define UDP_PACKET_HEADER_SIZE 16 // 1+1+2+4+4+4 = 16 bytes
+
+/* UDP数据包结构体 */
+typedef struct {
+ uint8_t type; // 类型 (1 byte)
+ uint8_t flags; // 标志 (1 byte)
+ uint16_t payload_len; // 负载长度 (2 bytes, 网络字节序)
+ uint32_t ssrc; // SSRC (4 bytes, 网络字节序)
+ uint32_t timestamp; // 时间戳 (4 bytes, 网络字节序)
+ uint32_t sequence; // 序列号 (4 bytes, 网络字节序)
+ uint8_t *payload; // 加密负载数据指针
+ uint16_t payload_size; // 负载数据大小
+} ln_udp_packet_t;
+
+/* UDP套接字全局变量 */
+static int g_udp_socket = -1;
+static volatile bool g_udp_thread_running = false;
+static uint32_t g_udp_thread_handle = 0;
+
+/* UDP数据包序列号和SSRC管理 */
+static uint32_t g_udp_ssrc = 0; // SSRC标识
+static uint32_t g_udp_sequence = 0; // 序列号(自动递增)
+
+/* 音频数据发送队列和线程 */
+#define AUDIO_SEND_QUEUE_SIZE 32 // 队列大小
+
+/* OGG 封装相关全局变量 */
+#define OGG_PACKETS_PER_FILE 50 // 每50个数据包打包成一个文件
+#define OGG_PACKET_CACHE_SIZE 32 // 数据包缓存大小(用于处理乱序)
+#define OGG_OPUS_ENCODE_HEADER_SIZE 8 // Opus 编码头大小(前8字节)
+#define ENABLE_OPUS_RAW_DEBUG 1 // 启用 Opus 原始数据保存调试(1=启用,0=禁用)
+
+static MqttOggContextHandle g_ogg_ctx_handle = NULL; // OGG 上下文句柄(不透明指针)
+static FILE *g_ogg_file = NULL; // 当前 OGG 文件句柄
+static uint32_t g_ogg_packet_count = 0; // 当前文件的数据包计数
+static uint32_t g_ogg_file_index = 0; // 文件序号
+static bool g_ogg_initialized = false; // OGG 上下文是否已初始化
+static char g_completed_ogg_filename[128] = {0}; // 已完成的 OGG 文件名(用于播放)
+
+/* Opus 原始数据调试相关全局变量 */
+static FILE *g_opus_debug_file = NULL; // Opus 调试文件句柄
+static uint32_t g_opus_debug_packet_count = 0; // Opus 调试文件的数据包计数
+static uint32_t g_opus_debug_file_index = 0; // Opus 调试文件序号
+#define OPUS_DEBUG_PCM_BUF_SAMPLES 5760 // 单帧解码 PCM 缓冲(120ms@48kHz)
+static short g_opus_debug_pcm_buf[OPUS_DEBUG_PCM_BUF_SAMPLES];
+static FILE *g_opus_debug_pcm_file = NULL; // 解码 PCM 测试输出文件(追加)
+
+/* 数据包缓存结构(用于处理乱序接收) */
+typedef struct {
+ uint32_t sequence; // 序列号
+ uint8_t *data; // 数据指针(动态分配)
+ uint32_t data_size; // 数据大小
+ bool valid; // 是否有效
+} ogg_packet_cache_t;
+
+static ogg_packet_cache_t g_ogg_packet_cache[OGG_PACKET_CACHE_SIZE] = {0}; // 数据包缓存
+static uint32_t g_ogg_expected_sequence = 0; // 期望的下一个序列号(0表示未初始化)
+static uint32_t g_ogg_out_of_order_count = 0; // 连续错序计数器(用于检测丢包)
+#define OGG_MAX_OUT_OF_ORDER_COUNT 5 // 最大连续错序次数,超过后跳过一包
+#define AUDIO_SEND_MAX_DATA_SIZE 0x800 // 最大音频数据大小(与 LN_MQTT_RECORD_MAX_FRAME 一致)
+
+/* 音频编码类型:入队时 data 的格式 */
+#define AUDIO_SEND_ENCODING_OPUS 0 // 已是 Opus,直接发送
+#define AUDIO_SEND_ENCODING_PCM 1 // PCM,发送前用 opus_pcm_to_frame_encode_packet 编码为 Opus
+
+/* PCM 编码默认参数(encoding==PCM 时使用):输入为 16kHz 单声道、16-bit 小端 */
+#define AUDIO_SEND_PCM_SAMPLE_RATE 16000 /* 采样率 16kHz */
+#define AUDIO_SEND_PCM_CHANNELS 1 /* 单声道 */
+#define AUDIO_SEND_PCM_BITRATE 64000
+#define AUDIO_SEND_PCM_APPLICATION 2049 /* Opus: OPUS_APPLICATION_AUDIO,必须为 2048/2049/2051 之一 */
+#define AUDIO_SEND_PCM_FRAME_MS 60 // 每帧 60ms,切割固定长度再编码
+/* 60ms 对应字节数:sample_rate * frame_ms/1000 * channels * 2(bytes/sample) */
+#define AUDIO_SEND_PCM_FRAME_BYTES ((uint32_t)((AUDIO_SEND_PCM_SAMPLE_RATE) * (AUDIO_SEND_PCM_FRAME_MS) / 1000 * (AUDIO_SEND_PCM_CHANNELS) * 2))
+#define AUDIO_SEND_PCM_FRAME_SAMPLES ((int)((AUDIO_SEND_PCM_SAMPLE_RATE) * (AUDIO_SEND_PCM_FRAME_MS) / 1000))
+/* 动态分配容量:帧数可调以增大缓存(约 6s @ 60ms/帧) */
+#define AUDIO_SEND_PCM_CACHE_ALLOC_FRAMES 100
+#define AUDIO_SEND_PCM_CACHE_ALLOC_SIZE ((AUDIO_SEND_PCM_CACHE_ALLOC_FRAMES) * (AUDIO_SEND_PCM_FRAME_BYTES) + (AUDIO_SEND_MAX_DATA_SIZE))
+
+/* PCM 发送缓存:动态分配,新数据追加,满 60ms 切割编码,余量保留 */
+static uint8_t *g_pcm_send_cache = NULL;
+static uint32_t g_pcm_send_cache_capacity = 0; /* 已分配容量(字节) */
+static uint32_t g_pcm_send_cache_size = 0; /* 当前有效数据长度 */
+
+/* 音频数据消息结构体 */
+typedef struct {
+ uint8_t *data; // 音频数据指针(动态分配)
+ uint32_t size; // 数据大小(字节)
+ uint8_t encoding; // 0=Opus,1=PCM(发送前编码为 Opus)
+} audio_send_msg_t;
+
+static unsigned long g_audio_send_queue = 0xFFFFFFFF; // 消息队列句柄
+static volatile bool g_audio_send_thread_running = false;
+static uint32_t g_audio_send_thread_handle = 0;
+
+/* 前向声明 */
+static void ln_udp_recv_thread(void *arg);
+int ln_udp_process_received_data(const uint8_t *data, uint16_t data_len);
+int ln_udp_handle_decrypted_payload(uint32_t sequence, uint8_t *decrypted_data, uint16_t payload_len);
+int ln_udp_unpack_packet(const uint8_t *data, uint16_t data_len, ln_udp_packet_t *packet);
+void ln_udp_free_packet(ln_udp_packet_t *packet);
+void ln_udp_close_socket(void);
+static void ln_udp_audio_send_thread(void *arg);
+static void create_audio_send_queue(void);
+/* OGG 封装相关函数声明 */
+static int ln_udp_ogg_handle_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size);
+static void ln_udp_ogg_cache_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size);
+static int ln_udp_ogg_write_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size);
+static void ln_udp_ogg_flush_cache(void);
+static void ln_udp_ogg_complete_current_file(void);
+static int ln_udp_ogg_create_new_file(void);
+
+#if USE_DUAL_STREAM_INTERFACE
+/* 双流接口相关函数声明 */
+static int ln_udp_dual_stream_handle_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size);
+static int ln_udp_dual_stream_decode_and_send(uint32_t sequence, const uint8_t *data, uint32_t data_size);
+static bool ln_udp_dual_stream_flush_cache(void);
+#endif /* USE_DUAL_STREAM_INTERFACE */
+/* Opus 原始数据调试相关函数声明 */
+static int ln_udp_opus_debug_create_new_file(void);
+static void ln_udp_opus_debug_complete_current_file(void);
+static int ln_udp_opus_debug_write_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size);
+/* Opus 数据包解析函数声明 */
+static int ln_udp_parse_opus_packet(const uint8_t *data, uint32_t data_size,
+ const uint8_t **opus_data, uint32_t *opus_data_size);
+
+
+
+/**
+ * @brief 处理已解密的负载数据(供 UDP/TCP 共享)
+ * @param sequence 数据包序列号
+ * @param decrypted_data 已解密数据(所有权转移给本函数)
+ * @param payload_len 数据长度
+ * @return 0 成功,-1 失败
+ */
+int ln_udp_handle_decrypted_payload(uint32_t sequence, uint8_t *decrypted_data, uint16_t payload_len)
+{
+ if (decrypted_data == NULL || payload_len == 0) {
+ return -1;
+ }
+
+#if USE_DUAL_STREAM_INTERFACE
+ if (ln_udp_dual_stream_handle_packet(sequence, decrypted_data, payload_len) != 0) {
+ LN_MQTT_ERROR("Failed to handle dual stream packet (sequence=%u)\n", sequence);
+ free(decrypted_data);
+ return -1;
+ }
+#else
+ if (ln_udp_ogg_handle_packet(sequence, decrypted_data, payload_len) != 0) {
+ LN_MQTT_ERROR("Failed to handle OGG packet (sequence=%u)\n", sequence);
+ free(decrypted_data);
+ return -1;
+ }
+#endif
+
+ return 0;
+}
+
+/**
+ * @brief 处理接收到的UDP数据(解包、解密)
+ * @param data 原始接收数据
+ * @param data_len 数据长度
+ * @return 0 成功,-1 失败
+ */
+int ln_udp_process_received_data(const uint8_t *data, uint16_t data_len)
{
- g_udp_sequence = sequence;
+ ln_udp_packet_t packet;
+ memset(&packet, 0, sizeof(packet));
+
+ // 1. 解包数据包
+ if (ln_udp_unpack_packet(data, data_len, &packet) != 0) {
+ LN_MQTT_ERROR("Failed to unpack packet\n");
+ return -1;
+ }
+
+ LN_MQTT_DEBUG("Packet unpacked: type=%d, flags=%d, ssrc=%u, timestamp=%u, sequence=%u, payload_len=%d\n",
+ packet.type, packet.flags, packet.ssrc, packet.timestamp, packet.sequence, packet.payload_len);
+
+ // 2. 获取UDP信息(用于解密)
+ ln_mqtt_udp_info_t udp_info;
+ if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
+ LN_MQTT_WARN("UDP info not available for decryption\n");
+ ln_udp_free_packet(&packet);
+ return -1;
+ }
+
+ // 3. 解密负载数据
+ if (packet.payload_len > 0 && packet.payload) {
+ // 分配解密数据缓冲区
+ uint8_t *decrypted_data = (uint8_t *)malloc(packet.payload_len);
+ if (!decrypted_data) {
+ LN_MQTT_ERROR("Failed to allocate memory for decrypted data\n");
+ ln_udp_free_packet(&packet);
+ return -1;
+ }
+
+ // 执行解密(nonce在函数内部构造)
+ if (ln_udp_decrypt_audio(udp_info.key, udp_info.nonce, packet.payload_len,
+ packet.timestamp, packet.sequence,
+ packet.payload, packet.payload_len, decrypted_data) != 0) {
+ LN_MQTT_ERROR("Failed to decrypt payload data\n");
+ free(decrypted_data);
+ ln_udp_free_packet(&packet);
+ return -1;
+ }
+ LN_MQTT_DEBUG("decrypted_data: ");
+
+ LN_MQTT_DEBUG("\n");
+
+ LN_MQTT_DEBUG("Payload decrypted successfully, size=%d bytes\n", packet.payload_len);
+
+ LN_MQTT_DEBUG("packet.sequence: %u\n", packet.sequence);
+
+ (void)ln_udp_handle_decrypted_payload(packet.sequence, decrypted_data, packet.payload_len);
+ } else {
+ LN_MQTT_DEBUG("Packet has no payload data\n");
+ }
+
+ // 4. 释放数据包
+ ln_udp_free_packet(&packet);
+
+ return 0;
}
-void set_udp_ssrc(uint32_t ssrc)
+/**
+ * @brief 解包UDP数据包
+ * @param data 原始数据缓冲区
+ * @param data_len 数据长度
+ * @param packet 输出的数据包结构体指针(payload字段需要外部释放)
+ * @return 0 成功,-1 失败
+ */
+int ln_udp_unpack_packet(const uint8_t *data, uint16_t data_len, ln_udp_packet_t *packet)
+{
+ if (!data || !packet || data_len < UDP_PACKET_HEADER_SIZE) {
+ LN_MQTT_WARN("Invalid parameters or data too short for unpack\n");
+ return -1;
+ }
+
+ memset(packet, 0, sizeof(ln_udp_packet_t));
+
+ // 解析头部字段(网络字节序)
+ const uint8_t *ptr = data;
+ packet->type = ptr[0];
+ packet->flags = ptr[1];
+ packet->payload_len = lwip_ntohs(*(uint16_t *)(ptr + 2));
+ packet->ssrc = lwip_ntohl(*(uint32_t *)(ptr + 4));
+ packet->timestamp = lwip_ntohl(*(uint32_t *)(ptr + 8));
+ packet->sequence = lwip_ntohl(*(uint32_t *)(ptr + 12));
+
+ // 验证负载长度
+ uint16_t expected_len = UDP_PACKET_HEADER_SIZE + packet->payload_len;
+ if (data_len < expected_len) {
+ LN_MQTT_WARN("Data length mismatch: expected %d, got %d\n", expected_len, data_len);
+ return -1;
+ }
+
+ // 分配并复制负载数据
+ if (packet->payload_len > 0) {
+ packet->payload = (uint8_t *)malloc(packet->payload_len);
+ if (!packet->payload) {
+ LN_MQTT_ERROR("Failed to allocate memory for payload\n");
+ return -1;
+ }
+ memcpy(packet->payload, ptr + UDP_PACKET_HEADER_SIZE, packet->payload_len);
+ packet->payload_size = packet->payload_len;
+ } else {
+ packet->payload = NULL;
+ packet->payload_size = 0;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief 封包UDP数据包
+ * @param packet 数据包结构体指针
+ * @param buffer 输出缓冲区指针(由调用者分配)
+ * @param buffer_size 缓冲区大小
+ * @param out_len 输出的实际数据长度
+ * @return 0 成功,-1 失败
+ */
+int ln_udp_pack_packet(const ln_udp_packet_t *packet, uint8_t *buffer, uint16_t buffer_size, uint16_t *out_len)
+{
+ if (!packet || !buffer || !out_len) {
+ LN_MQTT_WARN("Invalid parameters for pack\n");
+ return -1;
+ }
+
+ // 计算所需缓冲区大小
+ uint16_t total_len = UDP_PACKET_HEADER_SIZE + packet->payload_len;
+ if (buffer_size < total_len) {
+ LN_MQTT_WARN("Buffer too small: need %d, have %d\n", total_len, buffer_size);
+ return -1;
+ }
+
+ // 打包头部字段(转换为网络字节序)
+ uint8_t *ptr = buffer;
+ ptr[0] = packet->type;
+ ptr[1] = packet->flags;
+ *(uint16_t *)(ptr + 2) = lwip_htons(packet->payload_len);
+ *(uint32_t *)(ptr + 4) = lwip_htonl(packet->ssrc);
+ *(uint32_t *)(ptr + 8) = lwip_htonl(packet->timestamp);
+ *(uint32_t *)(ptr + 12) = lwip_htonl(packet->sequence);
+
+ // 复制负载数据
+ if (packet->payload_len > 0 && packet->payload) {
+ memcpy(ptr + UDP_PACKET_HEADER_SIZE, packet->payload, packet->payload_len);
+ }
+
+ *out_len = total_len;
+ return 0;
+}
+
+/**
+ * @brief 释放数据包结构体的负载数据
+ * @param packet 数据包结构体指针
+ */
+void ln_udp_free_packet(ln_udp_packet_t *packet)
+{
+ if (packet && packet->payload) {
+ free(packet->payload);
+ packet->payload = NULL;
+ packet->payload_size = 0;
+ }
+}
+
+// ==================== OGG 封装处理函数(支持乱序数据包缓存和排序)====================
+
+/**
+ * @brief 清空数据包缓存
+ */
+static void ln_udp_ogg_clear_cache(void)
+{
+ for (int i = 0; i < OGG_PACKET_CACHE_SIZE; i++) {
+ if (g_ogg_packet_cache[i].valid && g_ogg_packet_cache[i].data != NULL) {
+ free(g_ogg_packet_cache[i].data);
+ g_ogg_packet_cache[i].data = NULL;
+ }
+ g_ogg_packet_cache[i].valid = false;
+ g_ogg_packet_cache[i].sequence = 0;
+ g_ogg_packet_cache[i].data_size = 0;
+ }
+}
+
+/**
+ * @brief 将数据包缓存(用于处理乱序接收)
+ * @param sequence 序列号
+ * @param data 数据指针(会被复制,调用者可以释放)
+ * @param data_size 数据大小
+ */
+static void ln_udp_ogg_cache_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size)
+{
+ // 查找空闲的缓存槽
+ int empty_slot = -1;
+ for (int i = 0; i < OGG_PACKET_CACHE_SIZE; i++) {
+ if (!g_ogg_packet_cache[i].valid) {
+ empty_slot = i;
+ break;
+ }
+ }
+
+ if (empty_slot < 0) {
+ LN_MQTT_WARN("OGG cache full, dropping packet sequence=%u\n", sequence);
+ ln_udp_ogg_clear_cache();
+ return;
+ }
+
+ // 分配内存并复制数据
+ uint8_t *cached_data = (uint8_t *)malloc(data_size);
+ if (cached_data == NULL) {
+ LN_MQTT_ERROR("Failed to allocate memory for cached packet sequence=%u\n", sequence);
+ return;
+ }
+
+ memcpy(cached_data, data, data_size);
+
+ // 保存到缓存
+ g_ogg_packet_cache[empty_slot].sequence = sequence;
+ g_ogg_packet_cache[empty_slot].data = cached_data;
+ g_ogg_packet_cache[empty_slot].data_size = data_size;
+ g_ogg_packet_cache[empty_slot].valid = true;
+
+ LN_MQTT_DEBUG("Cached packet sequence=%u (slot=%d)\n", sequence, empty_slot);
+}
+
+/**
+ * @brief 创建新的 Opus 调试文件(直接保存 Opus 原始数据)
+ * @return 0 成功,-1 失败
+ */
+static int ln_udp_opus_debug_create_new_file(void)
+{
+#if ENABLE_OPUS_RAW_DEBUG
+ // 创建新文件(使用时间戳和序号命名)
+ time_t now = time(NULL);
+ struct tm *tm_info = localtime(&now);
+ char filename[128];
+ snprintf(filename, sizeof(filename), "/user/udp_opus_raw_%04d%02d%02d_%02d%02d%02d_%03u.opus",
+ tm_info->tm_year + 1900, tm_info->tm_mon + 1, tm_info->tm_mday,
+ tm_info->tm_hour, tm_info->tm_min, tm_info->tm_sec, g_opus_debug_file_index);
+
+ g_opus_debug_file = fopen(filename, "wb");
+ if (g_opus_debug_file == NULL) {
+ LN_MQTT_ERROR("Failed to open Opus debug file: %s\n", filename);
+ return -1;
+ }
+
+ g_opus_debug_packet_count = 0;
+ g_opus_debug_file_index++;
+ LN_MQTT_DEBUG("Created new Opus debug file: %s (index: %u)\n", filename, g_opus_debug_file_index - 1);
+
+ return 0;
+#else
+ return -1;
+#endif
+}
+
+/**
+ * @brief 完成当前 Opus 调试文件
+ */
+static void ln_udp_opus_debug_complete_current_file(void)
+{
+#if ENABLE_OPUS_RAW_DEBUG
+ if (g_opus_debug_file == NULL) {
+ return;
+ }
+
+ fclose(g_opus_debug_file);
+ g_opus_debug_file = NULL;
+ g_opus_debug_packet_count = 0;
+ LN_MQTT_DEBUG("Completed Opus debug file #%u\n", g_opus_debug_file_index - 1);
+#endif
+}
+
+/**
+ * @brief 解析 Opus 数据包,找到实际 Opus 编码数据的起始位置和大小
+ * @param data 完整的 Opus 数据包(包含 TOC 字节和可能的帧长度表)
+ * @param data_size 数据包总大小
+ * @param opus_data 输出的实际 Opus 数据起始指针
+ * @param opus_data_size 输出的实际 Opus 数据大小
+ * @return 0 成功,-1 失败
+ * @note 根据 RFC 6716 Opus 编码标准解析
+ */
+static int ln_udp_parse_opus_packet(const uint8_t *data, uint32_t data_size,
+ const uint8_t **opus_data, uint32_t *opus_data_size)
+{
+ if (!data || data_size == 0 || !opus_data || !opus_data_size) {
+ LN_MQTT_WARN("Invalid parameters for Opus packet parsing\n");
+ return -1;
+ }
+
+ // 至少需要 TOC 字节
+ if (data_size < 1) {
+ LN_MQTT_WARN("Opus packet too small (size=%u)\n", data_size);
+ return -1;
+ }
+
+ const uint8_t *ptr = data;
+ uint32_t remaining = data_size;
+
+ // 1. 读取 TOC 字节
+ uint8_t toc = ptr[0];
+ ptr++;
+ remaining--;
+
+ // 2. 解析帧计数编码(bit 3-7)
+ uint8_t frame_count_code = (toc >> 3) & 0x1F; // bit 3-7
+ uint8_t frame_count = 0;
+ uint32_t header_size = 1; // TOC 字节
+
+ // 3. 判断是单帧还是多帧
+ if (frame_count_code < 16) {
+ // 单帧:帧计数 = 编码值(0表示1帧,1-15表示对应帧数)
+ if (frame_count_code == 0) {
+ frame_count = 1; // 编码值0表示单帧
+ } else {
+ frame_count = frame_count_code;
+ }
+ } else {
+ // 多帧:需要读取帧计数字节
+ if (remaining < 1) {
+ LN_MQTT_WARN("Opus packet too small for frame count byte\n");
+ return -1;
+ }
+ frame_count = frame_count_code - 16 + 1 + ptr[0];
+ ptr++;
+ remaining--;
+ header_size++;
+ }
+
+ // 4. 如果是多帧,需要读取帧长度表(但不跳过数据)
+ if (frame_count > 1) {
+ // 多帧数据包需要帧长度表
+ // 每个帧长度使用可变长度编码(1-2字节)
+ // 如果长度 < 252,使用1字节;否则使用2字节(0xFC + 实际长度)
+ // 注意:我们只读取长度值,不跳过帧数据,因为所有帧数据是连续存储的
+ for (uint8_t i = 0; i < frame_count - 1; i++) {
+ if (remaining < 1) {
+ LN_MQTT_WARN("Opus packet too small for frame length table\n");
+ return -1;
+ }
+
+ if (ptr[0] < 252) {
+ // 1字节编码
+ ptr++;
+ remaining--;
+ header_size++;
+ } else {
+ // 2字节编码:0xFC + 实际长度(大端序)
+ if (remaining < 2) {
+ LN_MQTT_WARN("Opus packet too small for 2-byte frame length\n");
+ return -1;
+ }
+ ptr += 2;
+ remaining -= 2;
+ header_size += 2;
+ }
+ }
+ }
+
+ // 5. 现在 header_size 包含了所有头部信息(TOC + 帧计数 + 帧长度表)
+ // 从 header_size 之后的所有数据都是 Opus 编码数据(包含所有帧的数据)
+ if (header_size >= data_size) {
+ LN_MQTT_WARN("Opus header size (%u) >= total size (%u)\n", header_size, data_size);
+ return -1;
+ }
+
+ *opus_data = data + header_size;
+ *opus_data_size = data_size - header_size;
+
+ LN_MQTT_DEBUG("Opus parsed: frame_count=%d, header_size=%u, opus_data_size=%u\n",
+ frame_count, header_size, *opus_data_size);
+
+ return 0;
+}
+
+/**
+ * @brief 写入 Opus 原始数据到调试文件(不进行 OGG 封装)
+ * @param sequence 序列号
+ * @param data 数据指针(包含 Opus TOC 字节和可能的帧长度表)
+ * @param data_size 数据大小
+ * @return 0 成功,-1 失败
+ */
+static int ln_udp_opus_debug_write_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size)
+{
+#if ENABLE_OPUS_RAW_DEBUG
+ // 检查是否需要创建新文件
+ if (g_opus_debug_file == NULL || g_opus_debug_packet_count >= OGG_PACKETS_PER_FILE) {
+ // 完成当前文件
+ if (g_opus_debug_file != NULL) {
+ ln_udp_opus_debug_complete_current_file();
+ }
+
+ // 创建新文件
+ if (ln_udp_opus_debug_create_new_file() != 0) {
+ return -1;
+ }
+ }
+ LN_MQTT_DEBUG("opus debug data: ");
+ for (int i = 0; i < data_size; i++) {
+ LN_MQTT_DEBUG("%02X ", data[i]);
+ }
+ LN_MQTT_DEBUG("\n");
+
+ // 解析 Opus 数据包(用于验证和日志输出,但不影响保存)
+ const uint8_t *opus_data = NULL;
+ uint32_t opus_data_size = 0;
+ int parse_ret = ln_udp_parse_opus_packet(data, data_size, &opus_data, &opus_data_size);
+ if (parse_ret == 0) {
+ LN_MQTT_DEBUG("Opus debug: Parsed packet sequence=%u, total_size=%u, opus_data_size=%u\n",
+ sequence, data_size, opus_data_size);
+ } else {
+ LN_MQTT_WARN("Opus debug: Parse warning (sequence=%u, size=%u), but saving raw data anyway\n",
+ sequence, data_size);
+ }
+
+ /* 调用 opus 解码接口测试:完整包 data/data_size 送入解码 */
+ {
+ int pcm_samples = 0;
+ int dec_ret = opus_frame_to_pcm_decode_packet(
+ data, (int)data_size,
+ 16000, 1,
+ g_opus_debug_pcm_buf, OPUS_DEBUG_PCM_BUF_SAMPLES,
+ &pcm_samples);
+ if (dec_ret == 0) {
+ LN_MQTT_DEBUG("Opus decode test OK sequence=%u pcm_samples=%d\n", sequence, pcm_samples);
+ if (g_opus_debug_pcm_file == NULL) {
+ g_opus_debug_pcm_file = fopen("user/udp_opus_debug.pcm", "ab");
+ if (g_opus_debug_pcm_file != NULL) {
+ LN_MQTT_DEBUG("Opus decode PCM output: udp_opus_debug.pcm (append)\n");
+ }
+ }
+ if (g_opus_debug_pcm_file != NULL && pcm_samples > 0) {
+ size_t n = fwrite(g_opus_debug_pcm_buf, sizeof(short), (size_t)pcm_samples, g_opus_debug_pcm_file);
+ if (n != (size_t)pcm_samples) {
+ LN_MQTT_DEBUG("Opus decode PCM write short: %zu/%d\n", n, pcm_samples);
+ }
+ fflush(g_opus_debug_pcm_file);
+ }
+ fclose(g_opus_debug_pcm_file);
+ g_opus_debug_pcm_file = NULL;
+ } else {
+ LN_MQTT_ERROR("Opus decode test FAIL sequence=%u\n", sequence);
+ }
+ }
+
+ // 保存完整的原始数据(包含 TOC 字节和帧长度表)
+ size_t written = fwrite(data, 1, data_size, g_opus_debug_file);
+ if (written != data_size) {
+ LN_MQTT_ERROR("Opus debug: Failed to write data (sequence=%u, written=%zu, expected=%u)\n",
+ sequence, written, data_size);
+ return -1;
+ }
+
+ fflush(g_opus_debug_file); // 立即刷新到文件
+
+ g_opus_debug_packet_count++;
+ LN_MQTT_DEBUG("Opus debug: Written packet sequence=%u (%u/%u, raw_size=%u bytes)\n",
+ sequence, g_opus_debug_packet_count, OGG_PACKETS_PER_FILE, data_size);
+
+ return 0;
+#else
+ return 0; // 未启用时直接返回成功
+#endif
+}
+
+/**
+ * @brief 写入数据包到 OGG 文件
+ * @param sequence 序列号
+ * @param data 数据指针
+ * @param data_size 数据大小
+ * @return 0 成功,-1 失败
+ */
+static int ln_udp_ogg_write_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size)
+{
+ // 调试模式:同时保存 Opus 原始数据
+#if ENABLE_OPUS_RAW_DEBUG
+ ln_udp_opus_debug_write_packet(sequence, data, data_size);
+#endif
+
+ // 检查是否需要创建新文件
+ if (!g_ogg_initialized || g_ogg_packet_count >= OGG_PACKETS_PER_FILE) {
+ // 完成当前文件
+ if (g_ogg_initialized) {
+ ln_udp_ogg_complete_current_file();
+ }
+
+ // 创建新文件
+ if (ln_udp_ogg_create_new_file() != 0) {
+ return -1;
+ }
+ }
+
+ // 写入数据包
+ if (g_ogg_ctx_handle == NULL) {
+ LN_MQTT_ERROR("OGG context handle is null\n");
+ return -1;
+ }
+ if (MqttOggEncapsulationWriteHandle(g_ogg_ctx_handle, data, data_size, g_ogg_file, false) != 0) {
+ LN_MQTT_ERROR("Failed to write OGG data (sequence=%u)\n", sequence);
+ return -1;
+ }
+
+ g_ogg_packet_count++;
+ LN_MQTT_DEBUG("Written packet sequence=%u (%u/%u to OGG file)\n",
+ sequence, g_ogg_packet_count, OGG_PACKETS_PER_FILE);
+
+ return 0;
+}
+
+/**
+ * @brief 刷新缓存:尝试按顺序写入缓存中的数据包
+ */
+static void ln_udp_ogg_flush_cache(void)
+{
+ bool found = true;
+ while (found) {
+ found = false;
+ // 查找期望的下一个序列号
+ for (int i = 0; i < OGG_PACKET_CACHE_SIZE; i++) {
+ if (g_ogg_packet_cache[i].valid &&
+ g_ogg_packet_cache[i].sequence == g_ogg_expected_sequence) {
+ // 找到期望的包,写入
+ if (ln_udp_ogg_write_packet(g_ogg_packet_cache[i].sequence,
+ g_ogg_packet_cache[i].data,
+ g_ogg_packet_cache[i].data_size) == 0) {
+ // 更新期望的序列号
+ g_ogg_expected_sequence++;
+ // 释放缓存
+ free(g_ogg_packet_cache[i].data);
+ g_ogg_packet_cache[i].data = NULL;
+ g_ogg_packet_cache[i].valid = false;
+ g_ogg_packet_cache[i].sequence = 0;
+ g_ogg_packet_cache[i].data_size = 0;
+ found = true;
+ LN_MQTT_DEBUG("Flushed cached packet sequence=%u\n",
+ g_ogg_expected_sequence - 1);
+ break; // 重新开始查找
+ } else {
+ // 写入失败,保留在缓存中
+ break;
+ }
+ }
+ }
+ }
+}
+
+/**
+ * @brief 完成当前 OGG 文件并播放
+ */
+static void ln_udp_ogg_complete_current_file(void)
+{
+ if (!g_ogg_initialized || g_ogg_file == NULL) {
+ return;
+ }
+
+ // 写入结束标志并完成封装
+ if (g_ogg_ctx_handle != NULL) {
+ uint8_t empty_data[8] = {0}; // 至少需要8字节的编码头
+ MqttOggEncapsulationWriteHandle(g_ogg_ctx_handle, empty_data, 8, g_ogg_file, true);
+ MqttOggEncapsulationFinishHandle(g_ogg_ctx_handle, g_ogg_file);
+ }
+ fclose(g_ogg_file);
+ g_ogg_file = NULL;
+ g_ogg_initialized = false;
+
+ LN_MQTT_INFO("Completed OGG file #%u with %u packets: %s\n",
+ g_ogg_file_index - 1, g_ogg_packet_count, g_completed_ogg_filename);
+
+ // 使用 MQTT 播放接口播放完成的文件
+ if (g_completed_ogg_filename[0] != '\0') {
+ int32_t play_ret = MQTT_PlayAudioFile(g_completed_ogg_filename, NULL, NULL);
+ if (play_ret == 0) {
+ LN_MQTT_INFO("Started playing OGG file: %s\n", g_completed_ogg_filename);
+ } else {
+ LN_MQTT_ERROR("Failed to play OGG file: %s (ret=%d)\n",
+ g_completed_ogg_filename, play_ret);
+ }
+ g_completed_ogg_filename[0] = '\0';
+ }
+}
+
+/**
+ * @brief 创建新的 OGG 文件
+ * @return 0 成功,-1 失败
+ */
+static int ln_udp_ogg_create_new_file(void)
+{
+ // 创建新文件(使用时间戳和序号命名)
+ time_t now = time(NULL);
+ struct tm *tm_info = localtime(&now);
+ char filename[128];
+ snprintf(filename, sizeof(filename), "/user/udp_audio_%04d%02d%02d_%02d%02d%02d_%03u.ogg",
+ tm_info->tm_year + 1900, tm_info->tm_mon + 1, tm_info->tm_mday,
+ tm_info->tm_hour, tm_info->tm_min, tm_info->tm_sec, g_ogg_file_index);
+
+ // 保存文件名(用于后续播放)
+ strncpy(g_completed_ogg_filename, filename, sizeof(g_completed_ogg_filename) - 1);
+ g_completed_ogg_filename[sizeof(g_completed_ogg_filename) - 1] = '\0';
+
+ g_ogg_file = fopen(filename, "wb");
+ if (g_ogg_file == NULL) {
+ LN_MQTT_ERROR("Failed to open OGG file: %s\n", filename);
+ g_completed_ogg_filename[0] = '\0';
+ return -1;
+ }
+
+ // 获取 OGG 上下文句柄(如果尚未获取)
+ if (g_ogg_ctx_handle == NULL) {
+ g_ogg_ctx_handle = MqttOggGetContext();
+ if (g_ogg_ctx_handle == NULL) {
+ LN_MQTT_ERROR("Failed to get OGG context handle\n");
+ fclose(g_ogg_file);
+ g_ogg_file = NULL;
+ g_completed_ogg_filename[0] = '\0';
+ return -1;
+ }
+ }
+
+ // 初始化 OGG 上下文
+ if (MqttOggEncapsulationInitHandle(g_ogg_ctx_handle, g_ogg_file, 16000, 1) != 0) {
+ LN_MQTT_ERROR("Failed to initialize OGG context\n");
+ fclose(g_ogg_file);
+ g_ogg_file = NULL;
+ g_completed_ogg_filename[0] = '\0';
+ return -1;
+ }
+
+ g_ogg_initialized = true;
+ g_ogg_packet_count = 0;
+ g_ogg_file_index++;
+ LN_MQTT_DEBUG("Created new OGG file: %s (index: %u)\n", filename, g_ogg_file_index - 1);
+
+ return 0;
+}
+
+/**
+ * @brief 处理 OGG 数据包(支持乱序接收和缓存)
+ * @param sequence 数据包序列号
+ * @param data 解密后的数据(所有权转移,函数内部负责释放)
+ * @param data_size 数据大小
+ * @return 0 成功,-1 失败
+ * @note 此函数会接管 data 的所有权,调用者不应再释放 data
+ */
+static int ln_udp_ogg_handle_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size)
+{
+ // 初始化期望序列号(首次接收)
+ if (g_ogg_expected_sequence == 0) {
+ g_ogg_expected_sequence = sequence;
+ g_ogg_out_of_order_count = 0; // 重置错序计数器
+ LN_MQTT_DEBUG("Initialized expected sequence to %u\n", sequence);
+ }
+
+ // 检查是否是期望的下一个包
+ if (sequence == g_ogg_expected_sequence) {
+ // 是期望的包,直接写入
+ if (ln_udp_ogg_write_packet(sequence, data, data_size) == 0) {
+ g_ogg_expected_sequence++;
+ g_ogg_out_of_order_count = 0; // 重置错序计数器(收到期望的包)
+ free((void *)data); // 释放数据(所有权已转移)
+
+ // 尝试刷新缓存中的后续包
+ ln_udp_ogg_flush_cache();
+ return 0;
+ } else {
+ // 写入失败,缓存这个包
+ ln_udp_ogg_cache_packet(sequence, data, data_size);
+ free((void *)data);
+ return -1;
+ }
+ } else if (sequence > g_ogg_expected_sequence) {
+ // 是未来的包,缓存起来
+ g_ogg_out_of_order_count++; // 增加错序计数器
+ LN_MQTT_WARN("Received future packet sequence=%u (expected=%u), caching (out_of_order_count=%u)\n",
+ sequence, g_ogg_expected_sequence, g_ogg_out_of_order_count);
+
+ // 如果连续错序超过阈值,跳过期望的序列号(避免丢包时一直无法正常输出)
+ if (g_ogg_out_of_order_count > OGG_MAX_OUT_OF_ORDER_COUNT) {
+ uint32_t old_expected = g_ogg_expected_sequence;
+ LN_MQTT_DEBUG("Out of order count exceeded %d, skipping sequence %u\n",
+ OGG_MAX_OUT_OF_ORDER_COUNT, g_ogg_expected_sequence);
+
+ // 1. 先将期望序号往后加一(跳过丢失的包)
+ g_ogg_expected_sequence++;
+ g_ogg_out_of_order_count = 0; // 重置计数器
+
+ // 2. 处理缓存中的包(尝试写入缓存中所有能写入的连续包)
+ ln_udp_ogg_flush_cache();
+
+ // 3. 再尝试写入当前包
+ if (sequence == g_ogg_expected_sequence) {
+ // 当前包正好是期望的包,直接写入
+ if (ln_udp_ogg_write_packet(sequence, data, data_size) == 0) {
+ g_ogg_expected_sequence++;
+ free((void *)data);
+ // 继续刷新缓存中的后续包
+ ln_udp_ogg_flush_cache();
+ LN_MQTT_DEBUG("Successfully wrote skipped packet sequence=%u (old_expected=%u)\n",
+ sequence, old_expected);
+ return 0;
+ } else {
+ // 写入失败,缓存这个包
+ ln_udp_ogg_cache_packet(sequence, data, data_size);
+ free((void *)data);
+ return -1;
+ }
+ } else if (sequence > g_ogg_expected_sequence) {
+ // 当前包仍然是未来的包,缓存起来
+ LN_MQTT_DEBUG("Current packet sequence=%u still ahead of expected=%u after skip, caching\n",
+ sequence, g_ogg_expected_sequence);
+ ln_udp_ogg_cache_packet(sequence, data, data_size);
+ free((void *)data);
+ return 0;
+ } else {
+ // 当前包已经是过去的包(在刷新缓存时已处理),丢弃
+ LN_MQTT_DEBUG("Current packet sequence=%u is now old (expected=%u), dropping\n",
+ sequence, g_ogg_expected_sequence);
+ free((void *)data);
+ return 0;
+ }
+ } else {
+ // 正常缓存未来包
+ ln_udp_ogg_cache_packet(sequence, data, data_size);
+ free((void *)data);
+ return 0;
+ }
+ } else {
+ // 是过去的包(重复或乱序),丢弃
+ LN_MQTT_DEBUG("Received old/duplicate packet sequence=%u (expected=%u), dropping\n",
+ sequence, g_ogg_expected_sequence);
+ free((void *)data);
+ return 0;
+ }
+}
+
+#if USE_DUAL_STREAM_INTERFACE
+// ==================== 双流接口处理函数(支持乱序数据包缓存和排序)====================
+
+/**
+ * @brief 解码 Opus 数据包并送入 AI_SendAudioDataToQueue
+ * @param sequence 序列号
+ * @param data 数据指针
+ * @param data_size 数据大小
+ * @return 0 成功,-1 失败
+ */
+static int ln_udp_dual_stream_decode_and_send(uint32_t sequence, const uint8_t *data, uint32_t data_size)
{
- g_udp_ssrc = ssrc;
+ int pcm_samples = 0;
+ int dec_ret = opus_frame_to_pcm_decode_packet(
+ data, (int)data_size,
+ 16000, 1,
+ g_opus_debug_pcm_buf, OPUS_DEBUG_PCM_BUF_SAMPLES,
+ &pcm_samples);
+
+ if (dec_ret == 0 && pcm_samples > 0) {
+ // 解码成功,将 PCM 数据送入 AI_SendAudioDataToQueue
+ uint32_t pcm_data_size = (uint32_t)(pcm_samples * sizeof(short));
+ int32_t send_ret = AI_SendAudioDataToQueue((const uint8_t *)g_opus_debug_pcm_buf, pcm_data_size);
+ if (send_ret == 0) {
+ LN_MQTT_DEBUG("Dual stream: Decoded and sent to queue: sequence=%u, pcm_samples=%d\n",
+ sequence, pcm_samples);
+ return 0;
+ } else {
+ LN_MQTT_ERROR("Dual stream: Failed to send decoded PCM to queue: sequence=%u, ret=%d\n",
+ sequence, (int)send_ret);
+ return -1;
+ }
+ } else {
+ LN_MQTT_ERROR("Dual stream: Opus decode failed: sequence=%u, ret=%d\n",
+ sequence, dec_ret);
+ return -1;
+ }
}
-
- /* 音频数据发送队列和线程 */
- #define AUDIO_SEND_QUEUE_SIZE 32 // 队列大小
-
- /* OGG 封装相关全局变量 */
- #define OGG_PACKETS_PER_FILE 50 // 每50个数据包打包成一个文件
- #define OGG_PACKET_CACHE_SIZE 32 // 数据包缓存大小(用于处理乱序)
- #define OGG_OPUS_ENCODE_HEADER_SIZE 8 // Opus 编码头大小(前8字节)
- #define ENABLE_OPUS_RAW_DEBUG 1 // 启用 Opus 原始数据保存调试(1=启用,0=禁用)
-
- static MqttOggContextHandle g_ogg_ctx_handle = NULL; // OGG 上下文句柄(不透明指针)
- static FILE *g_ogg_file = NULL; // 当前 OGG 文件句柄
- static uint32_t g_ogg_packet_count = 0; // 当前文件的数据包计数
- static uint32_t g_ogg_file_index = 0; // 文件序号
- static bool g_ogg_initialized = false; // OGG 上下文是否已初始化
- static char g_completed_ogg_filename[128] = {0}; // 已完成的 OGG 文件名(用于播放)
-
- /* Opus 原始数据调试相关全局变量 */
- static FILE *g_opus_debug_file = NULL; // Opus 调试文件句柄
- static uint32_t g_opus_debug_packet_count = 0; // Opus 调试文件的数据包计数
- static uint32_t g_opus_debug_file_index = 0; // Opus 调试文件序号
- #define OPUS_DEBUG_PCM_BUF_SAMPLES 5760 // 单帧解码 PCM 缓冲(120ms@48kHz)
- static short g_opus_debug_pcm_buf[OPUS_DEBUG_PCM_BUF_SAMPLES];
- static FILE *g_opus_debug_pcm_file = NULL; // 解码 PCM 测试输出文件(追加)
-
- /* 数据包缓存结构(用于处理乱序接收) */
- typedef struct {
- uint32_t sequence; // 序列号
- uint8_t *data; // 数据指针(动态分配)
- uint32_t data_size; // 数据大小
- bool valid; // 是否有效
- } ogg_packet_cache_t;
-
- static ogg_packet_cache_t g_ogg_packet_cache[OGG_PACKET_CACHE_SIZE] = {0}; // 数据包缓存
- static uint32_t g_ogg_expected_sequence = 0; // 期望的下一个序列号(0表示未初始化)
- static uint32_t g_ogg_out_of_order_count = 0; // 连续错序计数器(用于检测丢包)
- #define OGG_MAX_OUT_OF_ORDER_COUNT 5 // 最大连续错序次数,超过后跳过一包
- #define AUDIO_SEND_MAX_DATA_SIZE 0x800 // 最大音频数据大小(与 LN_MQTT_RECORD_MAX_FRAME 一致)
-
- /* 音频编码类型:入队时 data 的格式 */
- #define AUDIO_SEND_ENCODING_OPUS 0 // 已是 Opus,直接发送
- #define AUDIO_SEND_ENCODING_PCM 1 // PCM,发送前用 opus_pcm_to_frame_encode_packet 编码为 Opus
-
- /* PCM 编码默认参数(encoding==PCM 时使用):输入为 16kHz 单声道、16-bit 小端 */
- #define AUDIO_SEND_PCM_SAMPLE_RATE 16000 /* 采样率 16kHz */
- #define AUDIO_SEND_PCM_CHANNELS 1 /* 单声道 */
- #define AUDIO_SEND_PCM_BITRATE 64000
- #define AUDIO_SEND_PCM_APPLICATION 2049 /* Opus: OPUS_APPLICATION_AUDIO,必须为 2048/2049/2051 之一 */
- #define AUDIO_SEND_PCM_FRAME_MS 60 // 每帧 60ms,切割固定长度再编码
- /* 60ms 对应字节数:sample_rate * frame_ms/1000 * channels * 2(bytes/sample) */
- #define AUDIO_SEND_PCM_FRAME_BYTES ((uint32_t)((AUDIO_SEND_PCM_SAMPLE_RATE) * (AUDIO_SEND_PCM_FRAME_MS) / 1000 * (AUDIO_SEND_PCM_CHANNELS) * 2))
- #define AUDIO_SEND_PCM_FRAME_SAMPLES ((int)((AUDIO_SEND_PCM_SAMPLE_RATE) * (AUDIO_SEND_PCM_FRAME_MS) / 1000))
- /* 动态分配容量:帧数可调以增大缓存(约 6s @ 60ms/帧) */
- #define AUDIO_SEND_PCM_CACHE_ALLOC_FRAMES 100
- #define AUDIO_SEND_PCM_CACHE_ALLOC_SIZE ((AUDIO_SEND_PCM_CACHE_ALLOC_FRAMES) * (AUDIO_SEND_PCM_FRAME_BYTES) + (AUDIO_SEND_MAX_DATA_SIZE))
-
- /* PCM 发送缓存:动态分配,新数据追加,满 60ms 切割编码,余量保留 */
- static uint8_t *g_pcm_send_cache = NULL;
- static uint32_t g_pcm_send_cache_capacity = 0; /* 已分配容量(字节) */
- static uint32_t g_pcm_send_cache_size = 0; /* 当前有效数据长度 */
-
- /* 音频数据消息结构体 */
- typedef struct {
- uint8_t *data; // 音频数据指针(动态分配)
- uint32_t size; // 数据大小(字节)
- uint8_t encoding; // 0=Opus,1=PCM(发送前编码为 Opus)
- } audio_send_msg_t;
-
- static unsigned long g_audio_send_queue = 0xFFFFFFFF; // 消息队列句柄
- static volatile bool g_audio_send_thread_running = false;
- static uint32_t g_audio_send_thread_handle = 0;
-
- /* 前向声明 */
- static void ln_udp_recv_thread(void *arg);
- int ln_udp_process_received_data(const uint8_t *data, uint16_t data_len);
- int ln_udp_handle_decrypted_payload(uint32_t sequence, uint8_t *decrypted_data, uint16_t payload_len);
- int ln_udp_unpack_packet(const uint8_t *data, uint16_t data_len, ln_udp_packet_t *packet);
- void ln_udp_free_packet(ln_udp_packet_t *packet);
- void ln_udp_close_socket(void);
- static void ln_udp_audio_send_thread(void *arg);
- static void create_audio_send_queue(void);
- /* OGG 封装相关函数声明 */
- static int ln_udp_ogg_handle_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size);
- static void ln_udp_ogg_cache_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size);
- static int ln_udp_ogg_write_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size);
- static void ln_udp_ogg_flush_cache(void);
- static void ln_udp_ogg_complete_current_file(void);
- static int ln_udp_ogg_create_new_file(void);
-
- #if USE_DUAL_STREAM_INTERFACE
- /* 双流接口相关函数声明 */
- static int ln_udp_dual_stream_handle_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size);
- static int ln_udp_dual_stream_decode_and_send(uint32_t sequence, const uint8_t *data, uint32_t data_size);
- static bool ln_udp_dual_stream_flush_cache(void);
- #endif /* USE_DUAL_STREAM_INTERFACE */
- /* Opus 原始数据调试相关函数声明 */
- static int ln_udp_opus_debug_create_new_file(void);
- static void ln_udp_opus_debug_complete_current_file(void);
- static int ln_udp_opus_debug_write_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size);
- /* Opus 数据包解析函数声明 */
- static int ln_udp_parse_opus_packet(const uint8_t *data, uint32_t data_size,
- const uint8_t **opus_data, uint32_t *opus_data_size);
-
-
-
- /**
- * @brief 处理已解密的负载数据(供 UDP/TCP 共享)
- * @param sequence 数据包序列号
- * @param decrypted_data 已解密数据(所有权转移给本函数)
- * @param payload_len 数据长度
- * @return 0 成功,-1 失败
- */
- int ln_udp_handle_decrypted_payload(uint32_t sequence, uint8_t *decrypted_data, uint16_t payload_len)
- {
- if (decrypted_data == NULL || payload_len == 0) {
- return -1;
- }
-
- #if USE_DUAL_STREAM_INTERFACE
- if (ln_udp_dual_stream_handle_packet(sequence, decrypted_data, payload_len) != 0) {
- LN_MQTT_ERROR("Failed to handle dual stream packet (sequence=%u)\n", sequence);
- free(decrypted_data);
- return -1;
- }
- #else
- if (ln_udp_ogg_handle_packet(sequence, decrypted_data, payload_len) != 0) {
- LN_MQTT_ERROR("Failed to handle OGG packet (sequence=%u)\n", sequence);
- free(decrypted_data);
- return -1;
- }
- #endif
-
- return 0;
- }
-
- /**
- * @brief 处理接收到的UDP数据(解包、解密)
- * @param data 原始接收数据
- * @param data_len 数据长度
- * @return 0 成功,-1 失败
- */
- int ln_udp_process_received_data(const uint8_t *data, uint16_t data_len)
- {
- ln_udp_packet_t packet;
- memset(&packet, 0, sizeof(packet));
-
- // 1. 解包数据包
- if (ln_udp_unpack_packet(data, data_len, &packet) != 0) {
- LN_MQTT_ERROR("Failed to unpack packet\n");
- return -1;
- }
-
- LN_MQTT_DEBUG("Packet unpacked: type=%d, flags=%d, ssrc=%u, timestamp=%u, sequence=%u, payload_len=%d\n",
- packet.type, packet.flags, packet.ssrc, packet.timestamp, packet.sequence, packet.payload_len);
-
- // 2. 获取UDP信息(用于解密)
- ln_mqtt_udp_info_t udp_info;
- if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
- LN_MQTT_WARN("UDP info not available for decryption\n");
- ln_udp_free_packet(&packet);
- return -1;
- }
-
- // 3. 解密负载数据
- if (packet.payload_len > 0 && packet.payload) {
- // 分配解密数据缓冲区
- uint8_t *decrypted_data = (uint8_t *)malloc(packet.payload_len);
- if (!decrypted_data) {
- LN_MQTT_ERROR("Failed to allocate memory for decrypted data\n");
- ln_udp_free_packet(&packet);
- return -1;
- }
-
- // 执行解密(nonce在函数内部构造)
- if (ln_udp_decrypt_audio(udp_info.key, udp_info.nonce, packet.payload_len,
- packet.timestamp, packet.sequence,
- packet.payload, packet.payload_len, decrypted_data) != 0) {
- LN_MQTT_ERROR("Failed to decrypt payload data\n");
- free(decrypted_data);
- ln_udp_free_packet(&packet);
- return -1;
- }
- LN_MQTT_DEBUG("decrypted_data: ");
-
- LN_MQTT_DEBUG("\n");
-
- LN_MQTT_DEBUG("Payload decrypted successfully, size=%d bytes\n", packet.payload_len);
-
- LN_MQTT_DEBUG("packet.sequence: %u\n", packet.sequence);
-
- (void)ln_udp_handle_decrypted_payload(packet.sequence, decrypted_data, packet.payload_len);
- } else {
- LN_MQTT_DEBUG("Packet has no payload data\n");
- }
-
- // 4. 释放数据包
- ln_udp_free_packet(&packet);
-
- return 0;
- }
-
- /**
- * @brief 解包UDP数据包
- * @param data 原始数据缓冲区
- * @param data_len 数据长度
- * @param packet 输出的数据包结构体指针(payload字段需要外部释放)
- * @return 0 成功,-1 失败
- */
- int ln_udp_unpack_packet(const uint8_t *data, uint16_t data_len, ln_udp_packet_t *packet)
- {
- if (!data || !packet || data_len < UDP_PACKET_HEADER_SIZE) {
- LN_MQTT_WARN("Invalid parameters or data too short for unpack\n");
- return -1;
- }
-
- memset(packet, 0, sizeof(ln_udp_packet_t));
-
- // 解析头部字段(网络字节序)
- const uint8_t *ptr = data;
- packet->type = ptr[0];
- packet->flags = ptr[1];
- packet->payload_len = lwip_ntohs(*(uint16_t *)(ptr + 2));
- packet->ssrc = lwip_ntohl(*(uint32_t *)(ptr + 4));
- packet->timestamp = lwip_ntohl(*(uint32_t *)(ptr + 8));
- packet->sequence = lwip_ntohl(*(uint32_t *)(ptr + 12));
-
- // 验证负载长度
- uint16_t expected_len = UDP_PACKET_HEADER_SIZE + packet->payload_len;
- if (data_len < expected_len) {
- LN_MQTT_WARN("Data length mismatch: expected %d, got %d\n", expected_len, data_len);
- return -1;
- }
-
- // 分配并复制负载数据
- if (packet->payload_len > 0) {
- packet->payload = (uint8_t *)malloc(packet->payload_len);
- if (!packet->payload) {
- LN_MQTT_ERROR("Failed to allocate memory for payload\n");
- return -1;
- }
- memcpy(packet->payload, ptr + UDP_PACKET_HEADER_SIZE, packet->payload_len);
- packet->payload_size = packet->payload_len;
- } else {
- packet->payload = NULL;
- packet->payload_size = 0;
- }
-
- return 0;
- }
-
- /**
- * @brief 封包UDP数据包
- * @param packet 数据包结构体指针
- * @param buffer 输出缓冲区指针(由调用者分配)
- * @param buffer_size 缓冲区大小
- * @param out_len 输出的实际数据长度
- * @return 0 成功,-1 失败
- */
- int ln_udp_pack_packet(const ln_udp_packet_t *packet, uint8_t *buffer, uint16_t buffer_size, uint16_t *out_len)
- {
- if (!packet || !buffer || !out_len) {
- LN_MQTT_WARN("Invalid parameters for pack\n");
- return -1;
- }
-
- // 计算所需缓冲区大小
- uint16_t total_len = UDP_PACKET_HEADER_SIZE + packet->payload_len;
- if (buffer_size < total_len) {
- LN_MQTT_WARN("Buffer too small: need %d, have %d\n", total_len, buffer_size);
- return -1;
- }
-
- // 打包头部字段(转换为网络字节序)
- uint8_t *ptr = buffer;
- ptr[0] = packet->type;
- ptr[1] = packet->flags;
- *(uint16_t *)(ptr + 2) = lwip_htons(packet->payload_len);
- *(uint32_t *)(ptr + 4) = lwip_htonl(packet->ssrc);
- *(uint32_t *)(ptr + 8) = lwip_htonl(packet->timestamp);
- *(uint32_t *)(ptr + 12) = lwip_htonl(packet->sequence);
-
- // 复制负载数据
- if (packet->payload_len > 0 && packet->payload) {
- memcpy(ptr + UDP_PACKET_HEADER_SIZE, packet->payload, packet->payload_len);
- }
-
- *out_len = total_len;
- return 0;
- }
-
- /**
- * @brief 释放数据包结构体的负载数据
- * @param packet 数据包结构体指针
- */
- void ln_udp_free_packet(ln_udp_packet_t *packet)
- {
- if (packet && packet->payload) {
- free(packet->payload);
- packet->payload = NULL;
- packet->payload_size = 0;
- }
- }
-
- // ==================== OGG 封装处理函数(支持乱序数据包缓存和排序)====================
-
- /**
- * @brief 清空数据包缓存
- */
- static void ln_udp_ogg_clear_cache(void)
- {
- for (int i = 0; i < OGG_PACKET_CACHE_SIZE; i++) {
- if (g_ogg_packet_cache[i].valid && g_ogg_packet_cache[i].data != NULL) {
- free(g_ogg_packet_cache[i].data);
- g_ogg_packet_cache[i].data = NULL;
- }
- g_ogg_packet_cache[i].valid = false;
- g_ogg_packet_cache[i].sequence = 0;
- g_ogg_packet_cache[i].data_size = 0;
- }
- }
-
- /**
- * @brief 将数据包缓存(用于处理乱序接收)
- * @param sequence 序列号
- * @param data 数据指针(会被复制,调用者可以释放)
- * @param data_size 数据大小
- */
- static void ln_udp_ogg_cache_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size)
- {
- // 查找空闲的缓存槽
- int empty_slot = -1;
- for (int i = 0; i < OGG_PACKET_CACHE_SIZE; i++) {
- if (!g_ogg_packet_cache[i].valid) {
- empty_slot = i;
- break;
- }
- }
-
- if (empty_slot < 0) {
- LN_MQTT_WARN("OGG cache full, dropping packet sequence=%u\n", sequence);
- ln_udp_ogg_clear_cache();
- return;
- }
-
- // 分配内存并复制数据
- uint8_t *cached_data = (uint8_t *)malloc(data_size);
- if (cached_data == NULL) {
- LN_MQTT_ERROR("Failed to allocate memory for cached packet sequence=%u\n", sequence);
- return;
- }
-
- memcpy(cached_data, data, data_size);
-
- // 保存到缓存
- g_ogg_packet_cache[empty_slot].sequence = sequence;
- g_ogg_packet_cache[empty_slot].data = cached_data;
- g_ogg_packet_cache[empty_slot].data_size = data_size;
- g_ogg_packet_cache[empty_slot].valid = true;
-
- LN_MQTT_DEBUG("Cached packet sequence=%u (slot=%d)\n", sequence, empty_slot);
- }
-
- /**
- * @brief 创建新的 Opus 调试文件(直接保存 Opus 原始数据)
- * @return 0 成功,-1 失败
- */
- static int ln_udp_opus_debug_create_new_file(void)
- {
- #if ENABLE_OPUS_RAW_DEBUG
- // 创建新文件(使用时间戳和序号命名)
- time_t now = time(NULL);
- struct tm *tm_info = localtime(&now);
- char filename[128];
- snprintf(filename, sizeof(filename), "/user/udp_opus_raw_%04d%02d%02d_%02d%02d%02d_%03u.opus",
- tm_info->tm_year + 1900, tm_info->tm_mon + 1, tm_info->tm_mday,
- tm_info->tm_hour, tm_info->tm_min, tm_info->tm_sec, g_opus_debug_file_index);
-
- g_opus_debug_file = fopen(filename, "wb");
- if (g_opus_debug_file == NULL) {
- LN_MQTT_ERROR("Failed to open Opus debug file: %s\n", filename);
- return -1;
- }
-
- g_opus_debug_packet_count = 0;
- g_opus_debug_file_index++;
- LN_MQTT_DEBUG("Created new Opus debug file: %s (index: %u)\n", filename, g_opus_debug_file_index - 1);
-
- return 0;
- #else
- return -1;
- #endif
- }
-
- /**
- * @brief 完成当前 Opus 调试文件
- */
- static void ln_udp_opus_debug_complete_current_file(void)
- {
- #if ENABLE_OPUS_RAW_DEBUG
- if (g_opus_debug_file == NULL) {
- return;
- }
-
- fclose(g_opus_debug_file);
- g_opus_debug_file = NULL;
- g_opus_debug_packet_count = 0;
- LN_MQTT_DEBUG("Completed Opus debug file #%u\n", g_opus_debug_file_index - 1);
- #endif
- }
-
- /**
- * @brief 解析 Opus 数据包,找到实际 Opus 编码数据的起始位置和大小
- * @param data 完整的 Opus 数据包(包含 TOC 字节和可能的帧长度表)
- * @param data_size 数据包总大小
- * @param opus_data 输出的实际 Opus 数据起始指针
- * @param opus_data_size 输出的实际 Opus 数据大小
- * @return 0 成功,-1 失败
- * @note 根据 RFC 6716 Opus 编码标准解析
- */
- static int ln_udp_parse_opus_packet(const uint8_t *data, uint32_t data_size,
- const uint8_t **opus_data, uint32_t *opus_data_size)
- {
- if (!data || data_size == 0 || !opus_data || !opus_data_size) {
- LN_MQTT_WARN("Invalid parameters for Opus packet parsing\n");
- return -1;
- }
-
- // 至少需要 TOC 字节
- if (data_size < 1) {
- LN_MQTT_WARN("Opus packet too small (size=%u)\n", data_size);
- return -1;
- }
-
- const uint8_t *ptr = data;
- uint32_t remaining = data_size;
-
- // 1. 读取 TOC 字节
- uint8_t toc = ptr[0];
- ptr++;
- remaining--;
-
- // 2. 解析帧计数编码(bit 3-7)
- uint8_t frame_count_code = (toc >> 3) & 0x1F; // bit 3-7
- uint8_t frame_count = 0;
- uint32_t header_size = 1; // TOC 字节
-
- // 3. 判断是单帧还是多帧
- if (frame_count_code < 16) {
- // 单帧:帧计数 = 编码值(0表示1帧,1-15表示对应帧数)
- if (frame_count_code == 0) {
- frame_count = 1; // 编码值0表示单帧
- } else {
- frame_count = frame_count_code;
- }
- } else {
- // 多帧:需要读取帧计数字节
- if (remaining < 1) {
- LN_MQTT_WARN("Opus packet too small for frame count byte\n");
- return -1;
- }
- frame_count = frame_count_code - 16 + 1 + ptr[0];
- ptr++;
- remaining--;
- header_size++;
- }
-
- // 4. 如果是多帧,需要读取帧长度表(但不跳过数据)
- if (frame_count > 1) {
- // 多帧数据包需要帧长度表
- // 每个帧长度使用可变长度编码(1-2字节)
- // 如果长度 < 252,使用1字节;否则使用2字节(0xFC + 实际长度)
- // 注意:我们只读取长度值,不跳过帧数据,因为所有帧数据是连续存储的
- for (uint8_t i = 0; i < frame_count - 1; i++) {
- if (remaining < 1) {
- LN_MQTT_WARN("Opus packet too small for frame length table\n");
- return -1;
- }
-
- if (ptr[0] < 252) {
- // 1字节编码
- ptr++;
- remaining--;
- header_size++;
- } else {
- // 2字节编码:0xFC + 实际长度(大端序)
- if (remaining < 2) {
- LN_MQTT_WARN("Opus packet too small for 2-byte frame length\n");
- return -1;
- }
- ptr += 2;
- remaining -= 2;
- header_size += 2;
- }
- }
- }
-
- // 5. 现在 header_size 包含了所有头部信息(TOC + 帧计数 + 帧长度表)
- // 从 header_size 之后的所有数据都是 Opus 编码数据(包含所有帧的数据)
- if (header_size >= data_size) {
- LN_MQTT_WARN("Opus header size (%u) >= total size (%u)\n", header_size, data_size);
- return -1;
- }
-
- *opus_data = data + header_size;
- *opus_data_size = data_size - header_size;
-
- LN_MQTT_DEBUG("Opus parsed: frame_count=%d, header_size=%u, opus_data_size=%u\n",
- frame_count, header_size, *opus_data_size);
-
- return 0;
- }
-
- /**
- * @brief 写入 Opus 原始数据到调试文件(不进行 OGG 封装)
- * @param sequence 序列号
- * @param data 数据指针(包含 Opus TOC 字节和可能的帧长度表)
- * @param data_size 数据大小
- * @return 0 成功,-1 失败
- */
- static int ln_udp_opus_debug_write_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size)
- {
- #if ENABLE_OPUS_RAW_DEBUG
- // 检查是否需要创建新文件
- if (g_opus_debug_file == NULL || g_opus_debug_packet_count >= OGG_PACKETS_PER_FILE) {
- // 完成当前文件
- if (g_opus_debug_file != NULL) {
- ln_udp_opus_debug_complete_current_file();
- }
-
- // 创建新文件
- if (ln_udp_opus_debug_create_new_file() != 0) {
- return -1;
- }
- }
- LN_MQTT_DEBUG("opus debug data: ");
- for (int i = 0; i < data_size; i++) {
- LN_MQTT_DEBUG("%02X ", data[i]);
- }
- LN_MQTT_DEBUG("\n");
-
- // 解析 Opus 数据包(用于验证和日志输出,但不影响保存)
- const uint8_t *opus_data = NULL;
- uint32_t opus_data_size = 0;
- int parse_ret = ln_udp_parse_opus_packet(data, data_size, &opus_data, &opus_data_size);
- if (parse_ret == 0) {
- LN_MQTT_DEBUG("Opus debug: Parsed packet sequence=%u, total_size=%u, opus_data_size=%u\n",
- sequence, data_size, opus_data_size);
- } else {
- LN_MQTT_WARN("Opus debug: Parse warning (sequence=%u, size=%u), but saving raw data anyway\n",
- sequence, data_size);
- }
-
- /* 调用 opus 解码接口测试:完整包 data/data_size 送入解码 */
- {
- int pcm_samples = 0;
- int dec_ret = opus_frame_to_pcm_decode_packet(
- data, (int)data_size,
- 16000, 1,
- g_opus_debug_pcm_buf, OPUS_DEBUG_PCM_BUF_SAMPLES,
- &pcm_samples);
- if (dec_ret == 0) {
- LN_MQTT_DEBUG("Opus decode test OK sequence=%u pcm_samples=%d\n", sequence, pcm_samples);
- if (g_opus_debug_pcm_file == NULL) {
- g_opus_debug_pcm_file = fopen("user/udp_opus_debug.pcm", "ab");
- if (g_opus_debug_pcm_file != NULL) {
- LN_MQTT_DEBUG("Opus decode PCM output: udp_opus_debug.pcm (append)\n");
- }
- }
- if (g_opus_debug_pcm_file != NULL && pcm_samples > 0) {
- size_t n = fwrite(g_opus_debug_pcm_buf, sizeof(short), (size_t)pcm_samples, g_opus_debug_pcm_file);
- if (n != (size_t)pcm_samples) {
- LN_MQTT_DEBUG("Opus decode PCM write short: %zu/%d\n", n, pcm_samples);
- }
- fflush(g_opus_debug_pcm_file);
- }
- fclose(g_opus_debug_pcm_file);
- g_opus_debug_pcm_file = NULL;
- } else {
- LN_MQTT_ERROR("Opus decode test FAIL sequence=%u\n", sequence);
- }
- }
-
- // 保存完整的原始数据(包含 TOC 字节和帧长度表)
- size_t written = fwrite(data, 1, data_size, g_opus_debug_file);
- if (written != data_size) {
- LN_MQTT_ERROR("Opus debug: Failed to write data (sequence=%u, written=%zu, expected=%u)\n",
- sequence, written, data_size);
- return -1;
- }
-
- fflush(g_opus_debug_file); // 立即刷新到文件
-
- g_opus_debug_packet_count++;
- LN_MQTT_DEBUG("Opus debug: Written packet sequence=%u (%u/%u, raw_size=%u bytes)\n",
- sequence, g_opus_debug_packet_count, OGG_PACKETS_PER_FILE, data_size);
-
- return 0;
- #else
- return 0; // 未启用时直接返回成功
- #endif
- }
-
- /**
- * @brief 写入数据包到 OGG 文件
- * @param sequence 序列号
- * @param data 数据指针
- * @param data_size 数据大小
- * @return 0 成功,-1 失败
- */
- static int ln_udp_ogg_write_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size)
- {
- // 调试模式:同时保存 Opus 原始数据
- #if ENABLE_OPUS_RAW_DEBUG
- ln_udp_opus_debug_write_packet(sequence, data, data_size);
- #endif
-
- // 检查是否需要创建新文件
- if (!g_ogg_initialized || g_ogg_packet_count >= OGG_PACKETS_PER_FILE) {
- // 完成当前文件
- if (g_ogg_initialized) {
- ln_udp_ogg_complete_current_file();
- }
-
- // 创建新文件
- if (ln_udp_ogg_create_new_file() != 0) {
- return -1;
- }
- }
-
- // 写入数据包
- if (g_ogg_ctx_handle == NULL) {
- LN_MQTT_ERROR("OGG context handle is null\n");
- return -1;
- }
- if (MqttOggEncapsulationWriteHandle(g_ogg_ctx_handle, data, data_size, g_ogg_file, false) != 0) {
- LN_MQTT_ERROR("Failed to write OGG data (sequence=%u)\n", sequence);
- return -1;
- }
-
- g_ogg_packet_count++;
- LN_MQTT_DEBUG("Written packet sequence=%u (%u/%u to OGG file)\n",
- sequence, g_ogg_packet_count, OGG_PACKETS_PER_FILE);
-
- return 0;
- }
-
- /**
- * @brief 刷新缓存:尝试按顺序写入缓存中的数据包
- */
- static void ln_udp_ogg_flush_cache(void)
- {
- bool found = true;
- while (found) {
- found = false;
- // 查找期望的下一个序列号
- for (int i = 0; i < OGG_PACKET_CACHE_SIZE; i++) {
- if (g_ogg_packet_cache[i].valid &&
- g_ogg_packet_cache[i].sequence == g_ogg_expected_sequence) {
- // 找到期望的包,写入
- if (ln_udp_ogg_write_packet(g_ogg_packet_cache[i].sequence,
- g_ogg_packet_cache[i].data,
- g_ogg_packet_cache[i].data_size) == 0) {
- // 更新期望的序列号
- g_ogg_expected_sequence++;
- // 释放缓存
- free(g_ogg_packet_cache[i].data);
- g_ogg_packet_cache[i].data = NULL;
- g_ogg_packet_cache[i].valid = false;
- g_ogg_packet_cache[i].sequence = 0;
- g_ogg_packet_cache[i].data_size = 0;
- found = true;
- LN_MQTT_DEBUG("Flushed cached packet sequence=%u\n",
- g_ogg_expected_sequence - 1);
- break; // 重新开始查找
- } else {
- // 写入失败,保留在缓存中
- break;
- }
- }
- }
- }
- }
-
- /**
- * @brief 完成当前 OGG 文件并播放
- */
- static void ln_udp_ogg_complete_current_file(void)
- {
- if (!g_ogg_initialized || g_ogg_file == NULL) {
- return;
- }
-
- // 写入结束标志并完成封装
- if (g_ogg_ctx_handle != NULL) {
- uint8_t empty_data[8] = {0}; // 至少需要8字节的编码头
- MqttOggEncapsulationWriteHandle(g_ogg_ctx_handle, empty_data, 8, g_ogg_file, true);
- MqttOggEncapsulationFinishHandle(g_ogg_ctx_handle, g_ogg_file);
- }
- fclose(g_ogg_file);
- g_ogg_file = NULL;
- g_ogg_initialized = false;
-
- LN_MQTT_INFO("Completed OGG file #%u with %u packets: %s\n",
- g_ogg_file_index - 1, g_ogg_packet_count, g_completed_ogg_filename);
-
- // 使用 MQTT 播放接口播放完成的文件
- if (g_completed_ogg_filename[0] != '\0') {
- int32_t play_ret = MQTT_PlayAudioFile(g_completed_ogg_filename, NULL, NULL);
- if (play_ret == 0) {
- LN_MQTT_INFO("Started playing OGG file: %s\n", g_completed_ogg_filename);
- } else {
- LN_MQTT_ERROR("Failed to play OGG file: %s (ret=%d)\n",
- g_completed_ogg_filename, play_ret);
- }
- g_completed_ogg_filename[0] = '\0';
- }
- }
-
- /**
- * @brief 创建新的 OGG 文件
- * @return 0 成功,-1 失败
- */
- static int ln_udp_ogg_create_new_file(void)
- {
- // 创建新文件(使用时间戳和序号命名)
- time_t now = time(NULL);
- struct tm *tm_info = localtime(&now);
- char filename[128];
- snprintf(filename, sizeof(filename), "/user/udp_audio_%04d%02d%02d_%02d%02d%02d_%03u.ogg",
- tm_info->tm_year + 1900, tm_info->tm_mon + 1, tm_info->tm_mday,
- tm_info->tm_hour, tm_info->tm_min, tm_info->tm_sec, g_ogg_file_index);
-
- // 保存文件名(用于后续播放)
- strncpy(g_completed_ogg_filename, filename, sizeof(g_completed_ogg_filename) - 1);
- g_completed_ogg_filename[sizeof(g_completed_ogg_filename) - 1] = '\0';
-
- g_ogg_file = fopen(filename, "wb");
- if (g_ogg_file == NULL) {
- LN_MQTT_ERROR("Failed to open OGG file: %s\n", filename);
- g_completed_ogg_filename[0] = '\0';
- return -1;
- }
-
- // 获取 OGG 上下文句柄(如果尚未获取)
- if (g_ogg_ctx_handle == NULL) {
- g_ogg_ctx_handle = MqttOggGetContext();
- if (g_ogg_ctx_handle == NULL) {
- LN_MQTT_ERROR("Failed to get OGG context handle\n");
- fclose(g_ogg_file);
- g_ogg_file = NULL;
- g_completed_ogg_filename[0] = '\0';
- return -1;
- }
- }
-
- // 初始化 OGG 上下文
- if (MqttOggEncapsulationInitHandle(g_ogg_ctx_handle, g_ogg_file, 16000, 1) != 0) {
- LN_MQTT_ERROR("Failed to initialize OGG context\n");
- fclose(g_ogg_file);
- g_ogg_file = NULL;
- g_completed_ogg_filename[0] = '\0';
- return -1;
- }
-
- g_ogg_initialized = true;
- g_ogg_packet_count = 0;
- g_ogg_file_index++;
- LN_MQTT_DEBUG("Created new OGG file: %s (index: %u)\n", filename, g_ogg_file_index - 1);
-
- return 0;
- }
-
- /**
- * @brief 处理 OGG 数据包(支持乱序接收和缓存)
- * @param sequence 数据包序列号
- * @param data 解密后的数据(所有权转移,函数内部负责释放)
- * @param data_size 数据大小
- * @return 0 成功,-1 失败
- * @note 此函数会接管 data 的所有权,调用者不应再释放 data
- */
- static int ln_udp_ogg_handle_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size)
- {
- // 初始化期望序列号(首次接收)
- if (g_ogg_expected_sequence == 0) {
- g_ogg_expected_sequence = sequence;
- g_ogg_out_of_order_count = 0; // 重置错序计数器
- LN_MQTT_DEBUG("Initialized expected sequence to %u\n", sequence);
- }
-
- // 检查是否是期望的下一个包
- if (sequence == g_ogg_expected_sequence) {
- // 是期望的包,直接写入
- if (ln_udp_ogg_write_packet(sequence, data, data_size) == 0) {
- g_ogg_expected_sequence++;
- g_ogg_out_of_order_count = 0; // 重置错序计数器(收到期望的包)
- free((void *)data); // 释放数据(所有权已转移)
-
- // 尝试刷新缓存中的后续包
- ln_udp_ogg_flush_cache();
- return 0;
- } else {
- // 写入失败,缓存这个包
- ln_udp_ogg_cache_packet(sequence, data, data_size);
- free((void *)data);
- return -1;
- }
- } else if (sequence > g_ogg_expected_sequence) {
- // 是未来的包,缓存起来
- g_ogg_out_of_order_count++; // 增加错序计数器
- LN_MQTT_WARN("Received future packet sequence=%u (expected=%u), caching (out_of_order_count=%u)\n",
- sequence, g_ogg_expected_sequence, g_ogg_out_of_order_count);
-
- // 如果连续错序超过阈值,跳过期望的序列号(避免丢包时一直无法正常输出)
- if (g_ogg_out_of_order_count > OGG_MAX_OUT_OF_ORDER_COUNT) {
- uint32_t old_expected = g_ogg_expected_sequence;
- LN_MQTT_DEBUG("Out of order count exceeded %d, skipping sequence %u\n",
- OGG_MAX_OUT_OF_ORDER_COUNT, g_ogg_expected_sequence);
-
- // 1. 先将期望序号往后加一(跳过丢失的包)
- g_ogg_expected_sequence++;
- g_ogg_out_of_order_count = 0; // 重置计数器
-
- // 2. 处理缓存中的包(尝试写入缓存中所有能写入的连续包)
- ln_udp_ogg_flush_cache();
-
- // 3. 再尝试写入当前包
- if (sequence == g_ogg_expected_sequence) {
- // 当前包正好是期望的包,直接写入
- if (ln_udp_ogg_write_packet(sequence, data, data_size) == 0) {
- g_ogg_expected_sequence++;
- free((void *)data);
- // 继续刷新缓存中的后续包
- ln_udp_ogg_flush_cache();
- LN_MQTT_DEBUG("Successfully wrote skipped packet sequence=%u (old_expected=%u)\n",
- sequence, old_expected);
- return 0;
- } else {
- // 写入失败,缓存这个包
- ln_udp_ogg_cache_packet(sequence, data, data_size);
- free((void *)data);
- return -1;
- }
- } else if (sequence > g_ogg_expected_sequence) {
- // 当前包仍然是未来的包,缓存起来
- LN_MQTT_DEBUG("Current packet sequence=%u still ahead of expected=%u after skip, caching\n",
- sequence, g_ogg_expected_sequence);
- ln_udp_ogg_cache_packet(sequence, data, data_size);
- free((void *)data);
- return 0;
- } else {
- // 当前包已经是过去的包(在刷新缓存时已处理),丢弃
- LN_MQTT_DEBUG("Current packet sequence=%u is now old (expected=%u), dropping\n",
- sequence, g_ogg_expected_sequence);
- free((void *)data);
- return 0;
- }
- } else {
- // 正常缓存未来包
- ln_udp_ogg_cache_packet(sequence, data, data_size);
- free((void *)data);
- return 0;
- }
- } else {
- // 是过去的包(重复或乱序),丢弃
- LN_MQTT_DEBUG("Received old/duplicate packet sequence=%u (expected=%u), dropping\n",
- sequence, g_ogg_expected_sequence);
- free((void *)data);
- return 0;
- }
- }
-
- #if USE_DUAL_STREAM_INTERFACE
- // ==================== 双流接口处理函数(支持乱序数据包缓存和排序)====================
-
- /**
- * @brief 解码 Opus 数据包并送入 AI_SendAudioDataToQueue
- * @param sequence 序列号
- * @param data 数据指针
- * @param data_size 数据大小
- * @return 0 成功,-1 失败
- */
- static int ln_udp_dual_stream_decode_and_send(uint32_t sequence, const uint8_t *data, uint32_t data_size)
- {
- int pcm_samples = 0;
- int dec_ret = opus_frame_to_pcm_decode_packet(
- data, (int)data_size,
- 16000, 1,
- g_opus_debug_pcm_buf, OPUS_DEBUG_PCM_BUF_SAMPLES,
- &pcm_samples);
-
- if (dec_ret == 0 && pcm_samples > 0) {
- // 解码成功,将 PCM 数据送入 AI_SendAudioDataToQueue
- uint32_t pcm_data_size = (uint32_t)(pcm_samples * sizeof(short));
- int32_t send_ret = AI_SendAudioDataToQueue((const uint8_t *)g_opus_debug_pcm_buf, pcm_data_size);
- if (send_ret == 0) {
- LN_MQTT_DEBUG("Dual stream: Decoded and sent to queue: sequence=%u, pcm_samples=%d\n",
- sequence, pcm_samples);
- return 0;
- } else {
- LN_MQTT_ERROR("Dual stream: Failed to send decoded PCM to queue: sequence=%u, ret=%d\n",
- sequence, (int)send_ret);
- return -1;
- }
- } else {
- LN_MQTT_ERROR("Dual stream: Opus decode failed: sequence=%u, ret=%d\n",
- sequence, dec_ret);
- return -1;
- }
- }
-
- /**
- * @brief 刷新双流数据包缓存(按顺序处理缓存中的包)
- */
- static bool ln_udp_dual_stream_flush_cache(void)
- {
- bool found = true;
- while (found) {
- found = false;
- // 查找期望序列号的包
- for (int i = 0; i < OGG_PACKET_CACHE_SIZE; i++) {
- if (g_ogg_packet_cache[i].valid &&
- g_ogg_packet_cache[i].sequence == g_ogg_expected_sequence) {
- // 找到期望的包,解码并发送
- if (ln_udp_dual_stream_decode_and_send(g_ogg_packet_cache[i].sequence,
- g_ogg_packet_cache[i].data,
- g_ogg_packet_cache[i].data_size) == 0) {
- g_ogg_expected_sequence++;
- // 释放缓存数据
- free(g_ogg_packet_cache[i].data);
- g_ogg_packet_cache[i].data = NULL;
- g_ogg_packet_cache[i].valid = false;
- g_ogg_packet_cache[i].sequence = 0;
- g_ogg_packet_cache[i].data_size = 0;
- found = true; // 继续查找下一个期望的包
- LN_MQTT_DEBUG("Dual stream: Flushed cached packet sequence=%u\n",
- g_ogg_expected_sequence - 1);
- break; // 重新开始查找
- } else {
- // 解码失败,停止刷新
- found = false;
- break;
- }
- }
- }
- }
- return found;
- }
-
- /**
- * @brief 处理双流数据包(支持乱序接收和缓存)
- * @param sequence 数据包序列号
- * @param data 解密后的数据(所有权转移,函数内部负责释放)
- * @param data_size 数据大小
- * @return 0 成功,-1 失败
- * @note 此函数会接管 data 的所有权,调用者不应再释放 data
- */
- static int ln_udp_dual_stream_handle_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size)
- {
- // 初始化期望序列号(首次接收)
- if (g_ogg_expected_sequence == 0) {
- g_ogg_expected_sequence = sequence;
- g_ogg_out_of_order_count = 0; // 重置错序计数器
- LN_MQTT_DEBUG("Dual stream: Initialized expected sequence to %u\n", sequence);
- }
-
- // 检查是否是期望的下一个包
- if (sequence == g_ogg_expected_sequence) {
- // 是期望的包,直接解码并发送
- if (ln_udp_dual_stream_decode_and_send(sequence, data, data_size) == 0) {
- g_ogg_expected_sequence++;
- g_ogg_out_of_order_count = 0; // 重置错序计数器(收到期望的包)
- free((void *)data); // 释放数据(所有权已转移)
-
- // 尝试刷新缓存中的后续包
- ln_udp_dual_stream_flush_cache();
- return 0;
- } else {
- // 解码失败,缓存这个包
- ln_udp_ogg_cache_packet(sequence, data, data_size);
- free((void *)data);
- return -1;
- }
- } else if (sequence > g_ogg_expected_sequence) {
- // 是未来的包,缓存起来
- g_ogg_out_of_order_count++; // 增加错序计数器
- LN_MQTT_DEBUG("Dual stream: Received future packet sequence=%u (expected=%u), caching (out_of_order_count=%u)\n",
- sequence, g_ogg_expected_sequence, g_ogg_out_of_order_count);
-
- // 如果连续错序超过阈值,跳过期望的序列号(避免丢包时一直无法正常输出)
- if (g_ogg_out_of_order_count > OGG_MAX_OUT_OF_ORDER_COUNT) {
- uint32_t old_expected = g_ogg_expected_sequence;
- LN_MQTT_WARN("Dual stream: Out of order count exceeded %d, skipping sequence %u\n",
- OGG_MAX_OUT_OF_ORDER_COUNT, g_ogg_expected_sequence);
-
- // 1. 先将期望序号往后加一(跳过丢失的包)
- g_ogg_expected_sequence++;
-
- // 2. 处理缓存中的包(尝试解码并发送缓存中所有能处理的连续包)
- bool found = ln_udp_dual_stream_flush_cache();
- if (found) {
- g_ogg_out_of_order_count = 0; // 重置计数器
- LN_MQTT_DEBUG("Dual stream: Successfully flushed cache\n");
- } else {
- LN_MQTT_WARN("Dual stream: Failed to flush cache\n");
- }
-
- // 3. 再尝试处理当前包
- if (sequence == g_ogg_expected_sequence) {
- // 当前包正好是期望的包,直接解码并发送
- if (ln_udp_dual_stream_decode_and_send(sequence, data, data_size) == 0) {
- g_ogg_expected_sequence++;
- free((void *)data);
- // 继续刷新缓存中的后续包
- ln_udp_dual_stream_flush_cache();
- LN_MQTT_DEBUG("Dual stream: Successfully decoded and sent skipped packet sequence=%u (old_expected=%u)\n",
- sequence, old_expected);
- return 0;
- } else {
- // 解码失败,缓存这个包
- ln_udp_ogg_cache_packet(sequence, data, data_size);
- free((void *)data);
- return -1;
- }
- } else if (sequence > g_ogg_expected_sequence) {
- // 当前包仍然是未来的包,缓存起来
- LN_MQTT_DEBUG("Dual stream: Current packet sequence=%u still ahead of expected=%u after skip, caching\n",
- sequence, g_ogg_expected_sequence);
- ln_udp_ogg_cache_packet(sequence, data, data_size);
- free((void *)data);
- return 0;
- } else {
- // 当前包已经是过去的包(在刷新缓存时已处理),丢弃
- LN_MQTT_DEBUG("Dual stream: Current packet sequence=%u is now old (expected=%u), dropping\n",
- sequence, g_ogg_expected_sequence);
- free((void *)data);
- return 0;
- }
- } else {
- // 正常缓存未来包
- ln_udp_ogg_cache_packet(sequence, data, data_size);
- free((void *)data);
- return 0;
- }
- } else {
- // 是过去的包(重复或乱序),丢弃
- LN_MQTT_DEBUG("Dual stream: Received old/duplicate packet sequence=%u (expected=%u), dropping\n",
- sequence, g_ogg_expected_sequence);
- free((void *)data);
- return 0;
- }
- }
- #endif /* USE_DUAL_STREAM_INTERFACE */
-
- /* 接收线程内固定时间间隔(秒)后重新创建 socket,0 表示不按时间重建 */
- #define UDP_RECV_RECREATE_INTERVAL_SEC 0
- /* UDP 客户端本地端口绑定策略
- * - UDP_CLIENT_LOCAL_BIND_PORT > 0: 绑定到指定本地端口
- * - 否则且 UDP_CLIENT_BIND_TO_SERVER_PORT=1: 绑定到 hello 下发的 udp.port
- * - 否则: 绑定到 0(由系统分配临时端口)
- */
- #ifndef UDP_CLIENT_BIND_TO_SERVER_PORT
- #define UDP_CLIENT_BIND_TO_SERVER_PORT 1
- #endif
- #ifndef UDP_CLIENT_LOCAL_BIND_PORT
- #define UDP_CLIENT_LOCAL_BIND_PORT 50001
- #endif
-
- /**
- * @brief 仅创建并配置 UDP socket(不启动线程),供创建与接收线程内重建复用
- * @return socket fd,失败返回 -1
- */
- static int ln_udp_create_socket_fd_only(void)
- {
- ln_mqtt_udp_info_t udp_info;
- if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
- return -1;
- }
- int fd = lwip_socket(AF_INET, SOCK_DGRAM, 0);
- if (fd < 0) {
- return -1;
- }
- int opt = 1;
- lwip_setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
-
- /* UDP 客户端显式绑定本地端口 */
- uint16_t local_bind_port = 0;
- #if UDP_CLIENT_LOCAL_BIND_PORT > 0
- local_bind_port = (uint16_t)UDP_CLIENT_LOCAL_BIND_PORT;
- #elif UDP_CLIENT_BIND_TO_SERVER_PORT
- local_bind_port = udp_info.port;
- #else
- local_bind_port = 0;
- #endif
- struct sockaddr_in local_addr;
- memset(&local_addr, 0, sizeof(local_addr));
- local_addr.sin_family = AF_INET;
- local_addr.sin_addr.s_addr = lwip_htonl(INADDR_ANY);
- local_addr.sin_port = lwip_htons(local_bind_port);
-
- if (lwip_bind(fd, (struct sockaddr *)&local_addr, sizeof(local_addr)) < 0) {
- LN_MQTT_ERROR("Failed to bind UDP local port %u: %s\n", local_bind_port, strerror(errno));
- lwip_close(fd);
- return -1;
- }
- LN_MQTT_INFO("UDP local bind success, port=%u\n", local_bind_port);
- return fd;
- }
-
- /**
- * @brief UDP接收线程
- */
- static void ln_udp_recv_thread(void *arg)
- {
- (void)arg;
- uint8_t recv_buffer[UDP_RECV_BUFFER_SIZE];
- struct sockaddr_in server_addr;
- socklen_t addr_len = sizeof(server_addr);
- uint32_t last_recreate_tick = 0;
- uint32_t recreate_interval_ticks = 0;
-
- LN_MQTT_INFO("Receive thread started\n");
-
- // 获取服务器地址信息
- ln_mqtt_udp_info_t udp_info;
- if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
- LN_MQTT_WARN("UDP info not available in receive thread\n");
- g_udp_thread_running = false;
- return;
- }
-
- // 设置服务器地址
- memset(&server_addr, 0, sizeof(server_addr));
- server_addr.sin_family = AF_INET;
- server_addr.sin_port = lwip_htons(udp_info.port);
- server_addr.sin_addr.s_addr = inet_addr(udp_info.server);
-
- if (UDP_RECV_RECREATE_INTERVAL_SEC > 0) {
- recreate_interval_ticks = (uint32_t)osKernelGetTickFreq() * UDP_RECV_RECREATE_INTERVAL_SEC;
- last_recreate_tick = osKernelGetTickCount();
- }
-
- while (g_udp_thread_running && g_udp_socket >= 0) {
- LN_MQTT_DEBUG("g_udp_thread_running %d g_udp_socket %d\r\n", g_udp_thread_running, g_udp_socket);
- // 固定时间间隔到达则重新创建 socket
- if (UDP_RECV_RECREATE_INTERVAL_SEC > 0 && recreate_interval_ticks > 0) {
- uint32_t now = osKernelGetTickCount();
- if ((now - last_recreate_tick) >= recreate_interval_ticks) {
- LN_MQTT_INFO("Recreate interval reached (%u s), recreating socket\n", (unsigned)UDP_RECV_RECREATE_INTERVAL_SEC);
- lwip_close(g_udp_socket);
- g_udp_socket = ln_udp_create_socket_fd_only();
- if (g_udp_socket < 0) {
- LN_MQTT_ERROR("Failed to recreate socket: %s\n", strerror(errno));
- break;
- }
- /* 重新获取 UDP 地址信息(服务端地址/端口可能变化) */
- if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
- LN_MQTT_WARN("UDP info not available after recreate, keep last address\n");
- } else {
- memset(&server_addr, 0, sizeof(server_addr));
- server_addr.sin_family = AF_INET;
- server_addr.sin_port = lwip_htons(udp_info.port);
- server_addr.sin_addr.s_addr = inet_addr(udp_info.server);
- addr_len = sizeof(server_addr);
- }
- last_recreate_tick = osKernelGetTickCount();
- }
- }
-
- // 接收UDP数据(阻塞,超时1秒)
- fd_set read_fds;
- struct timeval timeout;
-
- FD_ZERO(&read_fds);
- FD_SET(g_udp_socket, &read_fds);
- timeout.tv_sec = 1;
- timeout.tv_usec = 0;
-
- int select_ret = lwip_select(g_udp_socket + 1, &read_fds, NULL, NULL, &timeout);
- if (select_ret > 0 && FD_ISSET(g_udp_socket, &read_fds)) {
- // 有数据可读
- ssize_t recv_len = lwip_recvfrom(g_udp_socket, recv_buffer, sizeof(recv_buffer) - 1, 0,
- (struct sockaddr *)&server_addr, &addr_len);
-
- if (recv_len > 0) {
- LN_MQTT_DEBUG("Received %d bytes\r\n",
- (int)recv_len
- );
-
- // 处理接收到的数据(解包、解密)
- ln_udp_process_received_data(recv_buffer, (uint16_t)recv_len);
-
- } else if (recv_len == 0) {
- LN_MQTT_INFO("Connection closed by peer\n");
- break;
- } else {
- if (errno != EAGAIN && errno != EWOULDBLOCK) {
- LN_MQTT_ERROR("Recvfrom error: %s\n", strerror(errno));
- }
- }
- } else if (select_ret < 0) {
- LN_MQTT_DEBUG("select_ret %d\r\n", select_ret);
- if (errno != EINTR) {
- LN_MQTT_ERROR("Select error: %s\n", strerror(errno));
- break;
- }
- }
- // select_ret == 0 表示超时,继续循环
- }
-
- LN_MQTT_INFO("Receive thread exited\n");
- g_udp_thread_running = false;
- }
-
- /**
- * @brief 创建UDP套接字
- * @return 0 成功,-1 失败
- */
- int ln_udp_create_socket(void)
- {
- // 获取UDP信息
- ln_mqtt_udp_info_t udp_info;
- if (ln_mqtt_api_get_udp_info(&udp_info) != 0) {
- LN_MQTT_WARN("UDP info not available, cannot create socket\n");
- return -1;
- }
-
- if (!udp_info.valid) {
- LN_MQTT_WARN("UDP info invalid, cannot create socket\n");
- return -1;
- }
-
- LN_MQTT_INFO("Creating UDP socket for server: %s:%d\n", udp_info.server, udp_info.port);
-
- // 如果socket已存在,先关闭
- if (g_udp_socket >= 0) {
- LN_MQTT_DEBUG("Closing existing UDP socket\n");
- ln_udp_close_socket();
- }
-
- // 创建UDP套接字(复用仅创建 fd 的逻辑)
- g_udp_socket = ln_udp_create_socket_fd_only();
- if (g_udp_socket < 0) {
- LN_MQTT_ERROR("Failed to create UDP socket: %s\n", strerror(errno));
- return -1;
- }
-
- LN_MQTT_INFO("UDP socket created successfully, fd=%d\n", g_udp_socket);
-
- // 创建接收线程
- if (!g_udp_thread_running) {
- app_task_definition_ext_t recv_task = {
- .attr = {
- .name = "ln_udp_recv",
- .stack_size = 0x8000,
- .priority = osPriorityNormal
- },
- .func = ln_udp_recv_thread,
- .task_handle = &g_udp_thread_handle,
- .create_queue_handle = NULL,
- .use_mem = USE_EXTEND_MEM,
- .inst_args = NULL
- };
-
- g_udp_thread_running = true;
- errcode_t ret = uapi_create_osThread_custom_with_args(&recv_task);
- if (ret != ERRCODE_SUCC) {
- LN_MQTT_ERROR("Failed to create receive thread: %d\n", ret);
- g_udp_thread_running = false;
- lwip_close(g_udp_socket);
- g_udp_socket = -1;
- return -1;
- }
- LN_MQTT_INFO("Receive thread created successfully\n");
- }
-
- return 0;
- }
-
- /**
- * @brief 关闭UDP套接字
- */
- void ln_udp_close_socket(void)
- {
- // 完成并关闭 OGG 文件
- if (g_ogg_initialized) {
- ln_udp_ogg_complete_current_file();
- }
-
- // 完成并关闭 Opus 调试文件
- #if ENABLE_OPUS_RAW_DEBUG
- if (g_opus_debug_file != NULL) {
- ln_udp_opus_debug_complete_current_file();
- }
- #endif
-
- // 停止接收线程
- if (g_udp_thread_running) {
- LN_MQTT_INFO("Stopping receive thread\n");
- g_udp_thread_running = false;
-
- // 等待线程退出(最多等待2秒)
- uint32_t timeout = osKernelGetTickCount() + osKernelGetTickFreq() * 2;
- while (g_udp_thread_handle != 0 && osKernelGetTickCount() < timeout) {
- osDelay(10);
- }
-
- if (g_udp_thread_handle != 0) {
- LN_MQTT_WARN("Receive thread did not exit in time\n");
- }
-
- g_udp_thread_handle = 0;
- }
-
- // 关闭套接字
- if (g_udp_socket >= 0) {
- LN_MQTT_DEBUG("Closing UDP socket, fd=%d\n", g_udp_socket);
- lwip_close(g_udp_socket);
- g_udp_socket = -1;
- }
- }
-
- /**
- * @brief 获取UDP套接字文件描述符
- * @return socket文件描述符,-1表示未创建
- */
- int ln_udp_get_socket(void)
- {
- return g_udp_socket;
- }
-
- /**
- * @brief 检查UDP套接字是否已创建
- * @return true 已创建,false 未创建
- */
- bool ln_udp_is_socket_created(void)
- {
- return (g_udp_socket >= 0);
- }
-
- // +------+-------+-------------+----------+------------+----------+-------------------+
- // | Type | Flags | Payload Len | SSRC | Timestamp | Sequence | Encrypted Payload |
- // +------+-------+-------------+----------+------------+----------+-------------------+
- // |1 byte|1 byte | 2 bytes | 4 bytes | 4 bytes | 4 bytes | N bytes |
- // +------+-------+-------------+----------+------------+----------+-------------------+
-
-
- // import struct
- // from Crypto.Cipher import AES
- // from Crypto.Util import Counter
-
- // def encrypt_audio(key_hex: str, nonce_hex: str, timestamp: int, sequence: int, audio_data: bytes) -> bytes:
- // """
- // 加密音频数据
-
- // Args:
- // key_hex: 32字符十六进制密钥
- // nonce_hex: 32字符十六进制nonce
- // timestamp: 数据包时间戳
- // sequence: 数据包序列号
- // audio_data: 原始Opus音频数据
-
- // Returns:
- // 加密后的音频数据
- // """
- // key = bytes.fromhex(key_hex)
- // nonce = bytes.fromhex(nonce_hex)
-
- // # 构建计数器初始值:结合timestamp和sequence
- // counter_init = int.from_bytes(nonce[:12] + struct.pack('>I', sequence), 'big')
- // ctr = Counter.new(128, initial_value=counter_init)
-
- // cipher = AES.new(key, AES.MODE_CTR, counter=ctr)
- // return cipher.encrypt(audio_data)
-
- // def decrypt_audio(key_hex: str, nonce_hex: str, timestamp: int, sequence: int, encrypted_data: bytes) -> bytes:
- // """解密音频数据(与加密相同,CTR模式对称)"""
- // return encrypt_audio(key_hex, nonce_hex, timestamp, sequence, encrypted_data)
-
- /**
- * @brief 完整的数据打包函数(加密+打包)
- * @param audio_data 原始音频数据
- * @param audio_len 音频数据长度
- * @param buffer 输出缓冲区(由调用者分配,大小至少为 UDP_PACKET_HEADER_SIZE + audio_len)
- * @param buffer_size 缓冲区大小
- * @param out_len 输出的实际数据长度
- * @return 0 成功,-1 失败
- * @note 函数内部自动处理type、flags、ssrc、timestamp、sequence等字段
- */
- int ln_udp_pack_audio_data(const uint8_t *audio_data, uint16_t audio_len,
- uint8_t *buffer, uint16_t buffer_size, uint16_t *out_len)
- {
- if (!audio_data || audio_len == 0 || !buffer || !out_len) {
- LN_MQTT_WARN("Invalid parameters for pack audio data\n");
- return -1;
- }
-
- // 计算所需缓冲区大小
- uint16_t total_len = UDP_PACKET_HEADER_SIZE + audio_len;
- if (buffer_size < total_len) {
- LN_MQTT_WARN("Buffer too small: need %d, have %d\n", total_len, buffer_size);
- return -1;
- }
-
- // 1. 获取UDP信息(用于加密)
- ln_mqtt_udp_info_t udp_info;
- if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
- LN_MQTT_WARN("UDP info not available for encryption\n");
- return -1;
- }
- // 01 00 00 00 1d 38 db 20 69 70 a0 da 00000000
- // 2. 初始化SSRC(如果未初始化,从 nonce 字节数组的索引 4-8 提取,只取 4 个字节)
- if (g_udp_ssrc == 0) {
- if (ln_data_nonce_to_ssrc(udp_info.nonce, &g_udp_ssrc) == 0) {
- LN_MQTT_DEBUG("SSRC initialized from nonce bytes[4-7], ssrc=0x%08X\n", g_udp_ssrc);
- } else {
- LN_MQTT_WARN("Failed to convert nonce to bytes, using default SSRC\n");
- g_udp_ssrc = 0x12345678;
- }
- }
-
- // 3. 自动递增序列号
- uint32_t sequence = g_udp_sequence++;
-
- // 4. 获取时间戳(使用系统时钟)
- uint32_t timestamp = (uint32_t)osKernelGetTickCount(); // 使用系统tick作为时间戳
-
- // 5. 设置数据包类型和标志(使用默认值)
- uint8_t type = 0x01; // 默认类型
- uint8_t flags = 0; // 默认标志
-
- // 6. 加密音频数据(nonce在函数内部构造)
- uint8_t *encrypted_payload = buffer + UDP_PACKET_HEADER_SIZE;
- if (ln_udp_encrypt_audio(udp_info.key, udp_info.nonce, audio_len, timestamp, sequence,
- audio_data, audio_len, encrypted_payload) != 0) {
- LN_MQTT_ERROR("Failed to encrypt audio data\n");
- return -1;
- }
-
- // 7. 打包数据包头部
- uint8_t *ptr = buffer;
- ptr[0] = type;
- ptr[1] = flags;
- *(uint16_t *)(ptr + 2) = lwip_htons(audio_len); // payload_len(加密后的长度等于原始长度)
- *(uint32_t *)(ptr + 4) = lwip_htonl(g_udp_ssrc);
- *(uint32_t *)(ptr + 8) = lwip_htonl(timestamp);
- *(uint32_t *)(ptr + 12) = lwip_htonl(sequence);
-
- // 加密的payload已经在步骤6中写入buffer + UDP_PACKET_HEADER_SIZE位置
-
- *out_len = total_len;
-
- LN_MQTT_DEBUG("buffer: ");
- for (int i = 0; i < 16; i++) {
- LN_MQTT_DEBUG("%02x ", buffer[i]);
- }
- LN_MQTT_DEBUG("\n");
-
- LN_MQTT_DEBUG("Audio data packed: type=%d, flags=%d, ssrc=0x%08X, timestamp=%u, sequence=%u, payload_len=%d, total_len=%d\n",
- type, flags, g_udp_ssrc, timestamp, sequence, audio_len, total_len);
-
- return 0;
- }
-
- /**
- * @brief 创建音频发送队列
- */
- static void create_audio_send_queue(void)
- {
- if (g_audio_send_queue != 0xFFFFFFFF) {
- // 队列已创建
- return;
- }
-
- if (osal_msg_queue_create("ln_udp_audio_send_queue", AUDIO_SEND_QUEUE_SIZE, &g_audio_send_queue,
- 0, sizeof(audio_send_msg_t)) != ERRCODE_SUCC) {
- LN_MQTT_ERROR("Failed to create audio send queue\n");
- g_audio_send_queue = 0xFFFFFFFF;
- } else {
- LN_MQTT_INFO("Audio send queue created successfully\n");
- }
- }
-
- /**
- * @brief 发送单帧音频数据(打包/加密 + 发送)
- * @note 复用原有 ln_udp_pack_audio_data 加密逻辑
- * @return 0 成功,-1 失败
- */
- static int ln_udp_send_audio_frame(int sock, const uint8_t *audio_data, uint32_t audio_size)
- {
- if (audio_data == NULL || audio_size == 0 || audio_size > AUDIO_SEND_MAX_DATA_SIZE) {
- return -1;
- }
-
- // 打包(加密+UDP头)
- uint8_t send_buf[UDP_PACKET_HEADER_SIZE + AUDIO_SEND_MAX_DATA_SIZE];
- uint16_t out_len = 0;
- if (ln_udp_pack_audio_data(audio_data, (uint16_t)audio_size, send_buf,
- (uint16_t)sizeof(send_buf), &out_len) != 0) {
- LN_MQTT_ERROR("Failed to pack audio frame\n");
- return -1;
- }
-
- // 获取UDP信息(用于发送)
- ln_mqtt_udp_info_t udp_info;
- if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
- LN_MQTT_WARN("UDP info not available, drop audio frame\n");
- return -1;
- }
-
- // 发送到服务器
- struct sockaddr_in server_addr;
- memset(&server_addr, 0, sizeof(server_addr));
- server_addr.sin_family = AF_INET;
- server_addr.sin_port = lwip_htons(udp_info.port);
- server_addr.sin_addr.s_addr = inet_addr(udp_info.server);
-
- ssize_t sent = lwip_sendto(sock, send_buf, out_len, 0,
- (struct sockaddr *)&server_addr, sizeof(server_addr));
- if (sent < 0) {
- LN_MQTT_ERROR("UDP sendto failed: %s\n", strerror(errno));
- return -1;
- }
-
- return 0;
- }
-
- /**
- * @brief 音频数据发送线程
- */
- static void ln_udp_audio_send_thread(void *arg)
- {
- (void)arg;
- audio_send_msg_t msg;
- uint32_t msgsize = sizeof(audio_send_msg_t);
-
- LN_MQTT_INFO("Audio send thread started\n");
-
- while (g_audio_send_thread_running) {
- // 从队列读取音频数据(阻塞等待)
- int32_t ret = osal_msg_queue_read_copy(g_audio_send_queue, (void *)&msg, &msgsize,
- OSAL_MSGQ_WAIT_FOREVER);
- if (ret != OSAL_SUCCESS) {
- LN_MQTT_ERROR("Failed to read from audio send queue: %d\n", ret);
- continue;
- }
-
- // 检查数据大小和数据指针
- if (msg.size == 0 || msg.size > AUDIO_SEND_MAX_DATA_SIZE || msg.data == NULL) {
- LN_MQTT_WARN("Invalid audio data: size=%u, data=%p\n", msg.size, msg.data);
- // 释放内存(如果存在)
- if (msg.data != NULL) {
- free(msg.data);
- }
- continue;
- }
-
- // 确保 UDP socket 已创建
- if (!ln_udp_is_socket_created()) {
- LN_MQTT_WARN("UDP socket not ready, drop audio frame\n");
- free(msg.data);
- continue;
- }
-
- int sock = ln_udp_get_socket();
- if (sock < 0) {
- LN_MQTT_WARN("UDP socket invalid, drop audio frame\n");
- free(msg.data);
- continue;
- }
-
- const uint8_t *send_data = msg.data;
- uint32_t send_size = msg.size;
- if (msg.encoding == AUDIO_SEND_ENCODING_PCM) {
- /* PCM:追加到缓存,按 60ms 切割编码,余量保留 */
- if (g_pcm_send_cache == NULL) {
- LN_MQTT_WARN("PCM cache not allocated, drop %u bytes\n", msg.size);
- free(msg.data);
- continue;
- }
- while (g_pcm_send_cache_size + msg.size > g_pcm_send_cache_capacity &&
- g_pcm_send_cache_size >= AUDIO_SEND_PCM_FRAME_BYTES) {
- /* 缓存满时丢弃最旧一帧,避免持续溢出 */
- g_pcm_send_cache_size -= AUDIO_SEND_PCM_FRAME_BYTES;
- memmove(g_pcm_send_cache, g_pcm_send_cache + AUDIO_SEND_PCM_FRAME_BYTES, g_pcm_send_cache_size);
- }
- if (g_pcm_send_cache_size + msg.size > g_pcm_send_cache_capacity) {
- LN_MQTT_WARN("PCM cache full, drop %u bytes (cache=%u, cap=%u)\n", msg.size, g_pcm_send_cache_size, g_pcm_send_cache_capacity);
- free(msg.data);
- continue;
- }
- memcpy(g_pcm_send_cache + g_pcm_send_cache_size, msg.data, msg.size);
- g_pcm_send_cache_size += msg.size;
- free(msg.data);
- msg.data = NULL;
-
- /* 每次取 60ms 固定长度编码并发送,多余数据留在缓存 */
- uint8_t opus_buf[1500];
-
- while (g_pcm_send_cache_size >= AUDIO_SEND_PCM_FRAME_BYTES) {
- int encoded_len = 0;
- LN_MQTT_DEBUG("PCM send cache size: %d\n", g_pcm_send_cache_size);
- for (int i = 0; i < AUDIO_SEND_PCM_FRAME_BYTES; i++) {
- LN_MQTT_DEBUG("%02x ", g_pcm_send_cache[i]);
- }
- LN_MQTT_DEBUG("\n");
-
- if (opus_pcm_to_frame_encode_packet(
- (const short *)g_pcm_send_cache, AUDIO_SEND_PCM_FRAME_SAMPLES,
- AUDIO_SEND_PCM_SAMPLE_RATE, AUDIO_SEND_PCM_CHANNELS,
- AUDIO_SEND_PCM_BITRATE, AUDIO_SEND_PCM_APPLICATION,
- opus_buf, (int)sizeof(opus_buf), &encoded_len) != 0) {
- LN_MQTT_WARN("PCM to Opus encode failed, drop 60ms frame\n");
- break;
- }
- LN_MQTT_DEBUG("Opus encoded len: %d\n", encoded_len);
- LN_MQTT_DEBUG("Opus encoded data: ");
- for (int i = 0; i < encoded_len; i++) {
- LN_MQTT_DEBUG("%02x ", opus_buf[i]);
- }
- LN_MQTT_DEBUG("\n");
- if (ln_udp_send_audio_frame(sock, opus_buf, (uint32_t)encoded_len) != 0) {
- break;
- }
- /* 移除已编码的一帧,保留余量 */
- g_pcm_send_cache_size -= AUDIO_SEND_PCM_FRAME_BYTES;
- memmove(g_pcm_send_cache, g_pcm_send_cache + AUDIO_SEND_PCM_FRAME_BYTES, g_pcm_send_cache_size);
- }
- continue;
- }
-
- (void)send_data;
- if (ln_udp_send_audio_frame(sock, send_data, send_size) != 0) {
- free(msg.data);
- continue;
- }
-
- // 释放音频数据内存
- free(msg.data);
- msg.data = NULL;
- }
-
- LN_MQTT_INFO("Audio send thread exited\n");
- g_audio_send_thread_running = false;
- }
-
- /**
- * @brief 初始化音频发送队列和线程
- * @return 0 成功,-1 失败
- */
- int ln_udp_audio_send_init(void)
- {
- // 动态分配 PCM 发送缓存(若未分配或需扩容可在此统一申请)
- if (g_pcm_send_cache == NULL) {
- g_pcm_send_cache = (uint8_t *)malloc(AUDIO_SEND_PCM_CACHE_ALLOC_SIZE);
- if (g_pcm_send_cache == NULL) {
- LN_MQTT_ERROR("Failed to allocate PCM send cache (%u bytes)\n", (unsigned)AUDIO_SEND_PCM_CACHE_ALLOC_SIZE);
- return -1;
- }
- g_pcm_send_cache_capacity = AUDIO_SEND_PCM_CACHE_ALLOC_SIZE;
- g_pcm_send_cache_size = 0;
- LN_MQTT_DEBUG("PCM send cache allocated: %u bytes\n", g_pcm_send_cache_capacity);
- }
-
- // 创建消息队列
- create_audio_send_queue();
- if (g_audio_send_queue == 0xFFFFFFFF) {
- LN_MQTT_ERROR("Failed to create audio send queue\n");
- if (g_pcm_send_cache != NULL) {
- free(g_pcm_send_cache);
- g_pcm_send_cache = NULL;
- g_pcm_send_cache_capacity = 0;
- }
- return -1;
- }
-
- // 创建发送线程(如果尚未创建)
- if (!g_audio_send_thread_running) {
- app_task_definition_ext_t send_task = {
- .attr = {
- .name = "ln_udp_audio_send",
- .stack_size = 0x4000,
- .priority = osPriorityNormal
- },
- .func = ln_udp_audio_send_thread,
- .task_handle = &g_audio_send_thread_handle,
- .create_queue_handle = NULL,
- .use_mem = USE_EXTEND_MEM,
- .inst_args = NULL
- };
-
- g_audio_send_thread_running = true;
- errcode_t ret = uapi_create_osThread_custom_with_args(&send_task);
- if (ret != ERRCODE_SUCC) {
- LN_MQTT_ERROR("Failed to create audio send thread: %d\n", ret);
- g_audio_send_thread_running = false;
- return -1;
- }
- LN_MQTT_INFO("Audio send thread created successfully\n");
- }
-
- return 0;
- }
-
- /**
- * @brief 停止音频发送线程
- */
- void ln_udp_audio_send_deinit(void)
- {
- g_pcm_send_cache_size = 0;
- g_pcm_send_cache_capacity = 0;
- if (g_pcm_send_cache != NULL) {
- free(g_pcm_send_cache);
- g_pcm_send_cache = NULL;
- }
- // 停止发送线程
- if (g_audio_send_thread_running) {
- LN_MQTT_INFO("Stopping audio send thread\n");
- g_audio_send_thread_running = false;
-
- // 发送一个空消息唤醒线程(如果队列为空)
- // 注意:data 为 NULL,size 为 0,线程会检查并释放
- audio_send_msg_t wake_msg = {0};
- wake_msg.data = NULL;
- wake_msg.size = 0;
- wake_msg.encoding = AUDIO_SEND_ENCODING_OPUS;
- osal_msg_queue_write_copy(g_audio_send_queue, (void *)&wake_msg, sizeof(audio_send_msg_t), 0);
-
- // 等待线程退出(最多等待2秒)
- uint32_t timeout = osKernelGetTickCount() + osKernelGetTickFreq() * 2;
- while (g_audio_send_thread_handle != 0 && osKernelGetTickCount() < timeout) {
- osDelay(10);
- }
-
- if (g_audio_send_thread_handle != 0) {
- LN_MQTT_WARN("Audio send thread did not exit in time\n");
- }
-
- g_audio_send_thread_handle = 0;
- }
-
- // 清空队列中剩余的消息(释放内存)
- if (g_audio_send_queue != 0xFFFFFFFF) {
- audio_send_msg_t msg;
- uint32_t msgsize = sizeof(audio_send_msg_t);
- while (osal_msg_queue_read_copy(g_audio_send_queue, (void *)&msg, &msgsize, 0) == OSAL_SUCCESS) {
- if (msg.data != NULL) {
- free(msg.data);
- }
- msgsize = sizeof(audio_send_msg_t);
- }
- }
-
- // 删除消息队列
- if (g_audio_send_queue != 0xFFFFFFFF) {
- osal_msg_queue_delete(g_audio_send_queue);
- g_audio_send_queue = 0xFFFFFFFF;
- LN_MQTT_DEBUG("Audio send queue deleted\n");
- }
- }
-
- /**
- * @brief 将音频数据放入发送队列(供录音回调函数调用)
- * @param data 音频数据指针
- * @param size 音频数据大小
- * @return 0 成功,-1 失败
- * @note 函数内部会动态分配内存并复制数据,发送线程负责释放内存
- * @param encoding AUDIO_SEND_ENCODING_OPUS(0)=已是 Opus;AUDIO_SEND_ENCODING_PCM(1)=PCM,发送前编码为 Opus
- */
- int ln_udp_audio_send_enqueue(const uint8_t *data, uint32_t size, uint8_t encoding)
- {
- if (!data || size == 0 || size > AUDIO_SEND_MAX_DATA_SIZE) {
- LN_MQTT_WARN("Invalid parameters for audio send enqueue\n");
- return -1;
- }
-
- if (g_audio_send_queue == 0xFFFFFFFF) {
- LN_MQTT_WARN("Audio send queue not initialized\n");
- return -1;
- }
-
- // 动态分配内存并复制数据
- uint8_t *data_copy = (uint8_t *)malloc(size);
- if (data_copy == NULL) {
- LN_MQTT_ERROR("Failed to allocate memory for audio data\n");
- return -1;
- }
- memcpy(data_copy, data, size);
-
- // 构造消息
- audio_send_msg_t msg;
- msg.data = data_copy;
- msg.size = size;
- msg.encoding = (encoding != AUDIO_SEND_ENCODING_PCM) ? AUDIO_SEND_ENCODING_OPUS : AUDIO_SEND_ENCODING_PCM;
-
- // 写入队列(非阻塞,如果队列满则丢弃并释放内存)
- int32_t ret = osal_msg_queue_write_copy(g_audio_send_queue, (void *)&msg, sizeof(audio_send_msg_t), 0);
- if (ret != OSAL_SUCCESS) {
- LN_MQTT_WARN("Failed to enqueue audio data: %d (queue may be full)\n", ret);
- free(data_copy); // 队列满时释放内存
- return -1;
- }
-
- return 0;
- }
\ No newline at end of file
+
+/**
+ * @brief 刷新双流数据包缓存(按顺序处理缓存中的包)
+ */
+static bool ln_udp_dual_stream_flush_cache(void)
+{
+ bool found = true;
+ while (found) {
+ found = false;
+ // 查找期望序列号的包
+ for (int i = 0; i < OGG_PACKET_CACHE_SIZE; i++) {
+ if (g_ogg_packet_cache[i].valid &&
+ g_ogg_packet_cache[i].sequence == g_ogg_expected_sequence) {
+ // 找到期望的包,解码并发送
+ if (ln_udp_dual_stream_decode_and_send(g_ogg_packet_cache[i].sequence,
+ g_ogg_packet_cache[i].data,
+ g_ogg_packet_cache[i].data_size) == 0) {
+ g_ogg_expected_sequence++;
+ // 释放缓存数据
+ free(g_ogg_packet_cache[i].data);
+ g_ogg_packet_cache[i].data = NULL;
+ g_ogg_packet_cache[i].valid = false;
+ g_ogg_packet_cache[i].sequence = 0;
+ g_ogg_packet_cache[i].data_size = 0;
+ found = true; // 继续查找下一个期望的包
+ LN_MQTT_DEBUG("Dual stream: Flushed cached packet sequence=%u\n",
+ g_ogg_expected_sequence - 1);
+ break; // 重新开始查找
+ } else {
+ // 解码失败,停止刷新
+ found = false;
+ break;
+ }
+ }
+ }
+ }
+ return found;
+}
+
+/**
+ * @brief 处理双流数据包(支持乱序接收和缓存)
+ * @param sequence 数据包序列号
+ * @param data 解密后的数据(所有权转移,函数内部负责释放)
+ * @param data_size 数据大小
+ * @return 0 成功,-1 失败
+ * @note 此函数会接管 data 的所有权,调用者不应再释放 data
+ */
+static int ln_udp_dual_stream_handle_packet(uint32_t sequence, const uint8_t *data, uint32_t data_size)
+{
+ // 初始化期望序列号(首次接收)
+ if (g_ogg_expected_sequence == 0) {
+ g_ogg_expected_sequence = sequence;
+ g_ogg_out_of_order_count = 0; // 重置错序计数器
+ LN_MQTT_DEBUG("Dual stream: Initialized expected sequence to %u\n", sequence);
+ }
+
+ // 检查是否是期望的下一个包
+ if (sequence == g_ogg_expected_sequence) {
+ // 是期望的包,直接解码并发送
+ if (ln_udp_dual_stream_decode_and_send(sequence, data, data_size) == 0) {
+ g_ogg_expected_sequence++;
+ g_ogg_out_of_order_count = 0; // 重置错序计数器(收到期望的包)
+ free((void *)data); // 释放数据(所有权已转移)
+
+ // 尝试刷新缓存中的后续包
+ ln_udp_dual_stream_flush_cache();
+ return 0;
+ } else {
+ // 解码失败,缓存这个包
+ ln_udp_ogg_cache_packet(sequence, data, data_size);
+ free((void *)data);
+ return -1;
+ }
+ } else if (sequence > g_ogg_expected_sequence) {
+ // 是未来的包,缓存起来
+ g_ogg_out_of_order_count++; // 增加错序计数器
+ LN_MQTT_DEBUG("Dual stream: Received future packet sequence=%u (expected=%u), caching (out_of_order_count=%u)\n",
+ sequence, g_ogg_expected_sequence, g_ogg_out_of_order_count);
+
+ // 如果连续错序超过阈值,跳过期望的序列号(避免丢包时一直无法正常输出)
+ if (g_ogg_out_of_order_count > OGG_MAX_OUT_OF_ORDER_COUNT) {
+ uint32_t old_expected = g_ogg_expected_sequence;
+ LN_MQTT_WARN("Dual stream: Out of order count exceeded %d, skipping sequence %u\n",
+ OGG_MAX_OUT_OF_ORDER_COUNT, g_ogg_expected_sequence);
+
+ // 1. 先将期望序号往后加一(跳过丢失的包)
+ g_ogg_expected_sequence++;
+
+ // 2. 处理缓存中的包(尝试解码并发送缓存中所有能处理的连续包)
+ bool found = ln_udp_dual_stream_flush_cache();
+ if (found) {
+ g_ogg_out_of_order_count = 0; // 重置计数器
+ LN_MQTT_DEBUG("Dual stream: Successfully flushed cache\n");
+ } else {
+ LN_MQTT_WARN("Dual stream: Failed to flush cache\n");
+ }
+
+ // 3. 再尝试处理当前包
+ if (sequence == g_ogg_expected_sequence) {
+ // 当前包正好是期望的包,直接解码并发送
+ if (ln_udp_dual_stream_decode_and_send(sequence, data, data_size) == 0) {
+ g_ogg_expected_sequence++;
+ free((void *)data);
+ // 继续刷新缓存中的后续包
+ ln_udp_dual_stream_flush_cache();
+ LN_MQTT_DEBUG("Dual stream: Successfully decoded and sent skipped packet sequence=%u (old_expected=%u)\n",
+ sequence, old_expected);
+ return 0;
+ } else {
+ // 解码失败,缓存这个包
+ ln_udp_ogg_cache_packet(sequence, data, data_size);
+ free((void *)data);
+ return -1;
+ }
+ } else if (sequence > g_ogg_expected_sequence) {
+ // 当前包仍然是未来的包,缓存起来
+ LN_MQTT_DEBUG("Dual stream: Current packet sequence=%u still ahead of expected=%u after skip, caching\n",
+ sequence, g_ogg_expected_sequence);
+ ln_udp_ogg_cache_packet(sequence, data, data_size);
+ free((void *)data);
+ return 0;
+ } else {
+ // 当前包已经是过去的包(在刷新缓存时已处理),丢弃
+ LN_MQTT_DEBUG("Dual stream: Current packet sequence=%u is now old (expected=%u), dropping\n",
+ sequence, g_ogg_expected_sequence);
+ free((void *)data);
+ return 0;
+ }
+ } else {
+ // 正常缓存未来包
+ ln_udp_ogg_cache_packet(sequence, data, data_size);
+ free((void *)data);
+ return 0;
+ }
+ } else {
+ // 是过去的包(重复或乱序),丢弃
+ LN_MQTT_DEBUG("Dual stream: Received old/duplicate packet sequence=%u (expected=%u), dropping\n",
+ sequence, g_ogg_expected_sequence);
+ free((void *)data);
+ return 0;
+ }
+}
+#endif /* USE_DUAL_STREAM_INTERFACE */
+
+/* 接收线程内固定时间间隔(秒)后重新创建 socket,0 表示不按时间重建 */
+#define UDP_RECV_RECREATE_INTERVAL_SEC 0
+/* UDP 客户端本地端口绑定策略
+ * - UDP_CLIENT_LOCAL_BIND_PORT > 0: 绑定到指定本地端口
+ * - 否则且 UDP_CLIENT_BIND_TO_SERVER_PORT=1: 绑定到 hello 下发的 udp.port
+ * - 否则: 绑定到 0(由系统分配临时端口)
+ */
+#ifndef UDP_CLIENT_BIND_TO_SERVER_PORT
+#define UDP_CLIENT_BIND_TO_SERVER_PORT 1
+#endif
+#ifndef UDP_CLIENT_LOCAL_BIND_PORT
+#define UDP_CLIENT_LOCAL_BIND_PORT 50001
+#endif
+
+/**
+ * @brief 仅创建并配置 UDP socket(不启动线程),供创建与接收线程内重建复用
+ * @return socket fd,失败返回 -1
+ */
+static int ln_udp_create_socket_fd_only(void)
+{
+ ln_mqtt_udp_info_t udp_info;
+ if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
+ return -1;
+ }
+ int fd = lwip_socket(AF_INET, SOCK_DGRAM, 0);
+ if (fd < 0) {
+ return -1;
+ }
+ int opt = 1;
+ lwip_setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+ /* UDP 客户端显式绑定本地端口 */
+ uint16_t local_bind_port = 0;
+#if UDP_CLIENT_LOCAL_BIND_PORT > 0
+ local_bind_port = (uint16_t)UDP_CLIENT_LOCAL_BIND_PORT;
+#elif UDP_CLIENT_BIND_TO_SERVER_PORT
+ local_bind_port = udp_info.port;
+#else
+ local_bind_port = 0;
+#endif
+ struct sockaddr_in local_addr;
+ memset(&local_addr, 0, sizeof(local_addr));
+ local_addr.sin_family = AF_INET;
+ local_addr.sin_addr.s_addr = lwip_htonl(INADDR_ANY);
+ local_addr.sin_port = lwip_htons(local_bind_port);
+
+ if (lwip_bind(fd, (struct sockaddr *)&local_addr, sizeof(local_addr)) < 0) {
+ LN_MQTT_ERROR("Failed to bind UDP local port %u: %s\n", local_bind_port, strerror(errno));
+ lwip_close(fd);
+ return -1;
+ }
+ LN_MQTT_INFO("UDP local bind success, port=%u\n", local_bind_port);
+ return fd;
+}
+
+/**
+ * @brief UDP接收线程
+ */
+static void ln_udp_recv_thread(void *arg)
+{
+ (void)arg;
+ uint8_t recv_buffer[UDP_RECV_BUFFER_SIZE];
+ struct sockaddr_in server_addr;
+ socklen_t addr_len = sizeof(server_addr);
+ uint32_t last_recreate_tick = 0;
+ uint32_t recreate_interval_ticks = 0;
+
+ LN_MQTT_INFO("Receive thread started\n");
+
+ // 获取服务器地址信息
+ ln_mqtt_udp_info_t udp_info;
+ if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
+ LN_MQTT_WARN("UDP info not available in receive thread\n");
+ g_udp_thread_running = false;
+ return;
+ }
+
+ // 设置服务器地址
+ memset(&server_addr, 0, sizeof(server_addr));
+ server_addr.sin_family = AF_INET;
+ server_addr.sin_port = lwip_htons(udp_info.port);
+ server_addr.sin_addr.s_addr = inet_addr(udp_info.server);
+
+ if (UDP_RECV_RECREATE_INTERVAL_SEC > 0) {
+ recreate_interval_ticks = (uint32_t)osKernelGetTickFreq() * UDP_RECV_RECREATE_INTERVAL_SEC;
+ last_recreate_tick = osKernelGetTickCount();
+ }
+
+ while (g_udp_thread_running && g_udp_socket >= 0) {
+ LN_MQTT_DEBUG("g_udp_thread_running %d g_udp_socket %d\r\n", g_udp_thread_running, g_udp_socket);
+ // 固定时间间隔到达则重新创建 socket
+ if (UDP_RECV_RECREATE_INTERVAL_SEC > 0 && recreate_interval_ticks > 0) {
+ uint32_t now = osKernelGetTickCount();
+ if ((now - last_recreate_tick) >= recreate_interval_ticks) {
+ LN_MQTT_INFO("Recreate interval reached (%u s), recreating socket\n", (unsigned)UDP_RECV_RECREATE_INTERVAL_SEC);
+ lwip_close(g_udp_socket);
+ g_udp_socket = ln_udp_create_socket_fd_only();
+ if (g_udp_socket < 0) {
+ LN_MQTT_ERROR("Failed to recreate socket: %s\n", strerror(errno));
+ break;
+ }
+ /* 重新获取 UDP 地址信息(服务端地址/端口可能变化) */
+ if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
+ LN_MQTT_WARN("UDP info not available after recreate, keep last address\n");
+ } else {
+ memset(&server_addr, 0, sizeof(server_addr));
+ server_addr.sin_family = AF_INET;
+ server_addr.sin_port = lwip_htons(udp_info.port);
+ server_addr.sin_addr.s_addr = inet_addr(udp_info.server);
+ addr_len = sizeof(server_addr);
+ }
+ last_recreate_tick = osKernelGetTickCount();
+ }
+ }
+
+ // 接收UDP数据(阻塞,超时1秒)
+ fd_set read_fds;
+ struct timeval timeout;
+
+ FD_ZERO(&read_fds);
+ FD_SET(g_udp_socket, &read_fds);
+ timeout.tv_sec = 1;
+ timeout.tv_usec = 0;
+
+ int select_ret = lwip_select(g_udp_socket + 1, &read_fds, NULL, NULL, &timeout);
+ if (select_ret > 0 && FD_ISSET(g_udp_socket, &read_fds)) {
+ // 有数据可读
+ ssize_t recv_len = lwip_recvfrom(g_udp_socket, recv_buffer, sizeof(recv_buffer) - 1, 0,
+ (struct sockaddr *)&server_addr, &addr_len);
+
+ if (recv_len > 0) {
+ LN_MQTT_DEBUG("Received %d bytes\r\n",
+ (int)recv_len
+ );
+
+ // 处理接收到的数据(解包、解密)
+ ln_udp_process_received_data(recv_buffer, (uint16_t)recv_len);
+
+ } else if (recv_len == 0) {
+ LN_MQTT_INFO("Connection closed by peer\n");
+ break;
+ } else {
+ if (errno != EAGAIN && errno != EWOULDBLOCK) {
+ LN_MQTT_ERROR("Recvfrom error: %s\n", strerror(errno));
+ }
+ }
+ } else if (select_ret < 0) {
+ LN_MQTT_DEBUG("select_ret %d\r\n", select_ret);
+ if (errno != EINTR) {
+ LN_MQTT_ERROR("Select error: %s\n", strerror(errno));
+ break;
+ }
+ }
+ // select_ret == 0 表示超时,继续循环
+ }
+
+ LN_MQTT_INFO("Receive thread exited\n");
+ g_udp_thread_running = false;
+}
+
+/**
+ * @brief 创建UDP套接字
+ * @return 0 成功,-1 失败
+ */
+int ln_udp_create_socket(void)
+{
+ // 获取UDP信息
+ ln_mqtt_udp_info_t udp_info;
+ if (ln_mqtt_api_get_udp_info(&udp_info) != 0) {
+ LN_MQTT_WARN("UDP info not available, cannot create socket\n");
+ return -1;
+ }
+
+ if (!udp_info.valid) {
+ LN_MQTT_WARN("UDP info invalid, cannot create socket\n");
+ return -1;
+ }
+
+ LN_MQTT_INFO("Creating UDP socket for server: %s:%d\n", udp_info.server, udp_info.port);
+
+ // 如果socket已存在,先关闭
+ if (g_udp_socket >= 0) {
+ LN_MQTT_DEBUG("Closing existing UDP socket\n");
+ ln_udp_close_socket();
+ }
+
+ // 创建UDP套接字(复用仅创建 fd 的逻辑)
+ g_udp_socket = ln_udp_create_socket_fd_only();
+ if (g_udp_socket < 0) {
+ LN_MQTT_ERROR("Failed to create UDP socket: %s\n", strerror(errno));
+ return -1;
+ }
+
+ LN_MQTT_INFO("UDP socket created successfully, fd=%d\n", g_udp_socket);
+
+ // 创建接收线程
+ if (!g_udp_thread_running) {
+ app_task_definition_ext_t recv_task = {
+ .attr = {
+ .name = "ln_udp_recv",
+ .stack_size = 0x8000,
+ .priority = osPriorityNormal
+ },
+ .func = ln_udp_recv_thread,
+ .task_handle = &g_udp_thread_handle,
+ .create_queue_handle = NULL,
+ .use_mem = USE_EXTEND_MEM,
+ .inst_args = NULL
+ };
+
+ g_udp_thread_running = true;
+ errcode_t ret = uapi_create_osThread_custom_with_args(&recv_task);
+ if (ret != ERRCODE_SUCC) {
+ LN_MQTT_ERROR("Failed to create receive thread: %d\n", ret);
+ g_udp_thread_running = false;
+ lwip_close(g_udp_socket);
+ g_udp_socket = -1;
+ return -1;
+ }
+ LN_MQTT_INFO("Receive thread created successfully\n");
+ }
+
+ return 0;
+}
+
+/**
+ * @brief 关闭UDP套接字
+ */
+void ln_udp_close_socket(void)
+{
+ // 完成并关闭 OGG 文件
+ if (g_ogg_initialized) {
+ ln_udp_ogg_complete_current_file();
+ }
+
+ // 完成并关闭 Opus 调试文件
+#if ENABLE_OPUS_RAW_DEBUG
+ if (g_opus_debug_file != NULL) {
+ ln_udp_opus_debug_complete_current_file();
+ }
+#endif
+
+ // 停止接收线程
+ if (g_udp_thread_running) {
+ LN_MQTT_INFO("Stopping receive thread\n");
+ g_udp_thread_running = false;
+
+ // 等待线程退出(最多等待2秒)
+ uint32_t timeout = osKernelGetTickCount() + osKernelGetTickFreq() * 2;
+ while (g_udp_thread_handle != 0 && osKernelGetTickCount() < timeout) {
+ osDelay(10);
+ }
+
+ if (g_udp_thread_handle != 0) {
+ LN_MQTT_WARN("Receive thread did not exit in time\n");
+ }
+
+ g_udp_thread_handle = 0;
+ }
+
+ // 关闭套接字
+ if (g_udp_socket >= 0) {
+ LN_MQTT_DEBUG("Closing UDP socket, fd=%d\n", g_udp_socket);
+ lwip_close(g_udp_socket);
+ g_udp_socket = -1;
+ }
+}
+
+/**
+ * @brief 获取UDP套接字文件描述符
+ * @return socket文件描述符,-1表示未创建
+ */
+int ln_udp_get_socket(void)
+{
+ return g_udp_socket;
+}
+
+/**
+ * @brief 检查UDP套接字是否已创建
+ * @return true 已创建,false 未创建
+ */
+bool ln_udp_is_socket_created(void)
+{
+ return (g_udp_socket >= 0);
+}
+
+// +------+-------+-------------+----------+------------+----------+-------------------+
+// | Type | Flags | Payload Len | SSRC | Timestamp | Sequence | Encrypted Payload |
+// +------+-------+-------------+----------+------------+----------+-------------------+
+// |1 byte|1 byte | 2 bytes | 4 bytes | 4 bytes | 4 bytes | N bytes |
+// +------+-------+-------------+----------+------------+----------+-------------------+
+
+
+// import struct
+// from Crypto.Cipher import AES
+// from Crypto.Util import Counter
+
+// def encrypt_audio(key_hex: str, nonce_hex: str, timestamp: int, sequence: int, audio_data: bytes) -> bytes:
+// """
+// 加密音频数据
+
+// Args:
+// key_hex: 32字符十六进制密钥
+// nonce_hex: 32字符十六进制nonce
+// timestamp: 数据包时间戳
+// sequence: 数据包序列号
+// audio_data: 原始Opus音频数据
+
+// Returns:
+// 加密后的音频数据
+// """
+// key = bytes.fromhex(key_hex)
+// nonce = bytes.fromhex(nonce_hex)
+
+// # 构建计数器初始值:结合timestamp和sequence
+// counter_init = int.from_bytes(nonce[:12] + struct.pack('>I', sequence), 'big')
+// ctr = Counter.new(128, initial_value=counter_init)
+
+// cipher = AES.new(key, AES.MODE_CTR, counter=ctr)
+// return cipher.encrypt(audio_data)
+
+// def decrypt_audio(key_hex: str, nonce_hex: str, timestamp: int, sequence: int, encrypted_data: bytes) -> bytes:
+// """解密音频数据(与加密相同,CTR模式对称)"""
+// return encrypt_audio(key_hex, nonce_hex, timestamp, sequence, encrypted_data)
+
+/**
+ * @brief 完整的数据打包函数(加密+打包)
+ * @param audio_data 原始音频数据
+ * @param audio_len 音频数据长度
+ * @param buffer 输出缓冲区(由调用者分配,大小至少为 UDP_PACKET_HEADER_SIZE + audio_len)
+ * @param buffer_size 缓冲区大小
+ * @param out_len 输出的实际数据长度
+ * @return 0 成功,-1 失败
+ * @note 函数内部自动处理type、flags、ssrc、timestamp、sequence等字段
+ */
+int ln_udp_pack_audio_data(const uint8_t *audio_data, uint16_t audio_len,
+ uint8_t *buffer, uint16_t buffer_size, uint16_t *out_len)
+{
+ if (!audio_data || audio_len == 0 || !buffer || !out_len) {
+ LN_MQTT_WARN("Invalid parameters for pack audio data\n");
+ return -1;
+ }
+
+ // 计算所需缓冲区大小
+ uint16_t total_len = UDP_PACKET_HEADER_SIZE + audio_len;
+ if (buffer_size < total_len) {
+ LN_MQTT_WARN("Buffer too small: need %d, have %d\n", total_len, buffer_size);
+ return -1;
+ }
+
+ // 1. 获取UDP信息(用于加密)
+ ln_mqtt_udp_info_t udp_info;
+ if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
+ LN_MQTT_WARN("UDP info not available for encryption\n");
+ return -1;
+ }
+ // 01 00 00 00 1d 38 db 20 69 70 a0 da 00000000
+ // 2. 初始化SSRC(如果未初始化,从 nonce 字节数组的索引 4-8 提取,只取 4 个字节)
+ if (g_udp_ssrc == 0) {
+ if (ln_data_nonce_to_ssrc(udp_info.nonce, &g_udp_ssrc) == 0) {
+ LN_MQTT_DEBUG("SSRC initialized from nonce bytes[4-7], ssrc=0x%08X\n", g_udp_ssrc);
+ } else {
+ LN_MQTT_WARN("Failed to convert nonce to bytes, using default SSRC\n");
+ g_udp_ssrc = 0x12345678;
+ }
+ }
+
+ // 3. 自动递增序列号
+ uint32_t sequence = g_udp_sequence++;
+
+ // 4. 获取时间戳(使用系统时钟)
+ uint32_t timestamp = (uint32_t)osKernelGetTickCount(); // 使用系统tick作为时间戳
+
+ // 5. 设置数据包类型和标志(使用默认值)
+ uint8_t type = 0x01; // 默认类型
+ uint8_t flags = 0; // 默认标志
+
+ // 6. 加密音频数据(nonce在函数内部构造)
+ uint8_t *encrypted_payload = buffer + UDP_PACKET_HEADER_SIZE;
+ if (ln_udp_encrypt_audio(udp_info.key, udp_info.nonce, audio_len, timestamp, sequence,
+ audio_data, audio_len, encrypted_payload) != 0) {
+ LN_MQTT_ERROR("Failed to encrypt audio data\n");
+ return -1;
+ }
+
+ // 7. 打包数据包头部
+ uint8_t *ptr = buffer;
+ ptr[0] = type;
+ ptr[1] = flags;
+ *(uint16_t *)(ptr + 2) = lwip_htons(audio_len); // payload_len(加密后的长度等于原始长度)
+ *(uint32_t *)(ptr + 4) = lwip_htonl(g_udp_ssrc);
+ *(uint32_t *)(ptr + 8) = lwip_htonl(timestamp);
+ *(uint32_t *)(ptr + 12) = lwip_htonl(sequence);
+
+ // 加密的payload已经在步骤6中写入buffer + UDP_PACKET_HEADER_SIZE位置
+
+ *out_len = total_len;
+
+ LN_MQTT_DEBUG("buffer: ");
+ for (int i = 0; i < 16; i++) {
+ LN_MQTT_DEBUG("%02x ", buffer[i]);
+ }
+ LN_MQTT_DEBUG("\n");
+
+ LN_MQTT_DEBUG("Audio data packed: type=%d, flags=%d, ssrc=0x%08X, timestamp=%u, sequence=%u, payload_len=%d, total_len=%d\n",
+ type, flags, g_udp_ssrc, timestamp, sequence, audio_len, total_len);
+
+ return 0;
+}
+
+/**
+ * @brief 创建音频发送队列
+ */
+static void create_audio_send_queue(void)
+{
+ if (g_audio_send_queue != 0xFFFFFFFF) {
+ // 队列已创建
+ return;
+ }
+
+ if (osal_msg_queue_create("ln_udp_audio_send_queue", AUDIO_SEND_QUEUE_SIZE, &g_audio_send_queue,
+ 0, sizeof(audio_send_msg_t)) != ERRCODE_SUCC) {
+ LN_MQTT_ERROR("Failed to create audio send queue\n");
+ g_audio_send_queue = 0xFFFFFFFF;
+ } else {
+ LN_MQTT_INFO("Audio send queue created successfully\n");
+ }
+}
+
+/**
+ * @brief 发送单帧音频数据(打包/加密 + 发送)
+ * @note 复用原有 ln_udp_pack_audio_data 加密逻辑
+ * @return 0 成功,-1 失败
+ */
+static int ln_udp_send_audio_frame(int sock, const uint8_t *audio_data, uint32_t audio_size)
+{
+ if (audio_data == NULL || audio_size == 0 || audio_size > AUDIO_SEND_MAX_DATA_SIZE) {
+ return -1;
+ }
+
+ // 打包(加密+UDP头)
+ uint8_t send_buf[UDP_PACKET_HEADER_SIZE + AUDIO_SEND_MAX_DATA_SIZE];
+ uint16_t out_len = 0;
+ if (ln_udp_pack_audio_data(audio_data, (uint16_t)audio_size, send_buf,
+ (uint16_t)sizeof(send_buf), &out_len) != 0) {
+ LN_MQTT_ERROR("Failed to pack audio frame\n");
+ return -1;
+ }
+
+ // 获取UDP信息(用于发送)
+ ln_mqtt_udp_info_t udp_info;
+ if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
+ LN_MQTT_WARN("UDP info not available, drop audio frame\n");
+ return -1;
+ }
+
+ // 发送到服务器
+ struct sockaddr_in server_addr;
+ memset(&server_addr, 0, sizeof(server_addr));
+ server_addr.sin_family = AF_INET;
+ server_addr.sin_port = lwip_htons(udp_info.port);
+ server_addr.sin_addr.s_addr = inet_addr(udp_info.server);
+
+ ssize_t sent = lwip_sendto(sock, send_buf, out_len, 0,
+ (struct sockaddr *)&server_addr, sizeof(server_addr));
+ if (sent < 0) {
+ LN_MQTT_ERROR("UDP sendto failed: %s\n", strerror(errno));
+ return -1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief 音频数据发送线程
+ */
+static void ln_udp_audio_send_thread(void *arg)
+{
+ (void)arg;
+ audio_send_msg_t msg;
+ uint32_t msgsize = sizeof(audio_send_msg_t);
+
+ LN_MQTT_INFO("Audio send thread started\n");
+
+ while (g_audio_send_thread_running) {
+ // 从队列读取音频数据(阻塞等待)
+ int32_t ret = osal_msg_queue_read_copy(g_audio_send_queue, (void *)&msg, &msgsize,
+ OSAL_MSGQ_WAIT_FOREVER);
+ if (ret != OSAL_SUCCESS) {
+ LN_MQTT_ERROR("Failed to read from audio send queue: %d\n", ret);
+ continue;
+ }
+
+ // 检查数据大小和数据指针
+ if (msg.size == 0 || msg.size > AUDIO_SEND_MAX_DATA_SIZE || msg.data == NULL) {
+ LN_MQTT_WARN("Invalid audio data: size=%u, data=%p\n", msg.size, msg.data);
+ // 释放内存(如果存在)
+ if (msg.data != NULL) {
+ free(msg.data);
+ }
+ continue;
+ }
+
+ // 确保 UDP socket 已创建
+ if (!ln_udp_is_socket_created()) {
+ LN_MQTT_WARN("UDP socket not ready, drop audio frame\n");
+ free(msg.data);
+ continue;
+ }
+
+ int sock = ln_udp_get_socket();
+ if (sock < 0) {
+ LN_MQTT_WARN("UDP socket invalid, drop audio frame\n");
+ free(msg.data);
+ continue;
+ }
+
+ const uint8_t *send_data = msg.data;
+ uint32_t send_size = msg.size;
+ if (msg.encoding == AUDIO_SEND_ENCODING_PCM) {
+ /* PCM:追加到缓存,按 60ms 切割编码,余量保留 */
+ if (g_pcm_send_cache == NULL) {
+ LN_MQTT_WARN("PCM cache not allocated, drop %u bytes\n", msg.size);
+ free(msg.data);
+ continue;
+ }
+ while (g_pcm_send_cache_size + msg.size > g_pcm_send_cache_capacity &&
+ g_pcm_send_cache_size >= AUDIO_SEND_PCM_FRAME_BYTES) {
+ /* 缓存满时丢弃最旧一帧,避免持续溢出 */
+ g_pcm_send_cache_size -= AUDIO_SEND_PCM_FRAME_BYTES;
+ memmove(g_pcm_send_cache, g_pcm_send_cache + AUDIO_SEND_PCM_FRAME_BYTES, g_pcm_send_cache_size);
+ }
+ if (g_pcm_send_cache_size + msg.size > g_pcm_send_cache_capacity) {
+ LN_MQTT_WARN("PCM cache full, drop %u bytes (cache=%u, cap=%u)\n", msg.size, g_pcm_send_cache_size, g_pcm_send_cache_capacity);
+ free(msg.data);
+ continue;
+ }
+ memcpy(g_pcm_send_cache + g_pcm_send_cache_size, msg.data, msg.size);
+ g_pcm_send_cache_size += msg.size;
+ free(msg.data);
+ msg.data = NULL;
+
+ /* 每次取 60ms 固定长度编码并发送,多余数据留在缓存 */
+ uint8_t opus_buf[1500];
+
+ while (g_pcm_send_cache_size >= AUDIO_SEND_PCM_FRAME_BYTES) {
+ int encoded_len = 0;
+ LN_MQTT_DEBUG("PCM send cache size: %d\n", g_pcm_send_cache_size);
+ for (int i = 0; i < AUDIO_SEND_PCM_FRAME_BYTES; i++) {
+ LN_MQTT_DEBUG("%02x ", g_pcm_send_cache[i]);
+ }
+ LN_MQTT_DEBUG("\n");
+
+ if (opus_pcm_to_frame_encode_packet(
+ (const short *)g_pcm_send_cache, AUDIO_SEND_PCM_FRAME_SAMPLES,
+ AUDIO_SEND_PCM_SAMPLE_RATE, AUDIO_SEND_PCM_CHANNELS,
+ AUDIO_SEND_PCM_BITRATE, AUDIO_SEND_PCM_APPLICATION,
+ opus_buf, (int)sizeof(opus_buf), &encoded_len) != 0) {
+ LN_MQTT_WARN("PCM to Opus encode failed, drop 60ms frame\n");
+ break;
+ }
+ LN_MQTT_DEBUG("Opus encoded len: %d\n", encoded_len);
+ LN_MQTT_DEBUG("Opus encoded data: ");
+ for (int i = 0; i < encoded_len; i++) {
+ LN_MQTT_DEBUG("%02x ", opus_buf[i]);
+ }
+ LN_MQTT_DEBUG("\n");
+ if (ln_udp_send_audio_frame(sock, opus_buf, (uint32_t)encoded_len) != 0) {
+ break;
+ }
+ /* 移除已编码的一帧,保留余量 */
+ g_pcm_send_cache_size -= AUDIO_SEND_PCM_FRAME_BYTES;
+ memmove(g_pcm_send_cache, g_pcm_send_cache + AUDIO_SEND_PCM_FRAME_BYTES, g_pcm_send_cache_size);
+ }
+ continue;
+ }
+
+ (void)send_data;
+ if (ln_udp_send_audio_frame(sock, send_data, send_size) != 0) {
+ free(msg.data);
+ continue;
+ }
+
+ // 释放音频数据内存
+ free(msg.data);
+ msg.data = NULL;
+ }
+
+ LN_MQTT_INFO("Audio send thread exited\n");
+ g_audio_send_thread_running = false;
+}
+
+/**
+ * @brief 初始化音频发送队列和线程
+ * @return 0 成功,-1 失败
+ */
+int ln_udp_audio_send_init(void)
+{
+ // 动态分配 PCM 发送缓存(若未分配或需扩容可在此统一申请)
+ if (g_pcm_send_cache == NULL) {
+ g_pcm_send_cache = (uint8_t *)malloc(AUDIO_SEND_PCM_CACHE_ALLOC_SIZE);
+ if (g_pcm_send_cache == NULL) {
+ LN_MQTT_ERROR("Failed to allocate PCM send cache (%u bytes)\n", (unsigned)AUDIO_SEND_PCM_CACHE_ALLOC_SIZE);
+ return -1;
+ }
+ g_pcm_send_cache_capacity = AUDIO_SEND_PCM_CACHE_ALLOC_SIZE;
+ g_pcm_send_cache_size = 0;
+ LN_MQTT_DEBUG("PCM send cache allocated: %u bytes\n", g_pcm_send_cache_capacity);
+ }
+
+ // 创建消息队列
+ create_audio_send_queue();
+ if (g_audio_send_queue == 0xFFFFFFFF) {
+ LN_MQTT_ERROR("Failed to create audio send queue\n");
+ if (g_pcm_send_cache != NULL) {
+ free(g_pcm_send_cache);
+ g_pcm_send_cache = NULL;
+ g_pcm_send_cache_capacity = 0;
+ }
+ return -1;
+ }
+
+ // 创建发送线程(如果尚未创建)
+ if (!g_audio_send_thread_running) {
+ app_task_definition_ext_t send_task = {
+ .attr = {
+ .name = "ln_udp_audio_send",
+ .stack_size = 0x4000,
+ .priority = osPriorityNormal
+ },
+ .func = ln_udp_audio_send_thread,
+ .task_handle = &g_audio_send_thread_handle,
+ .create_queue_handle = NULL,
+ .use_mem = USE_EXTEND_MEM,
+ .inst_args = NULL
+ };
+
+ g_audio_send_thread_running = true;
+ errcode_t ret = uapi_create_osThread_custom_with_args(&send_task);
+ if (ret != ERRCODE_SUCC) {
+ LN_MQTT_ERROR("Failed to create audio send thread: %d\n", ret);
+ g_audio_send_thread_running = false;
+ return -1;
+ }
+ LN_MQTT_INFO("Audio send thread created successfully\n");
+ }
+
+ return 0;
+}
+
+/**
+ * @brief 停止音频发送线程
+ */
+void ln_udp_audio_send_deinit(void)
+{
+ g_pcm_send_cache_size = 0;
+ g_pcm_send_cache_capacity = 0;
+ if (g_pcm_send_cache != NULL) {
+ free(g_pcm_send_cache);
+ g_pcm_send_cache = NULL;
+ }
+ // 停止发送线程
+ if (g_audio_send_thread_running) {
+ LN_MQTT_INFO("Stopping audio send thread\n");
+ g_audio_send_thread_running = false;
+
+ // 发送一个空消息唤醒线程(如果队列为空)
+ // 注意:data 为 NULL,size 为 0,线程会检查并释放
+ audio_send_msg_t wake_msg = {0};
+ wake_msg.data = NULL;
+ wake_msg.size = 0;
+ wake_msg.encoding = AUDIO_SEND_ENCODING_OPUS;
+ osal_msg_queue_write_copy(g_audio_send_queue, (void *)&wake_msg, sizeof(audio_send_msg_t), 0);
+
+ // 等待线程退出(最多等待2秒)
+ uint32_t timeout = osKernelGetTickCount() + osKernelGetTickFreq() * 2;
+ while (g_audio_send_thread_handle != 0 && osKernelGetTickCount() < timeout) {
+ osDelay(10);
+ }
+
+ if (g_audio_send_thread_handle != 0) {
+ LN_MQTT_WARN("Audio send thread did not exit in time\n");
+ }
+
+ g_audio_send_thread_handle = 0;
+ }
+
+ // 清空队列中剩余的消息(释放内存)
+ if (g_audio_send_queue != 0xFFFFFFFF) {
+ audio_send_msg_t msg;
+ uint32_t msgsize = sizeof(audio_send_msg_t);
+ while (osal_msg_queue_read_copy(g_audio_send_queue, (void *)&msg, &msgsize, 0) == OSAL_SUCCESS) {
+ if (msg.data != NULL) {
+ free(msg.data);
+ }
+ msgsize = sizeof(audio_send_msg_t);
+ }
+ }
+
+ // 删除消息队列
+ if (g_audio_send_queue != 0xFFFFFFFF) {
+ osal_msg_queue_delete(g_audio_send_queue);
+ g_audio_send_queue = 0xFFFFFFFF;
+ LN_MQTT_DEBUG("Audio send queue deleted\n");
+ }
+}
+
+/**
+ * @brief 将音频数据放入发送队列(供录音回调函数调用)
+ * @param data 音频数据指针
+ * @param size 音频数据大小
+ * @return 0 成功,-1 失败
+ * @note 函数内部会动态分配内存并复制数据,发送线程负责释放内存
+ * @param encoding AUDIO_SEND_ENCODING_OPUS(0)=已是 Opus;AUDIO_SEND_ENCODING_PCM(1)=PCM,发送前编码为 Opus
+ */
+int ln_udp_audio_send_enqueue(const uint8_t *data, uint32_t size, uint8_t encoding)
+{
+ if (!data || size == 0 || size > AUDIO_SEND_MAX_DATA_SIZE) {
+ LN_MQTT_WARN("Invalid parameters for audio send enqueue\n");
+ return -1;
+ }
+
+ if (g_audio_send_queue == 0xFFFFFFFF) {
+ LN_MQTT_WARN("Audio send queue not initialized\n");
+ return -1;
+ }
+
+ // 动态分配内存并复制数据
+ uint8_t *data_copy = (uint8_t *)malloc(size);
+ if (data_copy == NULL) {
+ LN_MQTT_ERROR("Failed to allocate memory for audio data\n");
+ return -1;
+ }
+ memcpy(data_copy, data, size);
+
+ // 构造消息
+ audio_send_msg_t msg;
+ msg.data = data_copy;
+ msg.size = size;
+ msg.encoding = (encoding != AUDIO_SEND_ENCODING_PCM) ? AUDIO_SEND_ENCODING_OPUS : AUDIO_SEND_ENCODING_PCM;
+
+ // 写入队列(非阻塞,如果队列满则丢弃并释放内存)
+ int32_t ret = osal_msg_queue_write_copy(g_audio_send_queue, (void *)&msg, sizeof(audio_send_msg_t), 0);
+ if (ret != OSAL_SUCCESS) {
+ LN_MQTT_WARN("Failed to enqueue audio data: %d (queue may be full)\n", ret);
+ free(data_copy); // 队列满时释放内存
+ return -1;
+ }
+
+ return 0;
+}
\ No newline at end of file
/* 测试性录音数据保存到文件:1=启用,0=禁用。启用后每次开始录音创建新文件,停止时关闭。 */
#ifndef LN_MQTT_RECORD_SAVE_TO_FILE_TEST
-#define LN_MQTT_RECORD_SAVE_TO_FILE_TEST 1
+#define LN_MQTT_RECORD_SAVE_TO_FILE_TEST 0
#endif
/* MQTT API 全局状态 */
/* 传输层选择:默认启用 TCP,可通过编译宏切回 UDP */
#ifndef USE_LN_TCP_SERVICE
-#define USE_LN_TCP_SERVICE 0
+#define USE_LN_TCP_SERVICE 1
#endif
/* UDP 只创建一次模式:1=开启时断链不关闭 UDP 套接字,仅在 ln_mqtt_api_stop_service 退出时关闭;0=断链即关闭。仅在使用 UDP 传输时生效 */
printf("ln_mqtt_api_auto_subscribe_p2p client_id %s\n", client_id);
-
+
char p2p_topic[256] = {0};
int ret = snprintf(p2p_topic, sizeof(p2p_topic), "devices/p2p/%s", client_id);
if (ret <= 0 || ret >= (int)sizeof(p2p_topic)) {
#else
LN_TRANSPORT_CLOSE_SOCKET();
#endif
- set_udp_sequence(0);
- set_udp_ssrc(0);
}
}
// ln_mqtt_audio_init();
g_ln_mqtt_service_started = true;
+#if USE_DUAL_STREAM_INTERFACE
+ g_last_mqtt_activity_tick = osKernelGetTickCount();
+ if (g_keepalive_timer_id == NULL) {
+ g_keepalive_timer_id = osTimerNew(ln_mqtt_keepalive_timer_cb, osTimerPeriodic, NULL,NULL);
+ if (g_keepalive_timer_id != NULL) {
+ osTimerStart(g_keepalive_timer_id, LN_MQTT_KEEPALIVE_INTERVAL_MS);
+ LN_MQTT_DEBUG("Listen keepalive timer started (%u ms)\n", (unsigned)LN_MQTT_KEEPALIVE_INTERVAL_MS);
+ }
+ }
+#endif
LN_MQTT_INFO("MQTT service started successfully\n");
ret = uapi_pm_request_mode(PM_ID_SPI, PM_MODE_PERFORMACE);
}
LN_MQTT_INFO("Stopping MQTT service\n");
-
+#if USE_DUAL_STREAM_INTERFACE
+ if (g_keepalive_timer_id != NULL) {
+ osTimerStop(g_keepalive_timer_id);
+ osTimerDelete(g_keepalive_timer_id);
+ g_keepalive_timer_id = NULL;
+ }
+#endif
// 停止音频发送线程
LN_TRANSPORT_AUDIO_SEND_DEINIT();
// 停止MQTT主线程(会自动断开连接和清理资源)
uapi_mqtt_main_stop();
-
+
#if !USE_LN_TCP_SERVICE && LN_MQTT_UDP_SOCKET_CREATE_ONCE
/* UDP 只创建一次模式:退出时关闭套接字 */
LN_TRANSPORT_CLOSE_SOCKET();
g_ln_mqtt_service_started = false;
- set_udp_sequence(0);
- set_udp_ssrc(0);
-
LN_MQTT_INFO("MQTT service stopped\n");
}
return ret;
}
+#if USE_DUAL_STREAM_INTERFACE
+static void ln_mqtt_keepalive_timer_cb(void *arg)
+{
+ (void)arg;
+ if (!g_ln_mqtt_service_started || !uapi_mqtt_is_connected()) {
+ return;
+ }
+ uint32_t now = osKernelGetTickCount();
+ if (now - g_last_mqtt_activity_tick >= LN_MQTT_KEEPALIVE_INTERVAL_MS) {
+ /* 维持 g_recording_upload_started 不变:仅发送当前状态的 listen 消息,不启停录音 */
+ (void)ln_mqtt_send_listen_message_only(g_recording_upload_started);
+ g_last_mqtt_activity_tick = now;
+ LN_MQTT_DEBUG("Listen keepalive sent (state=%s)\n", g_recording_upload_started ? "start" : "stop");
+ }
+}
+#endif
int ln_mqtt_api_send_listen_state(bool start)
{
-/*\r
- * LN MQTT AT test commands\r
- * - Follow the style in `leiniao_api_at.c` / `uapi_mqtt_at.c`\r
- * - Provide simple AT commands to drive LN MQTT listen start/stop and hello send\r
- */\r
-\r
-#include "at_cmd_api.h"\r
-#include <stdio.h>\r
-#include <stdint.h>\r
-#include <string.h>\r
-#include <stdlib.h>\r
-#include "errcode.h"\r
-#include "ln_mqtt_api.h"\r
-#include "ln_mqtt_api_at.h"\r
-#include "cmsis_os2.h"\r
-\r
-#define ARRAY_COUNT(array) (sizeof(array) / sizeof((array)[0]))\r
-#define LN_MQTT_AT_MAX_ARGC 8\r
-#define LN_MQTT_AT_MAX_ARGV_LEN 256\r
-\r
-/* 自动停止定时器(10秒后停止录音) */\r
-static osTimerId_t g_listen_auto_stop_timer = NULL;\r
-\r
-/**\r
- * @brief 解析AT命令参数\r
- * 兼容 "AT^XXX=arg1,arg2" 或 "AT^XXX arg1 arg2"\r
- */\r
-static int ln_mqtt_at_parse_params(uint8_t *para, uint32_t paraLen,\r
- uint8_t argv[LN_MQTT_AT_MAX_ARGC][LN_MQTT_AT_MAX_ARGV_LEN],\r
- uint32_t *argc)\r
-{\r
- uint32_t pos = 0;\r
- *argc = 0;\r
-\r
- for (uint32_t i = 0; i < paraLen; i++) {\r
- if ((para[i] == ' ' || para[i] == '\n' || para[i] == ',' || para[i] == '=') && pos != 0) {\r
- argv[*argc][pos] = '\0';\r
- *argc += 1;\r
- pos = 0;\r
- if (*argc >= LN_MQTT_AT_MAX_ARGC) {\r
- return -1;\r
- }\r
- } else {\r
- if (para[i] == ' ' || para[i] == '\n' || para[i] == ',' || para[i] == '=') {\r
- continue;\r
- }\r
- argv[*argc][pos] = para[i];\r
- pos++;\r
- if (pos >= LN_MQTT_AT_MAX_ARGV_LEN) {\r
- return -1;\r
- }\r
- }\r
- }\r
- if (pos != 0) {\r
- argv[*argc][pos] = '\0';\r
- *argc += 1;\r
- }\r
-\r
- return 0;\r
-}\r
-\r
-/**\r
- * @brief 自动停止录音的定时器回调函数\r
- */\r
-static void ln_mqtt_listen_auto_stop_callback(void *arg)\r
-{\r
- (void)arg;\r
- printf("[LN_MQTT_AT] Auto stop timer expired, stopping listen...\n");\r
- (void)ln_mqtt_api_send_listen_state(false);\r
-}\r
-\r
-/* LN MQTT - 发送 listen 控制并开始/停止录音:AT^LN_MQTT_LISTEN=1/0 */\r
-static uint32_t ln_mqtt_listen_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)\r
-{\r
- (void)strCommonCmd;\r
-\r
- uint8_t argv[LN_MQTT_AT_MAX_ARGC][LN_MQTT_AT_MAX_ARGV_LEN] = {0};\r
- uint32_t argc = 0;\r
- if (ln_mqtt_at_parse_params(para, paraLen, argv, &argc) != 0 || argc < 1) {\r
- printf("Usage: AT^LN_MQTT_LISTEN=1/0\n");\r
- return ERRCODE_FAIL;\r
- }\r
-\r
- int enable = atoi((char *)argv[0]);\r
- if (enable != 0 && enable != 1) {\r
- printf("Usage: AT^LN_MQTT_LISTEN=1/0\n");\r
- return ERRCODE_FAIL;\r
- }\r
-\r
- // 如果之前有定时器在运行,先停止\r
- if (g_listen_auto_stop_timer != NULL) {\r
- if (osTimerIsRunning(g_listen_auto_stop_timer) == 1) {\r
- osTimerStop(g_listen_auto_stop_timer);\r
- }\r
- }\r
-\r
- int ret = ln_mqtt_api_send_listen_state(enable ? true : false);\r
- if (ret == 0) {\r
- printf("+LN_MQTT_LISTEN: OK\n");\r
- \r
- // 如果 enable == 1,启动10秒后自动停止的定时器\r
- if (enable == 1) {\r
- // 如果定时器未创建,先创建\r
- if (g_listen_auto_stop_timer == NULL) {\r
- g_listen_auto_stop_timer = osTimerNew((osTimerFunc_t)ln_mqtt_listen_auto_stop_callback, \r
- osTimerOnce, NULL, NULL);\r
- if (g_listen_auto_stop_timer == NULL) {\r
- printf("[LN_MQTT_AT] WARNING: Failed to create auto stop timer\n");\r
- }\r
- }\r
- \r
- // 启动定时器(10秒 = 10000毫秒)\r
- if (g_listen_auto_stop_timer != NULL) {\r
- osStatus_t timer_ret = osTimerStart(g_listen_auto_stop_timer, 10000);\r
- if (timer_ret != osOK) {\r
- printf("[LN_MQTT_AT] WARNING: Failed to start auto stop timer: %d\n", timer_ret);\r
- } else {\r
- printf("[LN_MQTT_AT] Auto stop timer started (10 seconds)\n");\r
- }\r
- }\r
- }\r
- \r
- return ERRCODE_SUCC;\r
- }\r
- printf("+LN_MQTT_LISTEN: FAIL\n");\r
- return ERRCODE_FAIL;\r
-}\r
-\r
-/* LN MQTT - 发送 hello:AT^LN_MQTT_HELLO */\r
-static uint32_t ln_mqtt_hello_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)\r
-{\r
- (void)para;\r
- (void)paraLen;\r
- (void)strCommonCmd;\r
-\r
- int ret = ln_mqtt_api_send_hello();\r
- if (ret == 0) {\r
- printf("+LN_MQTT_HELLO: OK\n");\r
- return ERRCODE_SUCC;\r
- }\r
- printf("+LN_MQTT_HELLO: FAIL\n");\r
- return ERRCODE_FAIL;\r
-}\r
-\r
-/* LN MQTT - 启动服务:AT^LN_MQTT_START_SERVICE */\r
-static uint32_t ln_mqtt_start_service_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)\r
-{\r
- (void)para;\r
- (void)paraLen;\r
- (void)strCommonCmd;\r
-\r
- printf("[LN_MQTT_AT] Starting MQTT service...\n");\r
- int ret = ln_mqtt_api_start_service(NULL);\r
- if (ret == 0) {\r
- printf("+LN_MQTT_START_SERVICE: OK\n");\r
- return ERRCODE_SUCC;\r
- }\r
- printf("+LN_MQTT_START_SERVICE: FAIL\n");\r
- return ERRCODE_FAIL;\r
-}\r
-\r
-/* LN MQTT - 停止服务:AT^LN_MQTT_STOP_SERVICE */\r
-static uint32_t ln_mqtt_stop_service_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)\r
-{\r
- (void)para;\r
- (void)paraLen;\r
- (void)strCommonCmd;\r
-\r
- printf("[LN_MQTT_AT] Stopping MQTT service...\n");\r
- ln_mqtt_api_stop_service();\r
- printf("+LN_MQTT_STOP_SERVICE: OK\n");\r
- return ERRCODE_SUCC;\r
-}\r
-\r
-\r
-/* OTA-发送设备信息到服务器:AT^LN_OTA_SEND_DEVICE_INFO */\r
-static uint32_t ln_ota_send_device_info_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)\r
-{\r
- (void)para;\r
- (void)paraLen;\r
- (void)strCommonCmd;\r
- \r
- printf("[LN][OTA_SEND_DEVICE_INFO]\n");\r
- \r
- // 直接调用封装函数,使用默认URL(NULL表示使用默认URL)\r
- int ret = ln_ota_send_device_info_json(NULL, NULL);\r
- if (ret == 0) {\r
- printf("+LN_OTA_SEND_DEVICE_INFO: OK\n");\r
- return ERRCODE_SUCC;\r
- } else {\r
- printf("+LN_OTA_SEND_DEVICE_INFO: FAIL\n");\r
- return ERRCODE_FAIL;\r
- }\r
-}\r
-\r
-/* 模组 cat1↔UDP 桥全路径自测:AT^LN_TCP_CAT1_BRIDGE_TEST */\r
-static uint32_t ln_tcp_cat1_bridge_test_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)\r
-{\r
- (void)para;\r
- (void)paraLen;\r
- (void)strCommonCmd;\r
-\r
- if (ln_tcp_at_test_cat1_full_bridge() == 0) {\r
- return ERRCODE_SUCC;\r
- }\r
- return ERRCODE_FAIL;\r
-}\r
-\r
-/* 发送测试帧:AT^LN_TCP_SEND_TEST_FRAMES */\r
-static uint32_t ln_tcp_send_test_frames_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)\r
-{\r
- (void)para;\r
- (void)paraLen;\r
- (void)strCommonCmd;\r
- if (ln_tcp_send_test_frames() == 0) {\r
- return ERRCODE_SUCC;\r
- }\r
- return ERRCODE_FAIL;\r
-}\r
-\r
-static const at_cmd_table_t g_ln_mqtt_at_cmds[] = {\r
- {(char *)"AT^LN_MQTT_LISTEN", ln_mqtt_listen_at, (char *)"LN MQTT listen start/stop: AT^LN_MQTT_LISTEN=1/0"},\r
- {(char *)"AT^LN_MQTT_HELLO", ln_mqtt_hello_at, (char *)"LN MQTT send hello: AT^LN_MQTT_HELLO"},\r
- {(char *)"AT^LN_MQTT_START_SERVICE", ln_mqtt_start_service_at, (char *)"LN MQTT start service: AT^LN_MQTT_START_SERVICE"},\r
- {(char *)"AT^LN_MQTT_STOP_SERVICE", ln_mqtt_stop_service_at, (char *)"LN MQTT stop service: AT^LN_MQTT_STOP_SERVICE"},\r
- {(char *)"AT^LN_OTA_SEND_DEVICE_INFO", ln_ota_send_device_info_at, (char *)"ln_ota_send_device_info_at: AT^ln_ota_send_device_info_json"},\r
- {(char *)"AT^LN_TCP_CAT1_BRIDGE_TEST", ln_tcp_cat1_bridge_test_at,\r
- (char *)"cat1桥+TCP+加密发送两帧+recv探测: AT^LN_TCP_CAT1_BRIDGE_TEST"},\r
- {(char *)"AT^LN_TCP_SEND_TEST_FRAMES", ln_tcp_send_test_frames_at,\r
- (char *)"TCP发送测试帧: AT^LN_TCP_SEND_TEST_FRAMES"},\r
-};\r
-\r
-at_cmd_table_t *get_ln_mqtt_at_cmd_table(uint32_t *cmd_count)\r
-{\r
- if (cmd_count) {\r
- *cmd_count = ARRAY_COUNT(g_ln_mqtt_at_cmds);\r
- }\r
- return (at_cmd_table_t *)g_ln_mqtt_at_cmds;\r
-}\r
-\r
+/*
+ * LN MQTT AT test commands
+ * - Follow the style in `leiniao_api_at.c` / `uapi_mqtt_at.c`
+ * - Provide simple AT commands to drive LN MQTT listen start/stop and hello send
+ */
+
+#include "at_cmd_api.h"
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "errcode.h"
+#include "ln_mqtt_api.h"
+#include "ln_mqtt_api_at.h"
+#include "cmsis_os2.h"
+
+#define ARRAY_COUNT(array) (sizeof(array) / sizeof((array)[0]))
+#define LN_MQTT_AT_MAX_ARGC 8
+#define LN_MQTT_AT_MAX_ARGV_LEN 256
+
+/* 自动停止定时器(10秒后停止录音) */
+static osTimerId_t g_listen_auto_stop_timer = NULL;
+
+/**
+ * @brief 解析AT命令参数
+ * 兼容 "AT^XXX=arg1,arg2" 或 "AT^XXX arg1 arg2"
+ */
+static int ln_mqtt_at_parse_params(uint8_t *para, uint32_t paraLen,
+ uint8_t argv[LN_MQTT_AT_MAX_ARGC][LN_MQTT_AT_MAX_ARGV_LEN],
+ uint32_t *argc)
+{
+ uint32_t pos = 0;
+ *argc = 0;
+
+ for (uint32_t i = 0; i < paraLen; i++) {
+ if ((para[i] == ' ' || para[i] == '\n' || para[i] == ',' || para[i] == '=') && pos != 0) {
+ argv[*argc][pos] = '\0';
+ *argc += 1;
+ pos = 0;
+ if (*argc >= LN_MQTT_AT_MAX_ARGC) {
+ return -1;
+ }
+ } else {
+ if (para[i] == ' ' || para[i] == '\n' || para[i] == ',' || para[i] == '=') {
+ continue;
+ }
+ argv[*argc][pos] = para[i];
+ pos++;
+ if (pos >= LN_MQTT_AT_MAX_ARGV_LEN) {
+ return -1;
+ }
+ }
+ }
+ if (pos != 0) {
+ argv[*argc][pos] = '\0';
+ *argc += 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief 自动停止录音的定时器回调函数
+ */
+static void ln_mqtt_listen_auto_stop_callback(void *arg)
+{
+ (void)arg;
+ printf("[LN_MQTT_AT] Auto stop timer expired, stopping listen...\n");
+ (void)ln_mqtt_api_send_listen_state(false);
+}
+
+/* LN MQTT - 发送 listen 控制并开始/停止录音:AT^LN_MQTT_LISTEN=1/0 */
+static uint32_t ln_mqtt_listen_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ (void)strCommonCmd;
+
+ uint8_t argv[LN_MQTT_AT_MAX_ARGC][LN_MQTT_AT_MAX_ARGV_LEN] = {0};
+ uint32_t argc = 0;
+ if (ln_mqtt_at_parse_params(para, paraLen, argv, &argc) != 0 || argc < 1) {
+ printf("Usage: AT^LN_MQTT_LISTEN=1/0\n");
+ return ERRCODE_FAIL;
+ }
+
+ int enable = atoi((char *)argv[0]);
+ if (enable != 0 && enable != 1) {
+ printf("Usage: AT^LN_MQTT_LISTEN=1/0\n");
+ return ERRCODE_FAIL;
+ }
+
+ // 如果之前有定时器在运行,先停止
+ if (g_listen_auto_stop_timer != NULL) {
+ if (osTimerIsRunning(g_listen_auto_stop_timer) == 1) {
+ osTimerStop(g_listen_auto_stop_timer);
+ }
+ }
+
+ int ret = ln_mqtt_api_send_listen_state(enable ? true : false);
+ if (ret == 0) {
+ printf("+LN_MQTT_LISTEN: OK\n");
+
+ // 如果 enable == 1,启动10秒后自动停止的定时器
+ if (enable == 1) {
+ // 如果定时器未创建,先创建
+ if (g_listen_auto_stop_timer == NULL) {
+ g_listen_auto_stop_timer = osTimerNew((osTimerFunc_t)ln_mqtt_listen_auto_stop_callback,
+ osTimerOnce, NULL, NULL);
+ if (g_listen_auto_stop_timer == NULL) {
+ printf("[LN_MQTT_AT] WARNING: Failed to create auto stop timer\n");
+ }
+ }
+
+ // 启动定时器(10秒 = 10000毫秒)
+ if (g_listen_auto_stop_timer != NULL) {
+ osStatus_t timer_ret = osTimerStart(g_listen_auto_stop_timer, 10000);
+ if (timer_ret != osOK) {
+ printf("[LN_MQTT_AT] WARNING: Failed to start auto stop timer: %d\n", timer_ret);
+ } else {
+ printf("[LN_MQTT_AT] Auto stop timer started (10 seconds)\n");
+ }
+ }
+ }
+
+ return ERRCODE_SUCC;
+ }
+ printf("+LN_MQTT_LISTEN: FAIL\n");
+ return ERRCODE_FAIL;
+}
+
+/* LN MQTT - 发送 hello:AT^LN_MQTT_HELLO */
+static uint32_t ln_mqtt_hello_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ (void)para;
+ (void)paraLen;
+ (void)strCommonCmd;
+
+ int ret = ln_mqtt_api_send_hello();
+ if (ret == 0) {
+ printf("+LN_MQTT_HELLO: OK\n");
+ return ERRCODE_SUCC;
+ }
+ printf("+LN_MQTT_HELLO: FAIL\n");
+ return ERRCODE_FAIL;
+}
+
+/* LN MQTT - 启动服务:AT^LN_MQTT_START_SERVICE */
+static uint32_t ln_mqtt_start_service_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ (void)para;
+ (void)paraLen;
+ (void)strCommonCmd;
+
+ printf("[LN_MQTT_AT] Starting MQTT service...\n");
+ int ret = ln_mqtt_api_start_service(NULL);
+ if (ret == 0) {
+ printf("+LN_MQTT_START_SERVICE: OK\n");
+ return ERRCODE_SUCC;
+ }
+ printf("+LN_MQTT_START_SERVICE: FAIL\n");
+ return ERRCODE_FAIL;
+}
+
+/* LN MQTT - 停止服务:AT^LN_MQTT_STOP_SERVICE */
+static uint32_t ln_mqtt_stop_service_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ (void)para;
+ (void)paraLen;
+ (void)strCommonCmd;
+
+ printf("[LN_MQTT_AT] Stopping MQTT service...\n");
+ ln_mqtt_api_stop_service();
+ printf("+LN_MQTT_STOP_SERVICE: OK\n");
+ return ERRCODE_SUCC;
+}
+
+
+/* OTA-发送设备信息到服务器:AT^LN_OTA_SEND_DEVICE_INFO */
+static uint32_t ln_ota_send_device_info_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ (void)para;
+ (void)paraLen;
+ (void)strCommonCmd;
+
+ printf("[LN][OTA_SEND_DEVICE_INFO]\n");
+
+ // 直接调用封装函数,使用默认URL(NULL表示使用默认URL)
+ int ret = ln_ota_send_device_info_json(NULL, NULL);
+ if (ret == 0) {
+ printf("+LN_OTA_SEND_DEVICE_INFO: OK\n");
+ return ERRCODE_SUCC;
+ } else {
+ printf("+LN_OTA_SEND_DEVICE_INFO: FAIL\n");
+ return ERRCODE_FAIL;
+ }
+}
+
+/* 模组 cat1↔UDP 桥全路径自测:AT^LN_TCP_CAT1_BRIDGE_TEST */
+static uint32_t ln_tcp_cat1_bridge_test_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ (void)para;
+ (void)paraLen;
+ (void)strCommonCmd;
+
+ if (ln_tcp_at_test_cat1_full_bridge() == 0) {
+ return ERRCODE_SUCC;
+ }
+ return ERRCODE_FAIL;
+}
+
+/* 发送测试帧:AT^LN_TCP_SEND_TEST_FRAMES */
+static uint32_t ln_tcp_send_test_frames_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ (void)para;
+ (void)paraLen;
+ (void)strCommonCmd;
+ if (ln_tcp_send_test_frames() == 0) {
+ return ERRCODE_SUCC;
+ }
+ return ERRCODE_FAIL;
+}
+
+static const at_cmd_table_t g_ln_mqtt_at_cmds[] = {
+ {(char *)"AT^LN_MQTT_LISTEN", ln_mqtt_listen_at, (char *)"LN MQTT listen start/stop: AT^LN_MQTT_LISTEN=1/0"},
+ {(char *)"AT^LN_MQTT_HELLO", ln_mqtt_hello_at, (char *)"LN MQTT send hello: AT^LN_MQTT_HELLO"},
+ {(char *)"AT^LN_MQTT_START_SERVICE", ln_mqtt_start_service_at, (char *)"LN MQTT start service: AT^LN_MQTT_START_SERVICE"},
+ {(char *)"AT^LN_MQTT_STOP_SERVICE", ln_mqtt_stop_service_at, (char *)"LN MQTT stop service: AT^LN_MQTT_STOP_SERVICE"},
+ {(char *)"AT^LN_OTA_SEND_DEVICE_INFO", ln_ota_send_device_info_at, (char *)"ln_ota_send_device_info_at: AT^ln_ota_send_device_info_json"},
+ {(char *)"AT^LN_TCP_CAT1_BRIDGE_TEST", ln_tcp_cat1_bridge_test_at,
+ (char *)"cat1桥+TCP+加密发送两帧+recv探测: AT^LN_TCP_CAT1_BRIDGE_TEST"},
+ {(char *)"AT^LN_TCP_SEND_TEST_FRAMES", ln_tcp_send_test_frames_at,
+ (char *)"TCP发送测试帧: AT^LN_TCP_SEND_TEST_FRAMES"},
+};
+
+at_cmd_table_t *get_ln_mqtt_at_cmd_table(uint32_t *cmd_count)
+{
+ if (cmd_count) {
+ *cmd_count = ARRAY_COUNT(g_ln_mqtt_at_cmds);
+ }
+ return (at_cmd_table_t *)g_ln_mqtt_at_cmds;
+}
+
}
+static uint32_t ln_ota_get_task_cat1_30_at(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ LN_UNUSED(para);
+ LN_UNUSED(paraLen);
+ LN_UNUSED(strCommonCmd);
+ printf("[LN][OTA_GET_TASK_NEW_CAT1]\n");
+ star_http_ota_updata("http://snicker.com.cn:8089/LN_OTA_30_test/dfota_1.bin","http://snicker.com.cn:8089/LN_OTA_30_test/dfota_2.bin",29);
+ return ERRCODE_SUCC;
+}
+
/*
* 职责单一:仅触发"根据最近一次getTask结果下载并校验MD5"的动作
* 不负责:查询任务/升级/重启/重取token
//心跳间隔设置
{(char *)"AT^LN_WS_HEARTBEAT_INTERVAL", ln_ws_get_heartbeat_interval_sec_at, (char *)"获取心跳间隔: AT^LN_WS_HEARTBEAT_INTERVAL"},
{(char *)"AT^LN_WS_HEARTBEAT_INTERVAL_SET", ln_ws_set_heartbeat_interval_sec_at, (char *)"设置心跳间隔: AT^LN_WS_HEARTBEAT_INTERVAL_SET=60"},
+
+ {(char *)"AT^LN_OTA_GET_TASK_CAT1_30", ln_ota_get_task_cat1_30_at, (char *)"获取CAT1 30模组升级任务: AT^LN_OTA_GET_TASK_CAT1_30"},
};
/* ============================== 公共宏与URL路径 ============================== */
#define LN_VOICE_CHAT_ENABLED 0 //声纹锁开启宏
-#define LN_ENV_PRODUCTION 1 //正式环境
+#define LN_ENV_PRODUCTION 0 //正式环境
/* 接口基础配置 - 如需切换环境/密钥,在此调整 */
#if LN_ENV_PRODUCTION
#define LN_BASE_URL "https://ambybox-o.api.leiniao.com/ambybox-device-api" //正式环境服务器地址
do_ln_http_server_send_data(LN_HTTP_SERVICE_CMD_OTA_GET_TASK, NULL, 0);
} else {
printf("[OTA] cat1模组升级url不为空,触发CAT1升级\n");
+
push_ota_status(OTA_UI_STATUS_CAT1_START);
}
#else
#endif
#include "Ln_Bluetooth_apiC.h"
+
// 功能开关宏定义
#define ENABLE_BINARY_DATA_INTERRUPT_CHECK 1 // 启用二进制数据间隔检查
-#define ENABLE_AUDIO_FILE_WRITE 0 // 启用音频文件写入功能(根据chat_id生成文件)
+#define ENABLE_AUDIO_FILE_WRITE 1 // 启用音频文件写入功能(根据chat_id生成文件)
// 主线程循环间隔时长(毫秒)
#define LN_WS_MAIN_THREAD_INTERVAL_MS 500
} ln_ws_log_level_t;
// 当前日志等级(可通过配置修改)
-static ln_ws_log_level_t g_log_level = LN_WS_LOG_WARN;
+static ln_ws_log_level_t g_log_level = LN_WS_LOG_INFO;
void ln_ws_set_log_level(uint8_t level)
{
LN_WS_ERROR("Failed to allocate memory for base64 encoding\n");
return -1;
}
+ memset(audio_base64, 0, base64_size);
+ printf("mp3 data >>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+ for (size_t i = 0; i < 32; i++) {
+ printf("%02X ", audio_data[i]);
+ }
+ printf("\n");
+ printf("data >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
size_t output_len = 0;
int ret_encode = mbedtls_base64_encode((unsigned char*)audio_base64, base64_size - 1, &output_len,
if(ret==0 && len>0)
{
ret = vad_server_send_audio(format, pcm_data, len, false);
+
if (ret != ERRCODE_SUCC) {
/* 静默失败,避免过多日志 */
} else {
// 设置初始化标志位
g_audio_initialized = true;
+ errcode_t ret = uapi_pm_request_mode(PM_ID_VIDEO, PM_MODE_PERFORMACE);
+ printf("uapi_pm_request_mode ret : %X\n",ret);
+
uapi_ws_wake_keep(1);
LN_WS_INFO("Audio initialization completed successfully\n");
StopAIVoice();
+ int ret = uapi_pm_request_mode(PM_ID_SPI, PM_MODE_NORMAL);
+ printf("uapi_pm_request_mode ret : %X\n",ret);
+
#ifdef SUPPORT_CAT1_SERVICE
cat1_api_keep_wakeup(0);
cat1_api_wakeup_cat1(0);
if (count >= BAT_FILE_COUNT)
{
- BATTERY_DATA_T data[BAT_FILE_COUNT] = {0};
+ BATTERY_DATA_T *data=(BATTERY_DATA_T *)malloc(BAT_FILE_COUNT*sizeof(BATTERY_DATA_T));
fseek(fp,(count - BAT_FILE_COUNT + 1) * sizeof(BATTERY_DATA_T), SEEK_SET);
fread(data, sizeof(BATTERY_DATA_T), BAT_FILE_COUNT - 1, fp);
fseek(fp, 0, SEEK_SET);
fwrite(data, sizeof(BATTERY_DATA_T), BAT_FILE_COUNT, fp);
+
+ free(data);
+
}
else
{
${CMAKE_CURRENT_SOURCE_DIR}/bleService.c
${CMAKE_CURRENT_SOURCE_DIR}/bleEvent.c
${CMAKE_CURRENT_SOURCE_DIR}/bleANCS.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/bleICCE.c
)
else()
set(SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/bleService.c
# ${CMAKE_CURRENT_SOURCE_DIR}/bleEvent.c
${CMAKE_CURRENT_SOURCE_DIR}/bleANCS.c
-
+ ${CMAKE_CURRENT_SOURCE_DIR}/bleICCE.c
)
-
endif()
set(COMPONENT_PUBLIC_CCFLAGS
} ble_ancs_client_at_cmd_id_t;
-static uint8_t g_client_id=0;
+uint8_t g_client_id=0;
/* 命令处理函数接口 */
filtration_data filtration_data_T[filtration_data_count]={0};
errcode_t ret = gattc_register_client(&uuid, &client_id);
g_client_id=client_id;
+
+ ret = gatts_set_mtu_size(1,247);
+ if(ret!=ERRCODE_SUCC)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"gatts_set_mtu_size fail ret %d\r\n",ret);
+ }
printf("[GATTClient]gattc_register ret(errcode_t): %x client_id:%u\n", ret, client_id);
}
--- /dev/null
+/*
+ * Copyright (c) @CompanyNameMagicTag 2024. All rights reserved.
+ * Description: ICCE 车辆控制协议实现,参考 ble_ancs_client.c / bleANCS.c.
+ * 使用 protocol 层 ble_icce_client,本文件负责回调注册与上层封装。
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include "mbedtls/aes.h"
+#include "mbedtls/sha256.h"
+#include "errcode.h"
+#include "bts_gatt_stru.h"
+#include "ble_icce_client.h"
+#include "bleICCE.h"
+#include "bleService.h"
+#include "wearable_log.h"
+
+#ifdef WEARABLE_LOG
+#include "wearable_log.h"
+#else
+#define ICCE_LOG(fmt, ...) printf("[ICCE]" fmt "\r\n", ##__VA_ARGS__)
+#endif
+
+#define ICCE_NO_DEBUG_AES_KEY
+
+/* 帧长/发送缓冲:必须在首段组帧与 TLV 组装函数之前定义 */
+#define ICCE_FRAME_MIN_LEN 12
+#define ICCE_MAX_REASM_CONN 4
+#define ICCE_MAX_REASM_BODY 1100
+#define ICCE_MAX_TX_FRAME_LEN 320
+
+/* icce_changan_build_auth_response_payload:密文 / 77 封装 / R-APDU 缓冲用堆,避免大栈数组 */
+#define ICCE_AUTH_RESP_HEAP_CIPHER_CAP 64u
+#define ICCE_AUTH_RESP_HEAP_BUF77_CAP 300u
+#define ICCE_AUTH_RESP_HEAP_RAPDU_CAP 320u
+
+static uint16_t icce_crc16_ccitt(const uint8_t *buf, uint16_t len);
+static uint16_t icce_put_be16(uint8_t *dst, uint16_t v);
+static uint16_t icce_tlv_build(uint8_t *dst, uint16_t dst_cap, uint16_t tag_number,
+ const uint8_t *value, uint16_t value_len);
+
+/*
+ * BT_SERVICE_TASK 栈很小:以下工作区勿放栈上,避免 notify→parse→handle→send 同路径爆栈。
+ * 非重入:本文件 ICCE 回调链单任务顺序执行;勿在持有这些缓冲时重入 icce_handle_complete_frame / ble_icce_send_frame。
+ */
+static icce_body_event_t s_icce_handle_complete_ev;
+static uint8_t s_ble_icce_tx_frame[ICCE_MAX_TX_FRAME_LEN];
+static uint8_t s_ble_icce_tx_enc_plain[ICCE_MAX_TX_FRAME_LEN];
+static uint8_t s_ble_icce_tx_enc_m2[ICCE_MAX_TX_FRAME_LEN];
+
+/* RKE03 发控车指令时自增计数器(与表 01 04 00000001 示例一致,断链后 ble_icce_clear_by_conn 复位) */
+static uint32_t g_icce_rke03_tx_counter = 1u;
+
+/*
+ * 联调调试默认 DKey(16 字节),对应 hex:
+ * 70326e21ead75c76d46742de644a2fc5
+ * 发布构建请在组件编译选项中加 -DICCE_NO_DEBUG_AES_KEY 关闭默认密钥,须通过 ble_icce_changan_set_auth_card_identity(..., opt_dkey) 注入主密钥 DKey。
+ */
+#if !defined(ICCE_NO_DEBUG_AES_KEY)
+/* 协议 DKey(车钥匙业务主密钥);会话密钥派生使用 BLE 缓存的 9F0C ReaderKeyParam(g_icce_auth_cache_key_param),不读独立全局 CardIV */
+// 725ec19ea99f640f07d78311d9e57827
+static uint8_t g_icce_dkey[16] = {
+ 0x72, 0x5e, 0xc1, 0x9e, 0xa9, 0x9f, 0x64, 0x0f,
+ 0x07, 0xd7, 0x83, 0x11, 0xd9, 0xe5, 0x78, 0x27,
+};
+static uint8_t g_icce_dkey_valid = 1;
+#else
+static uint8_t g_icce_dkey[16];
+static uint8_t g_icce_dkey_valid = 0;
+#endif
+static icce_body_handler_t g_icce_body_handler = NULL;
+
+/*
+ * 长安数字钥匙:Message ID=0x01 / Command ID=0x01「认证数据」。
+ * 「取处理数据」单独识别:Tag01(APDU) 命令数据内同时含 9F1E、9F37、9F0C 时视为取数据指令,仅此时组「取数据回应」。
+ * 会话密钥(SessionKey)计算(规范表):
+ * SessionKey = AES-128-CBC 密文最后一格(Last ENC block)
+ * = AES-128-CBC(DKey, CardIV, ISO9797 M2(ReaderRnd || CardRnd || ReaderKeyParameter))
+ * DKey:钥匙侧主密钥(局部 dkey / 全局 g_icce_dkey)
+ * CardIV:与 9F0C ReaderKeyParameter(16B)一致,作 CBC 初始 IV
+ * 明文块:ReaderRnd(9F37,8B) || CardRnd(9F3E,8B) || ReaderKeyParameter(9F0C,16B),共 32 字节,再 ISO9797-1 Method2 填充
+ * 派生出的 SessionKey 仅写入 g_icce_session_key;主密钥 DKey 仅由 ble_icce_changan_set_auth_card_identity 可选参数或联调默认区注入。
+ * 整段 body 加解密须用 SessionKey + SessionIV(ReaderRnd||CardRnd),不得用 DKey 或单独 CardIV 充当 body 的 CBC IV。
+ *
+ * 计算加密数据(Tag 0x73 等复合密文域):
+ * 加密数据 = AES128_CBC(SessionKey, SessionIV, ISO9797_M2(明文))
+ * SessionIV(16B)= ReaderRnd || CardRnd
+ * 取处理数据回应 73:先 TLV(9F36)||TLV(9F37),再 ISO9797_M2,再 AES(与 icce_auth_encrypt_73_inner 一致)
+ * 认证指令(车→机)73:与取数据回应同序 — ReaderRnd 须先 TLV(9F37) 封装,与 9F36 等拼接后再 M2、再 AES;
+ * 解密后从内层取 9F36(CardATC)、9F37(ReaderRnd);9F3E(CardRnd) 可在内层或 77 外明文。IV=ReaderRnd||CardRnd。
+ *
+ * 「认证指令 / 认证响应」(与取处理数据区分):
+ * 车→机:Tag01 内 77 可为「响应复合数据域」明文 TLV,或整段 Value 与 0x73 同算法(AES128_CBC+M2)的复合密文,须先解密再扫 9F36/9F3E/9F0A;
+ * 亦可再包一层 0x73;不含 9F1E+9F37+9F0C 取数据组合。
+ * 机→车认证响应:00(Status=成功 0x00)+01(R-APDU);先 TLV(9F37,ReaderRnd)→SHA256→M2→AES,密文作为 77 的 Value(密文外不再套 9F37 TLV);不使用 73、9F31、9F0A。
+ *
+ * 学习成功后首次刷卡 CardATC 为 0(计数器从 0 起)。
+ */
+typedef struct {
+ uint8_t has_reader_id;
+ uint8_t has_reader_rnd;
+ uint8_t has_reader_key_param;
+ uint8_t has_card_atc;
+ uint8_t has_card_rnd;
+ uint8_t has_apdu;
+ uint8_t reader_id[ICCE_TAG_LEN_READER_ID];
+ uint8_t reader_rnd[ICCE_TAG_LEN_READER_RND]; /* 车侧 9F37,仅 icce_auth_scan_payload 从 BLE 载荷解析 */
+ uint8_t reader_key_param[ICCE_TAG_LEN_READER_KEY_PARAM];
+ uint8_t card_atc[ICCE_TAG_LEN_CARD_ATC];
+ uint8_t card_rnd[ICCE_TAG_LEN_CARD_RND]; /* 若车端 TLV 含 9F3E 时填入;会话密钥只用本端 icce_auth_generate_local_card_rnd */
+ const uint8_t *apdu;
+ uint16_t apdu_len;
+ /* 车→机认证指令:77 内 Tag73 复合密文(与取数据回应 73 同算法,仅内层 TLV 为 9F36+9F3E) */
+ uint8_t has_auth_cmd_cipher73;
+ const uint8_t *auth_cmd_cipher73;
+ uint16_t auth_cmd_cipher73_len;
+} icce_auth_tlv_scan_t;
+
+/*
+ * 钥匙侧演示数据:正式环境应从 SE/NV 注入,或通过 ble_icce_changan_set_auth_card_identity(车端 BLE + 车辆 id 以落盘一车一钥)下发。
+ * 联调抓包(BLE_CARKEY 取处理数据应答 220B)中的 5A/9F3E,便于与参考线帧对照测试。
+ * 与默认 DKey 配对的 card info:前 16B 为 CardID;整段 123B 作 9F05 Card Info1(规范 CardInfo 无独立 CardSEID;BLE TLV 5A 用 8B 见 HTTP 注入路径说明)。
+ */
+#if !defined(ICCE_NO_DEBUG_AES_KEY)
+static uint8_t g_icce_auth_card_seid[ICCE_TAG_LEN_CARD_SEID] = {
+ 0xF8, 0x6F, 0xDE, 0x84, 0xDE, 0x30, 0x00, 0x00,
+};
+/* 与抓包 9F3E 一致;icce_auth_ensure_session_card_rnd 在未缓存时装入 g_icce_auth_cache_card_rnd */
+static const uint8_t g_icce_auth_test_card_rnd[ICCE_TAG_LEN_CARD_RND] = {
+ 0x36, 0x96, 0x94, 0x05, 0x47, 0xDD, 0x0F, 0x25,
+};
+static uint8_t g_icce_auth_card_id[ICCE_TAG_LEN_CARD_ID] = {
+ 0x00, 0x69, 0xE9, 0x86, 0xDA, 0xC6, 0x8F, 0x78, 0x0A, 0x1D, 0xF8, 0x24, 0xFD, 0x4E, 0x78, 0xAB,
+};
+/* 9F05 Card Info1:整段 123B 与用户给定 hex 一致 */
+static const uint8_t g_icce_auth_card_info1[ICCE_CARD_INFO1_TEST_LEN] = {
+ 0x00, 0x69, 0xE9, 0x86, 0xDA, 0xC6, 0x8F, 0x78, 0x0A, 0x1D, 0xF8, 0x24, 0xFD, 0x4E, 0x78, 0xAB,
+ 0x00, 0x00, 0x00, 0xAF, 0x34, 0x42, 0x88, 0x3D, 0x07, 0x33, 0x4E, 0x5E, 0x01, 0xC3, 0xE4, 0x61,
+ 0x01, 0xC3, 0xEA, 0x01, 0x4C, 0x53, 0x35, 0x41, 0x32, 0x44, 0x4B, 0x45, 0x34, 0x53, 0x41, 0x32,
+ 0x31, 0x33, 0x30, 0x32, 0x35, 0x24, 0x39, 0x33, 0x36, 0x65, 0x61, 0x37, 0x35, 0x64, 0x2D, 0x39,
+ 0x61, 0x62, 0x33, 0x2D, 0x34, 0x38, 0x61, 0x63, 0x2D, 0x61, 0x36, 0x38, 0x34, 0x2D, 0x36, 0x37,
+ 0x66, 0x61, 0x39, 0x37, 0x62, 0x33, 0x31, 0x64, 0x66, 0x32, 0x02, 0xEA, 0x9D, 0x0D, 0x72, 0xCF,
+ 0x91, 0x33, 0x0C, 0x70, 0x27, 0xDD, 0x6F, 0xAC, 0xA1, 0x68, 0x71, 0x0D, 0x81, 0x7E, 0x9D, 0x41,
+ 0x39, 0xDE, 0x76, 0x31, 0xC1, 0xB5, 0xE1, 0x63, 0x9E, 0xCF, 0xD8
+};
+#else
+static uint8_t g_icce_auth_card_seid[ICCE_TAG_LEN_CARD_SEID];
+static uint8_t g_icce_auth_card_id[ICCE_TAG_LEN_CARD_ID];
+static uint8_t g_icce_auth_card_info1[ICCE_CARD_INFO1_TEST_LEN];
+#endif
+static uint32_t g_icce_auth_card_atc_counter = 0; /* 首次刷卡为 0,与 CardAuthRes 明文一致 */
+static uint32_t g_icce_auth_card_rnd_salt = 0x3C96A1B5u;
+/* 9F0C(CardIV) / 9F37(ReaderRnd) 分帧到达时分别缓存;二者均有效后再派生 SessionKey */
+static uint8_t g_icce_auth_cache_key_param[ICCE_TAG_LEN_READER_KEY_PARAM];
+static uint8_t g_icce_auth_cache_key_param_valid;
+static uint8_t g_icce_auth_cache_reader_rnd[ICCE_TAG_LEN_READER_RND];
+static uint8_t g_icce_auth_cache_reader_rnd_valid;
+/* 本会话钥匙侧 9F3E CardRnd:分帧/本地生成后缓存 */
+static uint8_t g_icce_auth_cache_card_rnd[ICCE_TAG_LEN_CARD_RND];
+static uint8_t g_icce_auth_cache_card_rnd_valid;
+/* 派生得到的 SessionKey,用于 Tag73/77、整包 body 等(与主密钥 g_icce_dkey 分离) */
+static uint8_t g_icce_session_key[16];
+static uint8_t g_icce_session_key_valid;
+/* SessionIV(16B)= ReaderRnd||CardRnd,由 icce_auth_session_iv_fixed_sync() 写入,加密时拷入工作 IV */
+static uint8_t g_icce_session_iv_fixed[16];
+static uint8_t g_icce_session_iv_fixed_valid;
+/* 已对车端「同一取处理数据请求」应答成功时的 9F37+9F0C 指纹,防止重复 Notify 导致多次回包 */
+static uint8_t g_icce_auth_last_ack_reader_rnd[ICCE_TAG_LEN_READER_RND];
+static uint8_t g_icce_auth_last_ack_reader_kp[ICCE_TAG_LEN_READER_KEY_PARAM];
+static uint8_t g_icce_auth_last_ack_valid;
+/* 默认策略:取处理数据成功下发后,下一条 0x01/0x01 同步请求视为认证指令,不做 9F36/9F3E 等 TLV 判定,直接组认证响应 */
+static uint8_t g_icce_auth_expect_post_getdata_auth;
+
+static void icce_auth_tlv_scan_reset(icce_auth_tlv_scan_t *s)
+{
+ if (s == NULL) {
+ return;
+ }
+ memset(s, 0, sizeof(*s));
+}
+
+#define ICCE_HEX_DUMP_LINE 16u
+
+void icce_hex_dump_log(const char *label, const uint8_t *data, uint16_t len)
+{
+ static const char hexd[] = "0123456789ABCDEF";
+ const char *lb = (label != NULL) ? label : "?";
+ uint16_t i = 0;
+ if (data == NULL || len == 0) {
+ ICCE_LOG("[ICCE HEX] %s (empty)", lb);
+ return;
+ }
+ ICCE_LOG("[ICCE HEX] ---- %s total %u bytes ----", lb, (unsigned)len);
+ while (i < len) {
+ char line[80];
+ uint16_t n = (uint16_t)(len - i);
+ uint16_t j;
+ uint16_t p = 0;
+ if (n > ICCE_HEX_DUMP_LINE) {
+ n = ICCE_HEX_DUMP_LINE;
+ }
+ for (j = 0; j < n && p + 4 < sizeof(line); j++) {
+ uint8_t b = data[i + j];
+ line[p++] = hexd[b >> 4];
+ line[p++] = hexd[b & 0x0F];
+ if (j + 1 < n) {
+ line[p++] = ' ';
+ }
+ }
+ line[p] = '\0';
+ ICCE_LOG("[ICCE HEX] %s +%04X: %s", lb, (unsigned)i, line);
+ i = (uint16_t)(i + n);
+ }
+}
+
+/* 返回本 TLV 总占用字节(Tag+Length+Value),失败返回 0 */
+static uint16_t icce_tlv_unit_bytes(const uint8_t *buf, uint16_t buf_len, icce_tlv_header_t *out)
+{
+ if (buf == NULL || out == NULL) {
+ return 0;
+ }
+ int h = icce_tlv_parse(buf, buf_len, out);
+ if (h < 0) {
+ return 0;
+ }
+ return (uint16_t)((uint16_t)h + out->value_len);
+}
+
+/*
+ * 按「首个 TLV 的 Tag 第一字节」对照协议表做大类识别(同表:9x=认证域、6x=后台/RKE、7x=响应/77、8x=车端业务、Fx=安全通道等)。
+ */
+static const char *icce_tlv_classify_first_tag_byte(uint8_t first_byte)
+{
+ switch (first_byte) {
+ case ICCE_TAG_STATUS:
+ return "00-Status";
+ case ICCE_TAG_MSG_CMD_ID_1:
+ return "01-APDU";
+ case ICCE_TAG_MSG_CMD_ID_2:
+ return "02-Heartbeat";
+ case ICCE_TAG_MSG_CMD_ID_3:
+ return "03-VehReqApp";
+ case ICCE_TAG_CARD_SEID:
+ return "5A-CardSEID";
+ default:
+ break;
+ }
+ switch (first_byte >> 4) {
+ case 0x4:
+ return "4x-AID/4F";
+ case 0x5:
+ return "5x-Card/SEID";
+ case 0x6:
+ return "6x-backend/RKE";
+ case 0x7:
+ return "7x-resp/71/73/77";
+ case 0x8:
+ return "8x-vehicle_APP_resp";
+ case 0x9:
+ return "9x-9Fxx_auth";
+ case 0xF:
+ return "Fx-sec_channel";
+ default:
+ return "other";
+ }
+}
+
+/* 顶层 TLV 个数(整体扫一遍,不打印 hex) */
+static uint16_t icce_tlv_count_top_level(const uint8_t *payload, uint16_t payload_len)
+{
+ uint16_t pos = 0;
+ uint16_t n = 0;
+ while (pos < payload_len) {
+ icce_tlv_header_t tlv = {0};
+ uint16_t unit = icce_tlv_unit_bytes(payload + pos, (uint16_t)(payload_len - pos), &tlv);
+ if (unit == 0) {
+ break;
+ }
+ n++;
+ pos = (uint16_t)(pos + unit);
+ }
+ return n;
+}
+
+const char *icce_tlv_tag_label(uint16_t tag)
+{
+ switch (tag) {
+ case ICCE_TAG_STATUS:
+ return "00-Status";
+ case ICCE_TAG_MSG_CMD_ID_1:
+ return "01-APDU/RKE";
+ case ICCE_TAG_MSG_CMD_ID_2:
+ return "02-HB";
+ case ICCE_TAG_MSG_CMD_ID_3:
+ return "03-VehReqApp";
+ case ICCE_TAG_CARD_SEID:
+ return "5A-CardSEID";
+ case ICCE_TAG_RESP_TEMPLATE:
+ return "77-RespTpl";
+ case ICCE_TAG_9F0A_READER_AUTH_PARAM:
+ return "9F0A-ReaderAuthParam";
+ case ICCE_TAG_9F0C_READER_KEY_PARAM:
+ return "9F0C-ReaderKey/CardIV";
+ case ICCE_TAG_9F1E_READER_ID:
+ return "9F1E-ReaderID";
+ case ICCE_TAG_9F31_CARD_AUTH_PARAM:
+ return "9F31-CardAuthParam";
+ case ICCE_TAG_9F35_READER_TYPE:
+ return "9F35-ReaderType";
+ case ICCE_TAG_9F36_CARD_ATC:
+ return "9F36-CardATC";
+ case ICCE_TAG_9F37_READER_RND:
+ return "9F37-ReaderRnd";
+ case ICCE_TAG_9F3B_CARD_ID:
+ return "9F3B-CardID";
+ case ICCE_TAG_9F3E_CARD_RND:
+ return "9F3E-CardRnd";
+ case ICCE_TAG_9F05_CARD_INFO1:
+ return "9F05-CardInfo1(车钥匙应用自定义数据)";
+ case ICCE_TAG_ICCE_VAR_CIPHER_TEMPLATE:
+ return "73-CardAuthCipher";
+ case ICCE_TAG_RKE03_RKE_CTRL_ROOT: /* 与 ICCE_TAG_CA_BACKEND_RESP(0x61) 同值,勿写两条 case */
+ return "61-RKE-Req/Backend";
+ case ICCE_TAG_RKE03_ROOT_PARK62:
+ return "62-APP-PARK-Req";
+ case ICCE_TAG_RKE03_ROOT_HB63:
+ return "63-APP-HB-Req";
+ case ICCE_TAG_RKE03_ROOT_C3B64:
+ return "64-APP-C3B-PARK-Req";
+ case ICCE_TAG_CA_APP_PARK_CTRL:
+ return "71-PARK/RKE-FB";
+ case 0x3C:
+ return "3C-Tmpl";
+ default:
+ return "?";
+ }
+}
+
+const char *icce_app_command_kind_str(icce_app_command_kind_t kind)
+{
+ switch (kind) {
+ case ICCE_APP_CMD_UNKNOWN:
+ return "UNKNOWN";
+ case ICCE_APP_CMD_AUTH01_GET_PROCESS_DATA:
+ return "AUTH01_GET_PROCESS_DATA";
+ case ICCE_APP_CMD_AUTH01_VEHICLE_AUTH:
+ return "AUTH01_VEHICLE_AUTH";
+ case ICCE_APP_CMD_AUTH01_UNRESOLVED:
+ return "AUTH01_UNRESOLVED";
+ case ICCE_APP_CMD_RKE_APP_CONTROL:
+ return "RKE_APP_CONTROL";
+ case ICCE_APP_CMD_RKE_APP_HEARTBEAT:
+ return "RKE_APP_HEARTBEAT";
+ case ICCE_APP_CMD_RKE_VEHICLE_REQ_APP:
+ return "RKE_VEHICLE_REQ_APP";
+ case ICCE_APP_CMD_RKE_UNRESOLVED:
+ return "RKE_UNRESOLVED";
+ case ICCE_APP_CMD_CA_VEHICLE_STATUS:
+ return "CA_VEHICLE_STATUS";
+ case ICCE_APP_CMD_CA_RKE_PARK_COUNTER:
+ return "CA_RKE_PARK_COUNTER";
+ case ICCE_APP_CMD_CA_RKE_PARK_SIGNAL:
+ return "CA_RKE_PARK_SIGNAL";
+ case ICCE_APP_CMD_CA_APP_CTRL_FEEDBACK:
+ return "CA_APP_CTRL_FEEDBACK";
+ case ICCE_APP_CMD_CA_NORMAL_DATA:
+ return "CA_NORMAL_DATA";
+ case ICCE_APP_CMD_CA_APA_DATA:
+ return "CA_APA_DATA";
+ case ICCE_APP_CMD_CA_BACKEND_IF_ID:
+ return "CA_BACKEND_IF_ID";
+ case ICCE_APP_CMD_CA_VEHICLE_PARAM:
+ return "CA_VEHICLE_PARAM";
+ case ICCE_APP_CMD_CA_BACKEND_RESP:
+ return "CA_BACKEND_RESP";
+ case ICCE_APP_CMD_CA_BLE_UWB_KEY_STATUS:
+ return "CA_BLE_UWB_KEY_STATUS";
+ case ICCE_APP_CMD_CA_VEHICLE_UPLOAD:
+ return "CA_VEHICLE_UPLOAD";
+ case ICCE_APP_CMD_CA_APP_PARK_CTRL:
+ return "CA_APP_PARK_CTRL";
+ case ICCE_APP_CMD_CA_APP_HEARTBEAT_DATA:
+ return "CA_APP_HEARTBEAT_DATA";
+ case ICCE_APP_CMD_CA_RKE_FEEDBACK_PLAIN:
+ return "CA_RKE_FEEDBACK_PLAIN";
+ case ICCE_APP_CMD_CA_VEHICLE_PARK_RESP:
+ return "CA_VEHICLE_PARK_RESP";
+ case ICCE_APP_CMD_CA_VEHICLE_HB_RESP:
+ return "CA_VEHICLE_HB_RESP";
+ case ICCE_APP_CMD_CA_SEC_CH_VEHICLE:
+ return "CA_SEC_CH_VEHICLE";
+ case ICCE_APP_CMD_CA_SEC_CH_BACKEND:
+ return "CA_SEC_CH_BACKEND";
+ case ICCE_APP_CMD_RKE03_RKE61:
+ return "RKE03_RKE61";
+ case ICCE_APP_CMD_RKE03_PARK62:
+ return "RKE03_PARK62";
+ case ICCE_APP_CMD_RKE03_HB63:
+ return "RKE03_HB63";
+ case ICCE_APP_CMD_RKE03_C3B64:
+ return "RKE03_C3B64";
+ case ICCE_APP_CMD_RKE03_WATCH12:
+ return "RKE03_WATCH12";
+ case ICCE_APP_CMD_RKE03_VEHICLE_RESP:
+ return "RKE03_VEHICLE_RESP";
+ case ICCE_APP_CMD_RKE03_UNRESOLVED:
+ return "RKE03_UNRESOLVED";
+ case ICCE_APP_CMD_V03_C02_VEH_STATUS_NOTIFY:
+ return "V03_C02_VEH_STATUS_NOTIFY";
+ default:
+ return "?";
+ }
+}
+
+/* ---------- msg=0x03 cmd=0x02 车端主动通知(Status 变化);Tag02=异步安全通道结果 0x16 字节 ---------- */
+
+static const icce_tlv_parse_node_t *icce_find_tlv_at_depth0(const icce_payload_tlv_list_t *list, uint16_t tag)
+{
+ uint16_t i;
+
+ if (list == NULL) {
+ return NULL;
+ }
+ for (i = 0; i < list->count; i++) {
+ if (list->node[i].depth == 0u && list->node[i].tag_number == tag) {
+ return &list->node[i];
+ }
+ }
+ return NULL;
+}
+
+static const char *icce_v03c02_sec_ch_fail_reason_str(uint8_t b)
+{
+ switch (b) {
+ case 0x01:
+ return "VIN 校验失败(认证阶段)";
+ case 0x02:
+ return "SE 未初始化";
+ case 0x03:
+ return "SE 无个人化数据";
+ case 0x04:
+ return "密钥已过期";
+ case 0x05:
+ return "DKFP 校验失败";
+ case 0x06:
+ return "ReaderRand 校验失败";
+ case 0x07:
+ return "密钥已拉黑";
+ case 0xFF:
+ return "未知错误";
+ default:
+ return "未定义(仅失败时关注)";
+ }
+}
+
+static void icce_changan_handle_v03_c02_veh_status_notify(const icce_body_event_t *ev)
+{
+ const icce_tlv_parse_node_t *n01;
+ const icce_tlv_parse_node_t *n02;
+ const icce_tlv_parse_node_t *n03;
+
+ ICCE_LOG("[ICCE V03/C02] 车辆状态变化通知(规范: msg=0x03 cmd=0x02 唯一命令)");
+
+ n01 = icce_find_tlv_at_depth0(&ev->tlv_list, 0x01u);
+ n02 = icce_find_tlv_at_depth0(&ev->tlv_list, 0x02u);
+ n03 = icce_find_tlv_at_depth0(&ev->tlv_list, 0x03u);
+
+ if (n01 != NULL && n01->value != NULL) {
+ ICCE_LOG("[ICCE V03/C02] Tag01 车辆事件: len=%u", (unsigned)n01->value_len);
+ icce_hex_dump_log("V03C02-Tag01-事件", n01->value, n01->value_len);
+ } else {
+ ICCE_LOG("[ICCE V03/C02] Tag01(车辆事件) 无或未解析");
+ }
+
+ if (n02 == NULL || n02->value == NULL) {
+ ICCE_LOG("[ICCE V03/C02] Tag02(异步响应结果) 缺失");
+ } else {
+ if (n02->value_len != ICCE_LEN_V03_TAG02_ASYNC_SEC_RESULT) {
+ ICCE_LOG("[ICCE V03/C02] Tag02 len 期望 0x%02X 实际 %u(仍解析前两字节)",
+ (unsigned)ICCE_LEN_V03_TAG02_ASYNC_SEC_RESULT, (unsigned)n02->value_len);
+ }
+ icce_hex_dump_log("V03C02-Tag02-异步响应结果(22B 规范)", n02->value, n02->value_len);
+ if (n02->value_len >= 1u) {
+ uint8_t b0 = n02->value[0];
+ if (b0 == 0x00u) {
+ ICCE_LOG("[ICCE V03/C02] 安全通道建立: 成功 (byte0=0x00)");
+ } else if (b0 == 0x01u) {
+ uint8_t b1 = (n02->value_len >= 2u) ? n02->value[1] : 0xFFu;
+ ICCE_LOG("[ICCE V03/C02] 安全通道建立: 失败 (byte0=0x01) 原因=0x%02X %s",
+ (unsigned)b1, icce_v03c02_sec_ch_fail_reason_str(b1));
+ } else {
+ ICCE_LOG("[ICCE V03/C02] 安全通道 byte0=0x%02X(非 00/01,请核对线侧规范)", (unsigned)b0);
+ }
+ }
+ }
+
+ if (n03 != NULL && n03->value != NULL) {
+ ICCE_LOG("[ICCE V03/C02] Tag03 车辆状态信息: len=%u", (unsigned)n03->value_len);
+ icce_hex_dump_log("V03C02-Tag03-车辆状态", n03->value, n03->value_len);
+ } else {
+ ICCE_LOG("[ICCE V03/C02] Tag03(车辆状态信息) 无或 VAR 为空");
+ }
+}
+
+/* ---------- msg=0x02 cmd=0x03 RKE 远程车控(控车码 / 车端反馈) ---------- */
+
+static uint32_t icce_rke03_u32_be(const uint8_t *p)
+{
+ return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) | ((uint32_t)p[2] << 8) | (uint32_t)p[3];
+}
+
+static const char *icce_rke03_ctrl_code_name(uint32_t c)
+{
+ switch (c) {
+ case ICCE_RKE_CODE_OPEN_TRUNK:
+ return "open_trunk";
+ case ICCE_RKE_CODE_CLOSE_TRUNK:
+ return "close_trunk";
+ case ICCE_RKE_CODE_UNLOCK_4DOORS:
+ return "unlock_4doors";
+ case ICCE_RKE_CODE_LOCK_4DOORS:
+ return "lock_4doors";
+ default:
+ return "?";
+ }
+}
+
+/*
+ * 开/关行李箱等:车端反馈状态字节(表:0x040101XX / 0x040102XX 等中的末字节含义片段,仅列表示例业务)
+ */
+static const char *icce_rke03_trunk_fb_status_str(uint8_t xx, int is_open_cmd)
+{
+ switch (xx) {
+ case 0x00:
+ return "timeout_or_mcu_no_ibcm_fb";
+ case 0x01:
+ return "exec_ok";
+ case 0x02:
+ return "veh_not_support";
+ case 0x03:
+ return is_open_cmd ? "trunk_already_open" : "trunk_already_closed";
+ case 0x04:
+ return "power_gear_not_off";
+ case 0x05:
+ return "veh_speed_gt0";
+ case 0x06:
+ return "trunk_ctrl_in_progress";
+ case 0x07:
+ return "gear_not_P";
+ case 0x08:
+ return is_open_cmd ? "trunk_not_self_learned" : "unlock_lock_in_progress";
+ case 0x09:
+ return is_open_cmd ? "trunk_protection" : "frunk_not_closed";
+ case 0x0A:
+ return is_open_cmd ? "trunk_no_response" : "gear_or_speed";
+ case 0x0B:
+ return "driver_present";
+ default:
+ return "?";
+ }
+}
+
+static void icce_rke03_scan_inner_u32_pairs(const uint8_t *buf, uint16_t len,
+ uint32_t *ctr, uint32_t *code, uint8_t *got_mask)
+{
+ uint16_t pos = 0;
+
+ *got_mask = 0;
+ *ctr = 0;
+ *code = 0;
+ if (buf == NULL || len == 0) {
+ return;
+ }
+ while (pos < len) {
+ icce_tlv_header_t t = {0};
+ uint16_t u = icce_tlv_unit_bytes(buf + pos, (uint16_t)(len - pos), &t);
+ if (u == 0) {
+ break;
+ }
+ if (t.value != NULL && t.value_len == 4u) {
+ if (t.tag_number == ICCE_RKE03_INNER_COUNTER) {
+ *ctr = icce_rke03_u32_be(t.value);
+ *got_mask |= 1u;
+ } else if (t.tag_number == ICCE_RKE03_INNER_CTRL_CODE) {
+ *code = icce_rke03_u32_be(t.value);
+ *got_mask |= 2u;
+ }
+ }
+ pos = (uint16_t)(pos + u);
+ }
+}
+
+static const icce_tlv_parse_node_t *icce_rke03_find_flat_node(const icce_payload_tlv_list_t *list, uint16_t tag)
+{
+ uint16_t i;
+
+ if (list == NULL) {
+ return NULL;
+ }
+ for (i = 0; i < list->count; i++) {
+ if (list->node[i].tag_number == tag) {
+ return &list->node[i];
+ }
+ }
+ return NULL;
+}
+
+static void icce_changan_rke03_handle_61(const icce_body_event_t *ev)
+{
+ const uint8_t *v = ev->payload_data;
+ uint16_t vlen = ev->payload_len;
+ uint32_t ctr = 0;
+ uint32_t code = 0;
+ uint8_t got = 0;
+
+ if (v == NULL || vlen == 0) {
+ ICCE_LOG("[ICCE RKE03] 61: empty value");
+ return;
+ }
+ icce_rke03_scan_inner_u32_pairs(v, vlen, &ctr, &code, &got);
+ ICCE_LOG("[ICCE RKE03] 61 APP→车 RKE: counter=0x%08X code=0x%08X (%s) inner_ok=%u",
+ (unsigned)ctr, (unsigned)code, icce_rke03_ctrl_code_name(code), (unsigned)got);
+ icce_hex_dump_log("RKE03-61 inner", v, vlen);
+}
+
+static void icce_changan_rke03_handle_vehicle_resp(const icce_body_event_t *ev)
+{
+ const icce_tlv_parse_node_t *n71;
+ uint32_t ctr;
+ uint32_t code;
+ uint8_t got;
+ const uint8_t *st = ev->payload_data;
+ uint8_t status_b = (st != NULL && ev->payload_len >= 1u) ? st[0] : 0xFFu;
+
+ ICCE_LOG("[ICCE RKE03] 车→机 response: first(Status)=0x%02X", (unsigned)status_b);
+ n71 = icce_rke03_find_flat_node(&ev->tlv_list, ICCE_TAG_RKE03_RKE_FEEDBACK_INNER);
+ if (n71 == NULL || n71->value == NULL || n71->value_len == 0) {
+ ICCE_LOG("[ICCE RKE03] no flat Tag 71 in list (可能嵌套于 01,见 tlv 树日志)");
+ return;
+ }
+ icce_rke03_scan_inner_u32_pairs(n71->value, n71->value_len, &ctr, &code, &got);
+ ICCE_LOG("[ICCE RKE03] 71 RKE反馈: counter=0x%08X echo_code=0x%08X (%s)",
+ (unsigned)ctr, (unsigned)code, icce_rke03_ctrl_code_name(code));
+ /* Tag 03 APP 控车反馈 8B:末字节常为结果子码,开/关行李箱对照表 */
+ if (n71->value_len > 0) {
+ uint16_t pos = 0;
+ while (pos < n71->value_len) {
+ icce_tlv_header_t t = {0};
+ uint16_t u = icce_tlv_unit_bytes(n71->value + pos, (uint16_t)(n71->value_len - pos), &t);
+ if (u == 0) {
+ break;
+ }
+ if (t.tag_number == ICCE_RKE03_INNER_APP_FB && t.value != NULL && t.value_len >= 1u) {
+ uint8_t fb0 = t.value[0];
+ ICCE_LOG("[ICCE RKE03] 71-03 APP控车反馈 %u B, first=0x%02X", (unsigned)t.value_len, (unsigned)fb0);
+ icce_hex_dump_log("RKE03-71-03", t.value, t.value_len);
+ if (t.value_len >= 1u) {
+ int is_open = (code == ICCE_RKE_CODE_OPEN_TRUNK);
+ if (code == ICCE_RKE_CODE_OPEN_TRUNK || code == ICCE_RKE_CODE_CLOSE_TRUNK) {
+ ICCE_LOG("[ICCE RKE03] trunk sub_status(表): %s",
+ icce_rke03_trunk_fb_status_str(t.value[t.value_len - 1u], is_open));
+ }
+ }
+ }
+ pos = (uint16_t)(pos + u);
+ }
+ }
+}
+
+static void icce_changan_dispatch_rke03(const icce_body_event_t *ev)
+{
+ switch (ev->app_command) {
+ case ICCE_APP_CMD_RKE03_RKE61:
+ icce_changan_rke03_handle_61(ev);
+ return;
+ case ICCE_APP_CMD_RKE03_VEHICLE_RESP:
+ icce_changan_rke03_handle_vehicle_resp(ev);
+ return;
+ case ICCE_APP_CMD_RKE03_PARK62:
+ case ICCE_APP_CMD_RKE03_HB63:
+ case ICCE_APP_CMD_RKE03_C3B64:
+ case ICCE_APP_CMD_RKE03_WATCH12:
+ ICCE_LOG("[ICCE RKE03] kind=%s tag=0x%04X payload_len=%u",
+ icce_app_command_kind_str(ev->app_command), (unsigned)ev->tag_number, (unsigned)ev->payload_len);
+ if (ev->payload_data != NULL && ev->payload_len > 0) {
+ icce_hex_dump_log("RKE03", ev->payload_data, ev->payload_len);
+ }
+ return;
+ case ICCE_APP_CMD_RKE03_UNRESOLVED:
+ ICCE_LOG("[ICCE RKE03] unresolved first_tag=0x%04X", (unsigned)ev->tag_number);
+ return;
+ default:
+ return;
+ }
+}
+
+/* 仅对明确为「模板/复合」且线路上为明文 TLV 比特流的 Tag 向下解析(勿用 BER constructed 位)。
+ * Tag73:复合密文,在 parse/dump_inner 中专拆。
+ * Tag77:可能是明文 TLV,或与 73 同算法的整段密文,在 parse/dump_inner 中专拆(先尝试解密再扫)。 */
+static int icce_tlv_should_descend_inner(uint16_t tag)
+{
+ switch (tag) {
+ case 0x3C:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static int icce_auth_73_cipher_to_plain(const uint8_t session_key[16],
+ const uint8_t iv_reader_rnd[ICCE_TAG_LEN_READER_RND],
+ const uint8_t iv_card_rnd[ICCE_TAG_LEN_CARD_RND],
+ const uint8_t *cipher, uint16_t cipher_len,
+ uint8_t *plain, uint16_t plain_cap, uint16_t *plain_len_out);
+
+#define ICCE_TLV_DUMP_DEPTH_MAX 6u
+#define ICCE_TLV_COMMAND_PARSE_DEPTH_MAX ICCE_TLV_DUMP_DEPTH_MAX
+
+/* Tag73:勿在任务栈上分配 256B(AT/ICCE 等小栈任务易 SP error);单线程互斥使用 */
+#define ICCE_TLV_73_CIPHER_BUF_LEN 256u
+static uint8_t s_icce_tlv_dump_73_plain[ICCE_TLV_73_CIPHER_BUF_LEN];
+static uint8_t s_icce_tlv_parse_73_plain[ICCE_TLV_73_CIPHER_BUF_LEN];
+/* 77 整段密文解密结果(与 73 同算法);与 parse_73 分缓冲避免嵌套时互相覆盖 */
+static uint8_t s_icce_tlv_parse_77_plain[ICCE_TLV_73_CIPHER_BUF_LEN];
+static uint8_t s_icce_tlv_dump_77_plain[ICCE_TLV_73_CIPHER_BUF_LEN];
+static uint8_t s_icce_auth_73_work[ICCE_TLV_73_CIPHER_BUF_LEN];
+static uint8_t s_icce_auth_73_m2_plain[ICCE_TLV_73_CIPHER_BUF_LEN];
+
+static void icce_payload_tlv_parse_inner(const uint8_t *payload, uint16_t payload_len, uint8_t depth,
+ icce_payload_tlv_list_t *out)
+{
+ uint16_t pos = 0;
+ if (out == NULL) {
+ return;
+ }
+ while (pos < payload_len) {
+ if (out->count >= ICCE_PAYLOAD_TLV_MAX_NODES) {
+ out->truncated = 1;
+ return;
+ }
+ icce_tlv_header_t tlv = {0};
+ uint16_t unit = icce_tlv_unit_bytes(payload + pos, (uint16_t)(payload_len - pos), &tlv);
+ if (unit == 0) {
+ break;
+ }
+ {
+ icce_tlv_parse_node_t *n = &out->node[out->count];
+ n->tag_number = tlv.tag_number;
+ n->value_len = tlv.value_len;
+ n->value = tlv.value;
+ n->depth = depth;
+ out->count++;
+ }
+ /*
+ * Tag 01(APDU):C-APDU(80…) 命令数据段;或 R-APDU 前段(77…||SW)
+ */
+ if (tlv.tag_number == ICCE_TAG_MSG_CMD_ID_1 && tlv.value != NULL && tlv.value_len >= 5u &&
+ depth < ICCE_TLV_COMMAND_PARSE_DEPTH_MAX) {
+ const uint8_t *apdu = tlv.value;
+ uint16_t lc = apdu[4];
+ if (apdu[0] == 0x80u && lc > 0u && (uint32_t)5u + (uint32_t)lc <= (uint32_t)tlv.value_len) {
+ icce_payload_tlv_parse_inner(apdu + 5u, lc, (uint8_t)(depth + 1u), out);
+ } else if (tlv.value_len >= 5u && apdu[0] == (uint8_t)ICCE_TAG_RESP_TEMPLATE &&
+ (uint32_t)tlv.value_len >= 2u) {
+ uint16_t sw_off = (uint16_t)(tlv.value_len - 2u);
+ icce_payload_tlv_parse_inner(apdu, sw_off, (uint8_t)(depth + 1u), out);
+ }
+ } else if (tlv.tag_number == ICCE_TAG_ICCE_VAR_CIPHER_TEMPLATE && tlv.value != NULL && tlv.value_len > 0 &&
+ depth < ICCE_TLV_COMMAND_PARSE_DEPTH_MAX) {
+ /* 73 线路上为密文,非嵌套 TLV;解密后再扫内层 9F36/9F37/… */
+ uint16_t pl73 = 0;
+ if (g_icce_session_key_valid && g_icce_auth_cache_reader_rnd_valid && g_icce_auth_cache_card_rnd_valid &&
+ icce_auth_73_cipher_to_plain(g_icce_session_key, g_icce_auth_cache_reader_rnd,
+ g_icce_auth_cache_card_rnd, tlv.value, tlv.value_len, s_icce_tlv_parse_73_plain,
+ (uint16_t)sizeof(s_icce_tlv_parse_73_plain), &pl73) == 0) {
+ icce_payload_tlv_parse_inner(s_icce_tlv_parse_73_plain, pl73, (uint8_t)(depth + 1u), out);
+ }
+ } else if (tlv.tag_number == ICCE_TAG_RESP_TEMPLATE && tlv.value != NULL && tlv.value_len > 0 &&
+ depth < ICCE_TLV_COMMAND_PARSE_DEPTH_MAX) {
+ /* 77:规范为复合数据域;整段 Value 可为与 73 相同的 AES-CBC(SessionKey)+ISO9797_M2 密文,或明文嵌套 TLV */
+ uint16_t pl77 = 0;
+ if (g_icce_session_key_valid && g_icce_auth_cache_reader_rnd_valid && g_icce_auth_cache_card_rnd_valid &&
+ (tlv.value_len % 16u) == 0u &&
+ icce_auth_73_cipher_to_plain(g_icce_session_key, g_icce_auth_cache_reader_rnd,
+ g_icce_auth_cache_card_rnd, tlv.value, tlv.value_len, s_icce_tlv_parse_77_plain,
+ (uint16_t)sizeof(s_icce_tlv_parse_77_plain), &pl77) == 0) {
+ icce_payload_tlv_parse_inner(s_icce_tlv_parse_77_plain, pl77, (uint8_t)(depth + 1u), out);
+ } else {
+ icce_payload_tlv_parse_inner(tlv.value, tlv.value_len, (uint8_t)(depth + 1u), out);
+ }
+ } else if (icce_tlv_should_descend_inner(tlv.tag_number) && tlv.value != NULL && tlv.value_len > 0 &&
+ depth < ICCE_TLV_COMMAND_PARSE_DEPTH_MAX) {
+ icce_payload_tlv_parse_inner(tlv.value, tlv.value_len, (uint8_t)(depth + 1u), out);
+ }
+ pos = (uint16_t)(pos + unit);
+ }
+}
+
+int icce_payload_tlv_parse_command(const uint8_t *payload, uint16_t payload_len, icce_payload_tlv_list_t *out)
+{
+ if (out == NULL) {
+ return -1;
+ }
+ out->count = 0;
+ out->truncated = 0;
+ if (payload == NULL || payload_len == 0) {
+ return 0;
+ }
+ icce_payload_tlv_parse_inner(payload, payload_len, 0, out);
+ return 0;
+}
+
+/*
+ * 从 icce_payload_tlv_parse_command 生成的平面 TLV 表里抽出「第一个 depth==0 的顶层 TLV」,
+ * 填入 parsed,供事件里 tag_number / payload_data 指向「首个顶层 Tag 的 Value」。
+ * 若解析失败或未得到任何节点(count==0),则退回为整段 payload 当作一块原始数据(tag=0)。
+ */
+static void icce_parsed_from_tlv_list_first_top(const icce_payload_tlv_list_t *list, icce_parsed_body_t *parsed,
+ const uint8_t *fallback_payload, uint16_t fallback_len)
+{
+ if (parsed == NULL) {
+ return;
+ }
+ if (list == NULL || list->count == 0) {
+ parsed->tag_number = 0;
+ parsed->value_len = fallback_len;
+ parsed->value = fallback_payload;
+ return;
+ }
+ uint16_t i;
+ for (i = 0; i < list->count; i++) {
+ if (list->node[i].depth == 0) {
+ parsed->tag_number = list->node[i].tag_number;
+ parsed->value_len = list->node[i].value_len;
+ parsed->value = list->node[i].value;
+ return;
+ }
+ }
+ parsed->tag_number = list->node[0].tag_number;
+ parsed->value_len = list->node[0].value_len;
+ parsed->value = list->node[0].value;
+}
+
+static void icce_payload_tlv_dump_inner(const uint8_t *payload, uint16_t payload_len, uint8_t depth,
+ uint32_t *node_ix, const uint8_t *payload_base)
+{
+ uint16_t pos = 0;
+ while (pos < payload_len) {
+ icce_tlv_header_t tlv = {0};
+ uint16_t unit = icce_tlv_unit_bytes(payload + pos, (uint16_t)(payload_len - pos), &tlv);
+ if (unit == 0) {
+ ICCE_LOG("[ICCE TLV] offset=%u parse stop/trunc", (unsigned)pos);
+ break;
+ }
+ (*node_ix)++;
+ {
+ uint16_t abs_off = (uint16_t)((payload + pos) - payload_base);
+ ICCE_LOG("[ICCE TLV] #%u d=%u off=%04X tag=0x%04X (%s) len=%u unit=%u",
+ (unsigned)(*node_ix),
+ (unsigned)depth,
+ (unsigned)abs_off,
+ (unsigned)tlv.tag_number,
+ icce_tlv_tag_label(tlv.tag_number),
+ (unsigned)tlv.value_len,
+ (unsigned)unit);
+ }
+ if (tlv.tag_number == ICCE_TAG_ICCE_VAR_CIPHER_TEMPLATE && tlv.value != NULL && tlv.value_len > 0) {
+ ICCE_LOG("[ICCE TLV] 73: Var 复合密文域(线路上为 AES 密文,勿当嵌套 TLV 解析)");
+ icce_hex_dump_log("TLVv-73-cipher", tlv.value, tlv.value_len);
+ if (depth < ICCE_TLV_DUMP_DEPTH_MAX) {
+ if (!g_icce_session_key_valid || !g_icce_auth_cache_reader_rnd_valid || !g_icce_auth_cache_card_rnd_valid) {
+ ICCE_LOG("[ICCE TLV] 73: inner TLV dump skipped (need SessionKey + cached ReaderRnd + CardRnd)");
+ } else {
+ uint16_t pl73 = 0;
+ if (icce_auth_73_cipher_to_plain(g_icce_session_key, g_icce_auth_cache_reader_rnd,
+ g_icce_auth_cache_card_rnd, tlv.value, tlv.value_len,
+ s_icce_tlv_dump_73_plain, (uint16_t)sizeof(s_icce_tlv_dump_73_plain), &pl73) != 0) {
+ ICCE_LOG("[ICCE TLV] 73: decrypt/M2 unpad fail (IV/key mismatch or wrong cipher)");
+ } else {
+ ICCE_LOG("[ICCE TLV] ---- nested TLVs inside 73 (decrypted plaintext %u B) ----",
+ (unsigned)pl73);
+ icce_hex_dump_log("TLVv-73-plain", s_icce_tlv_dump_73_plain, pl73);
+ icce_payload_tlv_dump_inner(s_icce_tlv_dump_73_plain, pl73, (uint8_t)(depth + 1u), node_ix,
+ s_icce_tlv_dump_73_plain);
+ }
+ }
+ }
+ } else if (tlv.tag_number == ICCE_TAG_RESP_TEMPLATE && tlv.value != NULL && tlv.value_len > 0) {
+ ICCE_LOG("[ICCE TLV] 77: 响应复合数据域(与 73 同算法时先 AES+M2 解密再展开嵌套 TLV)");
+ icce_hex_dump_log("TLVv-77-wire", tlv.value, tlv.value_len);
+ if (depth < ICCE_TLV_DUMP_DEPTH_MAX) {
+ if (g_icce_session_key_valid && g_icce_auth_cache_reader_rnd_valid && g_icce_auth_cache_card_rnd_valid &&
+ (tlv.value_len % 16u) == 0u) {
+ uint16_t pl77 = 0;
+ if (icce_auth_73_cipher_to_plain(g_icce_session_key, g_icce_auth_cache_reader_rnd,
+ g_icce_auth_cache_card_rnd, tlv.value, tlv.value_len,
+ s_icce_tlv_dump_77_plain, (uint16_t)sizeof(s_icce_tlv_dump_77_plain), &pl77) == 0) {
+ ICCE_LOG("[ICCE TLV] ---- nested TLVs inside 77 (decrypted plaintext %u B) ----",
+ (unsigned)pl77);
+ icce_hex_dump_log("TLVv-77-plain", s_icce_tlv_dump_77_plain, pl77);
+ icce_payload_tlv_dump_inner(s_icce_tlv_dump_77_plain, pl77, (uint8_t)(depth + 1u), node_ix,
+ s_icce_tlv_dump_77_plain);
+ } else {
+ ICCE_LOG("[ICCE TLV] 77: decrypt/M2 fail,按明文嵌套解析");
+ icce_payload_tlv_dump_inner(tlv.value, tlv.value_len, (uint8_t)(depth + 1u), node_ix,
+ payload_base);
+ }
+ } else {
+ ICCE_LOG("[ICCE TLV] 77: 密钥或长度非 16 倍数,按明文嵌套 TLV 展开");
+ icce_payload_tlv_dump_inner(tlv.value, tlv.value_len, (uint8_t)(depth + 1u), node_ix,
+ payload_base);
+ }
+ }
+ } else if (tlv.value_len > 0 && tlv.value != NULL) {
+ icce_hex_dump_log("TLVv", tlv.value, tlv.value_len);
+ }
+ /*
+ * Tag 01(APDU):
+ * 车端请求:CLA=80 时为 C-APDU:CLA||INS||P1||P2||Lc + 命令数据(9F1E/9F37/9F0C…)。
+ * 手机回应:R-APDU = TLV(77 响应复合数据域) || SW1||SW2(常见 90 00),不再单独顶层 Tag77。
+ */
+ if (tlv.tag_number == ICCE_TAG_MSG_CMD_ID_1 && tlv.value != NULL && tlv.value_len >= 5u &&
+ depth < ICCE_TLV_DUMP_DEPTH_MAX) {
+ const uint8_t *apdu = tlv.value;
+ uint16_t lc = apdu[4];
+ if (apdu[0] == 0x80u && lc > 0u && (uint32_t)5u + (uint32_t)lc <= (uint32_t)tlv.value_len) {
+ ICCE_LOG("[ICCE TLV] C-APDU hdr: CLA=%02X INS=%02X P1=%02X P2=%02X Lc=%02X (+%uB cmd data)",
+ apdu[0], apdu[1], apdu[2], apdu[3], apdu[4], (unsigned)lc);
+ ICCE_LOG("[ICCE TLV] ---- nested TLVs inside 01 cmd data (9F1E/9F37/9F0C …) ----");
+ icce_payload_tlv_dump_inner(apdu + 5u, lc, (uint8_t)(depth + 1u), node_ix, payload_base);
+ } else if (tlv.value_len >= 5u && apdu[0] == (uint8_t)ICCE_TAG_RESP_TEMPLATE &&
+ (uint32_t)tlv.value_len >= 2u) {
+ uint16_t sw_off = (uint16_t)(tlv.value_len - 2u);
+ ICCE_LOG("[ICCE TLV] R-APDU: SW1=%02X SW2=%02X (prefix TLV block %u B)",
+ apdu[sw_off], apdu[sw_off + 1u], (unsigned)sw_off);
+ ICCE_LOG("[ICCE TLV] ---- nested TLVs inside 01 R-APDU (77/5A/9F3B/…) ----");
+ icce_payload_tlv_dump_inner(apdu, sw_off, (uint8_t)(depth + 1u), node_ix, payload_base);
+ }
+ } else if (tlv.tag_number == 0x3Cu && tlv.value != NULL && tlv.value_len > 0 &&
+ depth < ICCE_TLV_DUMP_DEPTH_MAX) {
+ icce_payload_tlv_dump_inner(tlv.value, tlv.value_len, (uint8_t)(depth + 1u), node_ix, payload_base);
+ }
+ pos = (uint16_t)(pos + unit);
+ }
+}
+
+/*
+ * 打印 body payload 顶层 TLV;Tag01 为 C-APDU(80…) 时下钻命令数据;为 R-APDU(77…||SW) 时下钻 77 前段。
+ */
+void icce_payload_tlv_dump(const uint8_t *payload, uint16_t payload_len)
+{
+ uint32_t node_ix = 0;
+ if (payload == NULL || payload_len == 0) {
+ return;
+ }
+ ICCE_LOG("[ICCE TLV] ---- payload %u bytes, TLV list (tag/len/value) ----", (unsigned)payload_len);
+ icce_hex_dump_log("PLD", payload, payload_len);
+ icce_payload_tlv_dump_inner(payload, payload_len, 0, &node_ix, payload);
+ ICCE_LOG("[ICCE TLV] ---- end: %u TLV node(s), depth nesting above ----", (unsigned)node_ix);
+}
+
+/* 与 TLV 打印一致:顶层 TLV + Tag01 内 APDU 命令数据段再扫 9F1E/9F37/9F0C */
+static void icce_auth_scan_payload_segment(const uint8_t *payload, uint16_t payload_len, icce_auth_tlv_scan_t *out)
+{
+ if (payload == NULL || payload_len == 0 || out == NULL) {
+ return;
+ }
+ uint16_t pos = 0;
+ while (pos < payload_len) {
+ icce_tlv_header_t tlv = {0};
+ uint16_t unit = icce_tlv_unit_bytes(payload + pos, (uint16_t)(payload_len - pos), &tlv);
+ if (unit == 0) {
+ break;
+ }
+ switch (tlv.tag_number) {
+ case ICCE_TAG_MSG_CMD_ID_1: /* APDU 数据 */
+ out->has_apdu = 1;
+ out->apdu = tlv.value;
+ out->apdu_len = tlv.value_len;
+ if (tlv.value != NULL && tlv.value_len >= 5u) {
+ const uint8_t *apdu = tlv.value;
+ uint16_t lc = apdu[4];
+ if (lc > 0u && (uint32_t)5u + (uint32_t)lc <= (uint32_t)tlv.value_len) {
+ icce_auth_scan_payload_segment(apdu + 5u, lc, out);
+ }
+ }
+ break;
+ case ICCE_TAG_9F1E_READER_ID:
+ if (tlv.value_len == ICCE_TAG_LEN_READER_ID) {
+ out->has_reader_id = 1;
+ memcpy(out->reader_id, tlv.value, ICCE_TAG_LEN_READER_ID);
+ }
+ break;
+ case ICCE_TAG_9F37_READER_RND:
+ if (tlv.value_len == ICCE_TAG_LEN_READER_RND) {
+ out->has_reader_rnd = 1;
+ memcpy(out->reader_rnd, tlv.value, ICCE_TAG_LEN_READER_RND);
+ } else {
+ ICCE_LOG("9F37 ReaderRnd bad len=%u (expect 8 from BLE)", (unsigned)tlv.value_len);
+ }
+ break;
+ case ICCE_TAG_9F0C_READER_KEY_PARAM:
+ if (tlv.value_len == ICCE_TAG_LEN_READER_KEY_PARAM) {
+ out->has_reader_key_param = 1;
+ memcpy(out->reader_key_param, tlv.value, ICCE_TAG_LEN_READER_KEY_PARAM);
+ }
+ break;
+ case ICCE_TAG_9F36_CARD_ATC:
+ if (tlv.value_len == ICCE_TAG_LEN_CARD_ATC) {
+ out->has_card_atc = 1;
+ memcpy(out->card_atc, tlv.value, ICCE_TAG_LEN_CARD_ATC);
+ }
+ break;
+ case ICCE_TAG_9F3E_CARD_RND:
+ /* 认证回合车端可能回传 9F3E;SessionKey 明文中的 CardRnd 仍以本端生成为准 */
+ if (tlv.value_len == ICCE_TAG_LEN_CARD_RND) {
+ out->has_card_rnd = 1;
+ memcpy(out->card_rnd, tlv.value, ICCE_TAG_LEN_CARD_RND);
+ }
+ break;
+ case ICCE_TAG_RESP_TEMPLATE: /* 0x77 复合数据域:密文(同 73 算法)或明文 TLV */
+ if (tlv.value != NULL && tlv.value_len > 0) {
+ uint16_t pl77 = 0;
+ if (g_icce_session_key_valid && g_icce_auth_cache_reader_rnd_valid && g_icce_auth_cache_card_rnd_valid &&
+ (tlv.value_len % 16u) == 0u &&
+ icce_auth_73_cipher_to_plain(g_icce_session_key, g_icce_auth_cache_reader_rnd,
+ g_icce_auth_cache_card_rnd, tlv.value, tlv.value_len, s_icce_tlv_parse_77_plain,
+ (uint16_t)sizeof(s_icce_tlv_parse_77_plain), &pl77) == 0) {
+ icce_auth_scan_payload_segment(s_icce_tlv_parse_77_plain, pl77, out);
+ } else {
+ icce_auth_scan_payload_segment(tlv.value, tlv.value_len, out);
+ }
+ }
+ break;
+ case ICCE_TAG_ICCE_VAR_CIPHER_TEMPLATE:
+ if (!out->has_auth_cmd_cipher73 && tlv.value != NULL && tlv.value_len > 0) {
+ out->has_auth_cmd_cipher73 = 1;
+ out->auth_cmd_cipher73 = tlv.value;
+ out->auth_cmd_cipher73_len = tlv.value_len;
+ }
+ break;
+ default:
+ break;
+ }
+ pos = (uint16_t)(pos + unit);
+ }
+}
+
+static int icce_auth_parse_inner_tlv_auth_cmd_73(const uint8_t *inner, uint16_t inner_len,
+ uint8_t card_atc_out[ICCE_TAG_LEN_CARD_ATC],
+ uint8_t reader_rnd_out[ICCE_TAG_LEN_READER_RND],
+ uint8_t card_rnd_out[ICCE_TAG_LEN_CARD_RND],
+ uint8_t *inner_has_card_rnd_out);
+static int icce_auth_decrypt_73_vehicle_auth_cmd(const uint8_t session_key[16],
+ const uint8_t iv_reader_rnd[ICCE_TAG_LEN_READER_RND],
+ const uint8_t iv_card_rnd[ICCE_TAG_LEN_CARD_RND],
+ const uint8_t *cipher, uint16_t cipher_len,
+ uint8_t card_atc_out[ICCE_TAG_LEN_CARD_ATC],
+ uint8_t reader_rnd_out[ICCE_TAG_LEN_READER_RND],
+ uint8_t card_rnd_out[ICCE_TAG_LEN_CARD_RND],
+ uint8_t *inner_has_card_rnd_out);
+
+/*
+ * 认证指令 Tag73:与「取处理数据回应」中 icce_auth_encrypt_73_inner 对称(内层 TLV 为 9F36+9F3E),
+ * IV 须与车端加密一致:取数据阶段缓存的 9F37(ReaderRnd) + 本端 9F3E(CardRnd)。
+ */
+static void icce_auth_try_decrypt_vehicle_auth_cipher73(icce_auth_tlv_scan_t *out)
+{
+ if (out == NULL || !out->has_auth_cmd_cipher73 || out->auth_cmd_cipher73 == NULL) {
+ return;
+ }
+ if (!g_icce_session_key_valid) {
+ ICCE_LOG("[ICCE AUTH] Tag73 present: need SessionKey (complete GET-data / key derivation first)");
+ return;
+ }
+ if (!g_icce_auth_cache_card_rnd_valid) {
+ ICCE_LOG("[ICCE AUTH] Tag73 present: need cached 9F3E(CardRnd) for IV half");
+ return;
+ }
+ /* IV 前半:本指令内明文 9F37 优先,否则取数据阶段缓存的 9F37 */
+ const uint8_t *iv_rn = g_icce_auth_cache_reader_rnd;
+ if (out->has_reader_rnd) {
+ iv_rn = out->reader_rnd;
+ } else if (!g_icce_auth_cache_reader_rnd_valid) {
+ ICCE_LOG("[ICCE AUTH] Tag73 present: need 9F37(ReaderRnd) in cmd or GET-data cache for IV");
+ return;
+ }
+ uint8_t atc[ICCE_TAG_LEN_CARD_ATC];
+ uint8_t reader_inner[ICCE_TAG_LEN_READER_RND];
+ uint8_t crnd[ICCE_TAG_LEN_CARD_RND];
+ uint8_t inner_has_cr = 0;
+ if (icce_auth_decrypt_73_vehicle_auth_cmd(g_icce_session_key, iv_rn, g_icce_auth_cache_card_rnd,
+ out->auth_cmd_cipher73, out->auth_cmd_cipher73_len, atc, reader_inner, crnd, &inner_has_cr) != 0) {
+ ICCE_LOG("[ICCE AUTH] vehicle auth Tag73 decrypt/M2/inner TLV fail (len=%u)", (unsigned)out->auth_cmd_cipher73_len);
+ return;
+ }
+ out->has_card_atc = 1;
+ memcpy(out->card_atc, atc, sizeof(atc));
+ out->has_reader_rnd = 1;
+ memcpy(out->reader_rnd, reader_inner, sizeof(reader_inner));
+ if (inner_has_cr) {
+ out->has_card_rnd = 1;
+ memcpy(out->card_rnd, crnd, sizeof(crnd));
+ }
+ ICCE_LOG("[ICCE AUTH] Tag73 decrypted → 9F36/9F37(TLV)%s", inner_has_cr ? ", 9F3E inner" : " (9F3E 见 77 外明文)");
+ icce_hex_dump_log("AUTH 73→card_atc", atc, sizeof(atc));
+ icce_hex_dump_log("AUTH 73→reader_rnd", reader_inner, sizeof(reader_inner));
+ if (inner_has_cr) {
+ icce_hex_dump_log("AUTH 73→card_rnd", crnd, sizeof(crnd));
+ }
+}
+
+static void icce_auth_scan_payload(const uint8_t *payload, uint16_t payload_len, icce_auth_tlv_scan_t *out)
+{
+ icce_auth_tlv_scan_reset(out);
+ icce_auth_scan_payload_segment(payload, payload_len, out);
+ icce_auth_try_decrypt_vehicle_auth_cipher73(out);
+}
+
+/* 车→机「取处理数据」:01 内 APDU 命令数据段固定带 9F1E(ReaderID)+9F37(ReaderRnd)+9F0C(ReaderKeyParam) */
+static int icce_changan_is_get_process_data_cmd(const icce_auth_tlv_scan_t *scan)
+{
+ if (scan == NULL) {
+ return 0;
+ }
+ if (!scan->has_apdu) {
+ return 0;
+ }
+ return scan->has_reader_id && scan->has_reader_rnd && scan->has_reader_key_param;
+}
+
+/*
+ * 车→机「认证指令」:与「取处理数据」互斥(取数据需 9F1E+9F37+9F0C)。
+ * 明文形态:9F36+9F3E;或 77 内 Tag73(内层先 TLV 含 9F37(ReaderRnd) 再 M2 再 AES,必选 9F36+9F37,9F3E 可内层或 77 外)。
+ * 9F0A 不使用。
+ */
+static int icce_changan_is_auth_command(const icce_auth_tlv_scan_t *scan)
+{
+ if (scan == NULL || !scan->has_apdu) {
+ return 0;
+ }
+ if (icce_changan_is_get_process_data_cmd(scan)) {
+ return 0;
+ }
+ return scan->has_card_atc && scan->has_card_rnd;
+}
+
+/*
+ * Message ID=0x01、Command ID=0x01:取处理数据与认证指令共用同一对 ID;区分见 icce_resolve_app_command_kind
+ *(ICCE_APP_CMD_AUTH01_*)与 icce_changan_is_get_process_data_cmd / icce_changan_is_auth_command。
+ */
+
+/*
+ * 在命令形式 TLV 解析(多 TLV + 嵌套)完成后,结合 msg/cmd 与(0x01/0x01 时)认证域 TLV 扫描结果,得到具体命令枚举。
+ * auth_scan_opt:若非 NULL,须为对当前 payload 已执行过的 icce_auth_scan_payload 结果(与同步回复共用,避免重复扫)。
+ */
+static icce_app_command_kind_t icce_resolve_app_command_kind(const icce_frame_body_t *frame_body,
+ const icce_payload_tlv_list_t *tlv_list,
+ const icce_parsed_body_t *parsed,
+ const icce_auth_tlv_scan_t *auth_scan_opt)
+{
+ if (frame_body == NULL) {
+ return ICCE_APP_CMD_UNKNOWN;
+ }
+
+ uint8_t m = frame_body->message_id;
+ uint8_t c = frame_body->command_id;
+
+ if (m == ICCE_MSG_AUTH_DATA && c == ICCE_CMD_AUTH_DATA) {
+ if (frame_body->payload_data == NULL || frame_body->payload_len == 0) {
+ return ICCE_APP_CMD_AUTH01_UNRESOLVED;
+ }
+ icce_auth_tlv_scan_t scan_stack;
+ const icce_auth_tlv_scan_t *scan;
+ if (auth_scan_opt != NULL) {
+ scan = auth_scan_opt;
+ } else {
+ icce_auth_tlv_scan_reset(&scan_stack);
+ icce_auth_scan_payload(frame_body->payload_data, frame_body->payload_len, &scan_stack);
+ scan = &scan_stack;
+ }
+ if (icce_changan_is_get_process_data_cmd(scan)) {
+ return ICCE_APP_CMD_AUTH01_GET_PROCESS_DATA;
+ }
+ if (icce_changan_is_auth_command(scan)) {
+ return ICCE_APP_CMD_AUTH01_VEHICLE_AUTH;
+ }
+ return ICCE_APP_CMD_AUTH01_UNRESOLVED;
+ }
+
+ /* msg=0x03 cmd=0x02:规范唯一配对,不依赖首 TLV(避免 Tag01=0x01 被误归入 RKE) */
+ if (m == ICCE_MSG_VEHICLE_STATUS_NOTIFY && c == ICCE_CMD_VEH_STATUS_EVENT) {
+ return ICCE_APP_CMD_V03_C02_VEH_STATUS_NOTIFY;
+ }
+
+ int tlv_ok = (tlv_list != NULL && tlv_list->count > 0);
+ if (!tlv_ok || parsed == NULL) {
+ return ICCE_APP_CMD_UNKNOWN;
+ }
+
+ uint16_t tag = parsed->tag_number;
+
+ /* msg=0x02 cmd=0x03:RKE 远程车控/泊车/心跳(0x61 与 0x61 后台同 Tag,以本 cmd 区分) */
+ if (m == ICCE_MSG_RKE_CTRL && c == ICCE_CMD_RKE_REMOTE_CTRL) {
+ switch (tag) {
+ case ICCE_TAG_STATUS:
+ return ICCE_APP_CMD_RKE03_VEHICLE_RESP;
+ case ICCE_TAG_RKE03_RKE_CTRL_ROOT: /* 与 0x61 后台同值,以 msg=0x02 cmd=0x03 定 RKE 语义 */
+ return ICCE_APP_CMD_RKE03_RKE61;
+ case ICCE_TAG_RKE03_ROOT_PARK62:
+ return ICCE_APP_CMD_RKE03_PARK62;
+ case ICCE_TAG_RKE03_ROOT_HB63:
+ return ICCE_APP_CMD_RKE03_HB63;
+ case ICCE_TAG_RKE03_ROOT_C3B64:
+ return ICCE_APP_CMD_RKE03_C3B64;
+ case 0x12:
+ return ICCE_APP_CMD_RKE03_WATCH12;
+ default:
+ return ICCE_APP_CMD_RKE03_UNRESOLVED;
+ }
+ }
+
+ if (m == ICCE_MSG_RKE_CTRL && c == ICCE_CMD_RKE_MAIN) {
+ switch (tag) {
+ case ICCE_TAG_CA_APP_RKE:
+ return ICCE_APP_CMD_RKE_APP_CONTROL;
+ case ICCE_TAG_CA_APP_HEARTBEAT:
+ return ICCE_APP_CMD_RKE_APP_HEARTBEAT;
+ case ICCE_TAG_CA_VEHICLE_REQ_APP:
+ return ICCE_APP_CMD_RKE_VEHICLE_REQ_APP;
+ default:
+ return ICCE_APP_CMD_RKE_UNRESOLVED;
+ }
+ }
+
+ switch (tag) {
+ case ICCE_TAG_CA_VEHICLE_STATUS:
+ return ICCE_APP_CMD_CA_VEHICLE_STATUS;
+ case ICCE_TAG_CA_RKE_PARK_COUNTER:
+ return ICCE_APP_CMD_CA_RKE_PARK_COUNTER;
+ case ICCE_TAG_CA_RKE_PARK_SIGNAL:
+ return ICCE_APP_CMD_CA_RKE_PARK_SIGNAL;
+ case ICCE_TAG_CA_APP_CTRL_FEEDBACK:
+ return ICCE_APP_CMD_CA_APP_CTRL_FEEDBACK;
+ case ICCE_TAG_CA_NORMAL_DATA:
+ return ICCE_APP_CMD_CA_NORMAL_DATA;
+ case ICCE_TAG_CA_APA_DATA:
+ return ICCE_APP_CMD_CA_APA_DATA;
+ case ICCE_TAG_CA_BACKEND_IF_ID:
+ return ICCE_APP_CMD_CA_BACKEND_IF_ID;
+ case ICCE_TAG_CA_VEHICLE_PARAM:
+ return ICCE_APP_CMD_CA_VEHICLE_PARAM;
+ case ICCE_TAG_CA_BACKEND_RESP:
+ return ICCE_APP_CMD_CA_BACKEND_RESP;
+ case ICCE_TAG_CA_BLE_UWB_KEY_STATUS:
+ return ICCE_APP_CMD_CA_BLE_UWB_KEY_STATUS;
+ case ICCE_TAG_CA_VEHICLE_UPLOAD:
+ return ICCE_APP_CMD_CA_VEHICLE_UPLOAD;
+ case ICCE_TAG_CA_APP_PARK_CTRL:
+ return ICCE_APP_CMD_CA_APP_PARK_CTRL;
+ case ICCE_TAG_CA_APP_HEARTBEAT_DATA:
+ return ICCE_APP_CMD_CA_APP_HEARTBEAT_DATA;
+ case ICCE_TAG_CA_RKE_FEEDBACK_PLAIN:
+ return ICCE_APP_CMD_CA_RKE_FEEDBACK_PLAIN;
+ case ICCE_TAG_CA_VEHICLE_PARK_RESP:
+ return ICCE_APP_CMD_CA_VEHICLE_PARK_RESP;
+ case ICCE_TAG_CA_VEHICLE_HB_RESP:
+ return ICCE_APP_CMD_CA_VEHICLE_HB_RESP;
+ case ICCE_TAG_CA_SEC_CH_VEHICLE:
+ return ICCE_APP_CMD_CA_SEC_CH_VEHICLE;
+ case ICCE_TAG_CA_SEC_CH_BACKEND:
+ return ICCE_APP_CMD_CA_SEC_CH_BACKEND;
+ default:
+ return ICCE_APP_CMD_UNKNOWN;
+ }
+}
+
+/* ISO/IEC 9797-1 Method 2:末尾 0x80,再补 0 至 16 字节对齐 */
+static uint16_t icce_iso9797_m2_pad(const uint8_t *in, uint16_t in_len, uint8_t *out, uint16_t out_cap)
+{
+ uint32_t i;
+ uint16_t need = (uint16_t)(in_len + 1u);
+ while ((need % 16u) != 0u) {
+ need++;
+ }
+ if (need > out_cap || need == 0) {
+ return 0;
+ }
+ if (in_len > 0 && in != NULL) {
+ memcpy(out, in, in_len);
+ }
+ out[in_len] = 0x80;
+ for (i = (uint32_t)in_len + 1u; i < need; i++) {
+ out[i] = 0x00;
+ }
+ return need;
+}
+
+/* ISO9797-1 M2 去填充:与 icce_iso9797_m2_pad 对称,返回去垫后数据长度,失败返回 0 */
+static uint16_t icce_iso9797_m2_unpad(const uint8_t *in, uint16_t in_len, uint8_t *out, uint16_t out_cap)
+{
+ if (in == NULL || out == NULL || in_len == 0) {
+ return 0;
+ }
+ int i = (int)in_len - 1;
+ while (i >= 0 && in[i] == 0) {
+ i--;
+ }
+ if (i < 0 || in[i] != 0x80) {
+ return 0;
+ }
+ uint16_t dlen = (uint16_t)i;
+ if (dlen > out_cap) {
+ return 0;
+ }
+ if (dlen > 0) {
+ memcpy(out, in, dlen);
+ }
+ return dlen;
+}
+
+/*
+ * Tag73 复合密文 → 内层 TLV 明文:AES-128-CBC(SessionKey, SessionIV=ReaderRnd‖CardRnd) + ISO9797-1 M2 去垫。
+ * 与 icce_auth_decrypt_73_vehicle_auth_cmd 解密段一致,仅输出明文供打印/命令解析树。
+ */
+static int icce_auth_73_cipher_to_plain(const uint8_t session_key[16],
+ const uint8_t iv_reader_rnd[ICCE_TAG_LEN_READER_RND],
+ const uint8_t iv_card_rnd[ICCE_TAG_LEN_CARD_RND],
+ const uint8_t *cipher, uint16_t cipher_len,
+ uint8_t *plain, uint16_t plain_cap, uint16_t *plain_len_out)
+{
+ if (plain_len_out == NULL) {
+ return -1;
+ }
+ *plain_len_out = 0;
+ if (cipher == NULL || plain == NULL || cipher_len == 0 || (cipher_len % 16u) != 0u ||
+ cipher_len > ICCE_TLV_73_CIPHER_BUF_LEN) {
+ return -1;
+ }
+ memcpy(s_icce_auth_73_work, cipher, cipher_len);
+ uint8_t iv_work[16];
+ memcpy(iv_work, iv_reader_rnd, ICCE_TAG_LEN_READER_RND);
+ memcpy(iv_work + ICCE_TAG_LEN_READER_RND, iv_card_rnd, ICCE_TAG_LEN_CARD_RND);
+ mbedtls_aes_context aes;
+ mbedtls_aes_init(&aes);
+ if (mbedtls_aes_setkey_dec(&aes, session_key, 128) != 0) {
+ mbedtls_aes_free(&aes);
+ return -1;
+ }
+ if (mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_DECRYPT, cipher_len, iv_work, s_icce_auth_73_work,
+ s_icce_auth_73_work) != 0) {
+ mbedtls_aes_free(&aes);
+ return -1;
+ }
+ mbedtls_aes_free(&aes);
+ uint16_t plen = icce_iso9797_m2_unpad(s_icce_auth_73_work, cipher_len, plain, plain_cap);
+ if (plen == 0) {
+ return -1;
+ }
+ *plain_len_out = plen;
+ return 0;
+}
+
+/*
+ * 车→机「认证指令」Tag73 内层:与 icce_auth_encrypt_73_inner(取数据回应)一致 —
+ * 明文 = TLV 拼接(须含 TLV(9F37,ReaderRnd))→ ISO9797_M2 → AES。
+ * 必选:9F36(CardATC)、9F37(ReaderRnd);可选:9F3E(CardRnd),若无则依赖 77 外明文 9F3E。
+ */
+static int icce_auth_parse_inner_tlv_auth_cmd_73(const uint8_t *inner, uint16_t inner_len,
+ uint8_t card_atc_out[ICCE_TAG_LEN_CARD_ATC],
+ uint8_t reader_rnd_out[ICCE_TAG_LEN_READER_RND],
+ uint8_t card_rnd_out[ICCE_TAG_LEN_CARD_RND],
+ uint8_t *inner_has_card_rnd_out)
+{
+ uint8_t got_atc = 0;
+ uint8_t got_rdr = 0;
+ uint16_t pos = 0;
+ if (inner_has_card_rnd_out != NULL) {
+ *inner_has_card_rnd_out = 0;
+ }
+ while (pos < inner_len) {
+ icce_tlv_header_t tlv = {0};
+ int h = icce_tlv_parse(inner + pos, (uint16_t)(inner_len - pos), &tlv);
+ if (h < 0) {
+ return -1;
+ }
+ uint16_t unit = (uint16_t)((uint16_t)h + tlv.value_len);
+ if (tlv.tag_number == ICCE_TAG_9F36_CARD_ATC && tlv.value_len == ICCE_TAG_LEN_CARD_ATC && tlv.value != NULL) {
+ memcpy(card_atc_out, tlv.value, ICCE_TAG_LEN_CARD_ATC);
+ got_atc = 1;
+ } else if (tlv.tag_number == ICCE_TAG_9F37_READER_RND && tlv.value_len == ICCE_TAG_LEN_READER_RND &&
+ tlv.value != NULL) {
+ memcpy(reader_rnd_out, tlv.value, ICCE_TAG_LEN_READER_RND);
+ got_rdr = 1;
+ } else if (tlv.tag_number == ICCE_TAG_9F3E_CARD_RND && tlv.value_len == ICCE_TAG_LEN_CARD_RND &&
+ tlv.value != NULL) {
+ memcpy(card_rnd_out, tlv.value, ICCE_TAG_LEN_CARD_RND);
+ if (inner_has_card_rnd_out != NULL) {
+ *inner_has_card_rnd_out = 1;
+ }
+ }
+ pos = (uint16_t)(pos + unit);
+ }
+ return (got_atc && got_rdr) ? 0 : -1;
+}
+
+static int icce_auth_decrypt_73_vehicle_auth_cmd(const uint8_t session_key[16],
+ const uint8_t iv_reader_rnd[ICCE_TAG_LEN_READER_RND],
+ const uint8_t iv_card_rnd[ICCE_TAG_LEN_CARD_RND],
+ const uint8_t *cipher, uint16_t cipher_len,
+ uint8_t card_atc_out[ICCE_TAG_LEN_CARD_ATC],
+ uint8_t reader_rnd_out[ICCE_TAG_LEN_READER_RND],
+ uint8_t card_rnd_out[ICCE_TAG_LEN_CARD_RND],
+ uint8_t *inner_has_card_rnd_out)
+{
+ if (cipher == NULL || cipher_len == 0 || (cipher_len % 16u) != 0u) {
+ return -1;
+ }
+ if (cipher_len > ICCE_TLV_73_CIPHER_BUF_LEN) {
+ return -1;
+ }
+ memcpy(s_icce_auth_73_work, cipher, cipher_len);
+ uint8_t iv_work[16];
+ memcpy(iv_work, iv_reader_rnd, ICCE_TAG_LEN_READER_RND);
+ memcpy(iv_work + ICCE_TAG_LEN_READER_RND, iv_card_rnd, ICCE_TAG_LEN_CARD_RND);
+ mbedtls_aes_context aes;
+ mbedtls_aes_init(&aes);
+ if (mbedtls_aes_setkey_dec(&aes, session_key, 128) != 0) {
+ mbedtls_aes_free(&aes);
+ return -1;
+ }
+ if (mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_DECRYPT, cipher_len, iv_work, s_icce_auth_73_work,
+ s_icce_auth_73_work) != 0) {
+ mbedtls_aes_free(&aes);
+ return -1;
+ }
+ mbedtls_aes_free(&aes);
+ uint16_t plen = icce_iso9797_m2_unpad(s_icce_auth_73_work, cipher_len, s_icce_auth_73_m2_plain,
+ (uint16_t)sizeof(s_icce_auth_73_m2_plain));
+ if (plen == 0) {
+ return -1;
+ }
+ return icce_auth_parse_inner_tlv_auth_cmd_73(s_icce_auth_73_m2_plain, plen, card_atc_out, reader_rnd_out, card_rnd_out,
+ inner_has_card_rnd_out);
+}
+
+/*
+ * 0x73 复合密文域:明文为 ISO9797_M2( TLV(9F36,CardATC) || TLV(9F37,ReaderRnd) ),
+ * AES-128-CBC(SessionKey, SessionIV=ReaderRnd||CardRnd)。
+ * CardATC 的 4 字节取值按大端(高字节在前)填入 TLV(9F36) 的 Value。
+ */
+static int icce_auth_encrypt_73_inner(const uint8_t session_key[16],
+ const uint8_t reader_rnd[ICCE_TAG_LEN_READER_RND],
+ const uint8_t card_rnd[ICCE_TAG_LEN_CARD_RND],
+ const uint8_t card_atc_be[ICCE_TAG_LEN_CARD_ATC],
+ const uint8_t reader_rnd_echo[ICCE_TAG_LEN_READER_RND],
+ uint8_t *cipher_out, uint16_t cipher_cap, uint16_t *cipher_len_out)
+{
+ uint8_t inner[48];
+ uint16_t ilen = 0;
+ uint16_t n;
+
+ n = icce_tlv_build(inner + ilen, (uint16_t)(sizeof(inner) - ilen), ICCE_TAG_9F36_CARD_ATC,
+ card_atc_be, ICCE_TAG_LEN_CARD_ATC);
+ if (n == 0) {
+ return -1;
+ }
+ ilen = (uint16_t)(ilen + n);
+ n = icce_tlv_build(inner + ilen, (uint16_t)(sizeof(inner) - ilen), ICCE_TAG_9F37_READER_RND,
+ reader_rnd_echo, ICCE_TAG_LEN_READER_RND);
+ if (n == 0) {
+ return -1;
+ }
+ ilen = (uint16_t)(ilen + n);
+
+ uint8_t padded[64];
+ uint16_t plen = icce_iso9797_m2_pad(inner, ilen, padded, (uint16_t)sizeof(padded));
+ if (plen == 0 || plen > cipher_cap) {
+ return -1;
+ }
+ printf("padded data >>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+ for (size_t i = 0; i < plen; i++) {
+ printf("%02X ", padded[i]);
+ }
+ printf("\n");
+ printf("plen >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+
+ uint8_t iv_work[16];
+ memcpy(iv_work, reader_rnd, ICCE_TAG_LEN_READER_RND);
+ memcpy(iv_work + ICCE_TAG_LEN_READER_RND, card_rnd, ICCE_TAG_LEN_CARD_RND);
+ mbedtls_aes_context aes;
+ mbedtls_aes_init(&aes);
+ if (mbedtls_aes_setkey_enc(&aes, session_key, 128) != 0) {
+ mbedtls_aes_free(&aes);
+ return -1;
+ }
+ if (mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_ENCRYPT, plen, iv_work, padded, cipher_out) != 0) {
+ mbedtls_aes_free(&aes);
+ return -1;
+ }
+ mbedtls_aes_free(&aes);
+ *cipher_len_out = plen;
+ return 0;
+}
+
+static int icce_auth_digest_sha256(const uint8_t *data, size_t len, uint8_t out32[32])
+{
+ mbedtls_sha256_context ctx;
+ mbedtls_sha256_init(&ctx);
+ if (mbedtls_sha256_starts(&ctx, 0) != 0) {
+ mbedtls_sha256_free(&ctx);
+ return -1;
+ }
+ if (mbedtls_sha256_update(&ctx, data, len) != 0) {
+ mbedtls_sha256_free(&ctx);
+ return -1;
+ }
+ if (mbedtls_sha256_finish(&ctx, out32) != 0) {
+ mbedtls_sha256_free(&ctx);
+ return -1;
+ }
+ mbedtls_sha256_free(&ctx);
+ return 0;
+}
+
+/* 将 g_icce_auth_cache_reader_rnd || g_icce_auth_cache_card_rnd 固化到 g_icce_session_iv_fixed(与整段 body 解密所用 SessionIV 一致) */
+static void icce_auth_session_iv_fixed_sync(void)
+{
+ if (!g_icce_auth_cache_reader_rnd_valid || !g_icce_auth_cache_card_rnd_valid) {
+ g_icce_session_iv_fixed_valid = 0;
+ return;
+ }
+ memcpy(g_icce_session_iv_fixed, g_icce_auth_cache_reader_rnd, ICCE_TAG_LEN_READER_RND);
+ memcpy(g_icce_session_iv_fixed + ICCE_TAG_LEN_READER_RND, g_icce_auth_cache_card_rnd, ICCE_TAG_LEN_CARD_RND);
+ printf("g_icce_session_iv_fixed >>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+ for (size_t i = 0; i < ICCE_TAG_LEN_READER_RND + ICCE_TAG_LEN_CARD_RND; i++) {
+ printf("%02X ", g_icce_session_iv_fixed[i]);
+ }
+ printf("\n");
+ g_icce_session_iv_fixed_valid = 1;
+}
+
+/*
+ * 认证响应 77 的 Value(仅密文字节):先 TLV(9F37, ReaderRnd),再 SHA256(该 TLV 完整字节) → ISO9797_M2 → AES-128-CBC。
+ * AES IV 使用 g_icce_session_iv_fixed(由 icce_auth_session_iv_fixed_sync 填充,勿每次用参数拼接)。
+ */
+static int icce_auth_encrypt_auth77_from_9f37_tlv(const uint8_t session_key[16],
+ const uint8_t reader_rnd[ICCE_TAG_LEN_READER_RND],
+ uint8_t *cipher_out, uint16_t cipher_cap, uint16_t *cipher_len_out)
+{
+ if (!g_icce_session_iv_fixed_valid) {
+ return -1;
+ }
+ uint8_t tlv_9f37[32]={0};
+ uint16_t tlen = icce_tlv_build(tlv_9f37, (uint16_t)sizeof(tlv_9f37), ICCE_TAG_9F37_READER_RND,
+ reader_rnd, ICCE_TAG_LEN_READER_RND);
+ if (tlen == 0) {
+ return -1;
+ }
+
+ printf("tlv_9f37 >>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+ for (size_t i = 0; i < tlen; i++) {
+ printf("%02X ", tlv_9f37[i]);
+ }
+ printf("\n");
+
+ uint8_t hash[ICCE_TAG_LEN_SHA256_DIGEST]={0};
+ if (icce_auth_digest_sha256(tlv_9f37, tlen, hash) != 0) {
+ return -1;
+ }
+ printf("hash >>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+ for (size_t i = 0; i < ICCE_TAG_LEN_SHA256_DIGEST; i++) {
+ printf("%02X ", hash[i]);
+ }
+ printf("\n");
+
+ uint8_t padded[64]={0};
+ uint16_t plen = icce_iso9797_m2_pad(hash, ICCE_TAG_LEN_SHA256_DIGEST, padded, (uint16_t)sizeof(padded));
+ if (plen == 0 || plen > cipher_cap) {
+ return -1;
+ }
+
+ uint8_t iv_work[16]={0};
+ memcpy(iv_work, g_icce_session_iv_fixed, sizeof(iv_work));
+ mbedtls_aes_context aes;
+ mbedtls_aes_init(&aes);
+ if (mbedtls_aes_setkey_enc(&aes, session_key, 128) != 0) {
+ mbedtls_aes_free(&aes);
+ return -1;
+ }
+ if (mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_ENCRYPT, plen, iv_work, padded, cipher_out) != 0) {
+ mbedtls_aes_free(&aes);
+ return -1;
+ }
+ mbedtls_aes_free(&aes);
+ *cipher_len_out = plen;
+ return 0;
+}
+
+/*
+ * SessionKey = CBC 密文最后一个 16 字节块。
+ * DKey=dkey,CardIV=card_iv(与 9F0C 一致),明文为 M2(ReaderRnd||CardRnd||ReaderKeyParameter)。
+ * reader_key_param:9F0C 内容,与 CBC IV 同源字节。
+ */
+static int icce_auth_derive_session_key(const uint8_t dkey[16],
+ const uint8_t card_iv[ICCE_TAG_LEN_READER_KEY_PARAM],
+ const uint8_t reader_rnd[ICCE_TAG_LEN_READER_RND],
+ const uint8_t card_rnd[ICCE_TAG_LEN_CARD_RND],
+ const uint8_t reader_key_param[ICCE_TAG_LEN_READER_KEY_PARAM],
+ uint8_t session_key_out[16])
+{
+ uint8_t plain[ICCE_LEN_SESSION_KEY_PLAIN];
+ uint8_t padded[64];
+ uint8_t cipher[64];
+ uint8_t iv_work[16];
+ memcpy(plain, reader_rnd, ICCE_TAG_LEN_READER_RND);
+ memcpy(plain + ICCE_TAG_LEN_READER_RND, card_rnd, ICCE_TAG_LEN_CARD_RND);
+ memcpy(plain + ICCE_TAG_LEN_READER_RND + ICCE_TAG_LEN_CARD_RND, reader_key_param,
+ ICCE_TAG_LEN_READER_KEY_PARAM);
+ uint16_t plen = icce_iso9797_m2_pad(plain, ICCE_LEN_SESSION_KEY_PLAIN, padded, (uint16_t)sizeof(padded));
+ if (plen == 0 || plen > sizeof(cipher)) {
+ return -1;
+ }
+ memcpy(iv_work, card_iv, sizeof(iv_work));
+ mbedtls_aes_context aes;
+ mbedtls_aes_init(&aes);
+ if (mbedtls_aes_setkey_enc(&aes, dkey, 128) != 0) {
+ mbedtls_aes_free(&aes);
+ return -1;
+ }
+ if (mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_ENCRYPT, plen, iv_work, padded, cipher) != 0) {
+ mbedtls_aes_free(&aes);
+ return -1;
+ }
+ mbedtls_aes_free(&aes);
+ memcpy(session_key_out, cipher + plen - 16u, 16u);
+ return 0;
+}
+
+/*
+ * AT 自测:ZhixingApp initBlueKey GPDPayload 同刻向量(与 ChangAan/icce_session_key_selftest.c 一致),
+ * 不修改运行时 g_icce_* 演示数据,仅打印派生 SessionKey 与金样比对结果。
+ */
+void ble_icce_changan_session_key_zhixing_at_test(void)
+{
+ uint8_t session_key[16];
+ static const uint8_t k_dkey[16] = {
+ 0x70, 0x32, 0x6e, 0x21, 0xea, 0xd7, 0x5c, 0x76,
+ 0xd4, 0x67, 0x42, 0xde, 0x64, 0x4a, 0x2f, 0xc5,
+ };
+ static const uint8_t k_reader_kp[16] = {
+ 0x60, 0x00, 0x10, 0x01, 0x25, 0x05, 0x28, 0x33,
+ 0x00, 0x00, 0x00, 0x69, 0x25, 0x95, 0x14, 0x06,
+ };
+ static const uint8_t k_reader_rnd[8] = {
+ 0x9d, 0x57, 0xcc, 0x53, 0xa4, 0xda, 0xca, 0x84,
+ };
+ static const uint8_t k_card_rnd[8] = {
+ 0xa8, 0xc1, 0xf9, 0x45, 0x37, 0xb9, 0x88, 0x25,
+ };
+ static const uint8_t k_expect_session_key[16] = {
+ 0xb6, 0x33, 0x53, 0x22, 0xf2, 0x15, 0xb8, 0x5d,
+ 0x51, 0x84, 0x59, 0x94, 0xf2, 0xa2, 0x86, 0x2a,
+ };
+
+ if (icce_auth_derive_session_key(k_dkey, k_reader_kp, k_reader_rnd, k_card_rnd, k_reader_kp,
+ session_key) != 0) {
+ ICCE_LOG("[ICCE] AT Zhixing session key derive failed");
+ return;
+ }
+ ICCE_LOG("[ICCE] AT Zhixing GPDPayload session key selftest (dKey/9F37/9F3E/9F0C from App log):");
+ icce_hex_dump_log("SessionKey", session_key, 16);
+ if (memcmp(session_key, k_expect_session_key, 16) == 0) {
+ ICCE_LOG("[ICCE] AT session key golden match PASS (b6335322f215b85d51845994f2a2862a)");
+ } else {
+ ICCE_LOG("[ICCE] AT session key golden mismatch");
+ }
+}
+
+/* 9F3E CardRnd:钥匙侧本地 8 字节,与车侧 9F37 无关;实车可改为 SE/TRNG */
+static void icce_auth_generate_local_card_rnd(uint8_t card_rnd[ICCE_TAG_LEN_CARD_RND])
+{
+ uint32_t s = g_icce_auth_card_rnd_salt++;
+ uint8_t i;
+ for (i = 0; i < ICCE_TAG_LEN_CARD_RND; i++) {
+ card_rnd[i] = (uint8_t)(g_icce_auth_card_seid[i % ICCE_TAG_LEN_CARD_SEID] ^
+ g_icce_auth_card_id[i] ^ (uint8_t)(s >> ((i % 4u) * 8u)) ^
+ (uint8_t)((g_icce_auth_card_atc_counter >> (i * 4u)) & 0xFFu) ^ (uint8_t)(0x5Au + i));
+ }
+}
+
+/*
+ * 认证响应里 TLV(9F37) 的 8 字节 = 车侧 ReaderRnd,须与取处理数据阶段车端下发的 9F37 一致(见表 9F37/0x08),
+ * 不可本端随机生成。优先 g_icce_auth_cache_reader_rnd(取数指令解析写入);若无缓存且当前帧 scan 含 9F37 则用之。
+ * @return 0 已填入;非 0 无可用 ReaderRnd,不应组 77 认证响应。
+ */
+static int icce_auth_fill_reader_rnd_resp_for_auth(uint8_t out[ICCE_TAG_LEN_READER_RND],
+ const icce_auth_tlv_scan_t *scan_opt)
+{
+ if (g_icce_auth_cache_reader_rnd_valid) {
+ memcpy(out, g_icce_auth_cache_reader_rnd, ICCE_TAG_LEN_READER_RND);
+ return 0;
+ }
+ if (scan_opt != NULL && scan_opt->has_reader_rnd) {
+ memcpy(out, scan_opt->reader_rnd, ICCE_TAG_LEN_READER_RND);
+ return 0;
+ }
+ ICCE_LOG("[ICCE AUTH] 9F37 ReaderRnd missing: need GET-process-data cache or 9F37 in current cmd");
+ memset(out, 0, ICCE_TAG_LEN_READER_RND);
+ return -1;
+}
+
+static void icce_auth_ensure_session_card_rnd(void)
+{
+ if (g_icce_auth_cache_card_rnd_valid) {
+ return;
+ }
+#if !defined(ICCE_NO_DEBUG_AES_KEY)
+ memcpy(g_icce_auth_cache_card_rnd, g_icce_auth_test_card_rnd, ICCE_TAG_LEN_CARD_RND);
+#else
+ icce_auth_generate_local_card_rnd(g_icce_auth_cache_card_rnd);
+#endif
+ g_icce_auth_cache_card_rnd_valid = 1;
+ if (g_icce_auth_cache_reader_rnd_valid) {
+ icce_auth_session_iv_fixed_sync();
+ }
+}
+
+/*
+ * 组 ICCE 线帧:SOF(5A) + Length(2,BE) + Control + FSN + message_id + command_id + payload TLV + CRC16(CCITT)。
+ * @return 整帧字节数(含 CRC),0 表示失败(cap 不足等)
+ *
+ * 与「正确」联调帧格式对照(例:220 字节 = 1+2+215+2,Length=0x00D7=215):
+ * 5A | 00 D7 | 00 | 00 | 01 | 01 | payload… | CRC16 (完整单帧时 FSN 固定 0x00)
+ * payload = Tag00(Status) + Tag01(R-APDU),其中 01 的 Value = TLV(77)||SW1SW2,
+ * 例:00 01 00 | 01 81 CD | 77 81 C8 [200B inner] | 90 00 (inner 为 5A/9F3B/9F3E/9F05/73…)
+ * 当前 icce_changan_build_get_process_data_response_payload 即按此拼装;icce_pack_vehicle_icce_frame 再封成线帧。
+ * 与参考 hex 逐字节一致需相同:车侧 9F37/9F0C、本端 CardSEID/CardID/9F3E(CardRnd)/9F05、ATC、SessionKey、密文、CRC。
+ * 注意:CardRnd 参与 SessionKey 派生(ReaderRnd||CardRnd||ReaderKeyParam),故「仅 CardSEID 不同其余全同」在算法上不成立;
+ * 换 SEID 而 CardRnd/车侧随机数不变时,9F3E 明文字节、73 密文、尾 CRC 仍会变化。
+ */
+static uint16_t icce_pack_vehicle_icce_frame(uint8_t *frame, uint16_t cap,
+ uint8_t is_request, uint8_t is_async, uint8_t is_encrypted,
+ uint8_t message_id, uint8_t command_id,
+ const uint8_t *payload_tlvs, uint16_t payload_len)
+{
+ if (frame == NULL || cap < 12u) {
+ return 0;
+ }
+ uint16_t off = 0;
+ frame[off++] = ICCE_FRAME_SOF;
+ uint16_t len_pos = off;
+ off += 2;
+ uint8_t control = ICCE_CTRL_FRAGMENT_FULL;
+ if (is_async) {
+ control |= ICCE_CTRL_ASYNC_BIT;
+ }
+ if (is_encrypted) {
+ control |= ICCE_CTRL_ENCRYPT_BIT;
+ }
+ if (is_request) {
+ control |= ICCE_CTRL_REQUEST_BIT;
+ }
+ frame[off++] = control;
+ /* 本函数只组 FRAGMENT_FULL;FSN 固定 0(多帧分片发送未实现时勿用全局自增) */
+ frame[off++] = ICCE_FSN_FULL_SINGLE_FRAME;
+ frame[off++] = message_id;
+ frame[off++] = command_id;
+ if (payload_tlvs != NULL && payload_len > 0) {
+ if ((uint32_t)off + payload_len + 2u > cap) {
+ return 0;
+ }
+ memcpy(frame + off, payload_tlvs, payload_len);
+ off = (uint16_t)(off + payload_len);
+ }
+ /* Length = Control..payload 末(不含 CRC 2 字节) */
+ uint16_t len_field = (uint16_t)(off - 3);
+ (void)icce_put_be16(&frame[len_pos], len_field);
+ if ((uint32_t)off + 2u > cap) {
+ return 0;
+ }
+ uint16_t crc = icce_crc16_ccitt(frame, off);
+ off += icce_put_be16(frame + off, crc);
+ return off;
+}
+
+/* 组帧并下发:payload 为 body 内 TLV 段 */
+static uint8_t icce_send_vehicle_icce_frame(uint8_t client_id, uint16_t conn_id,
+ uint8_t is_request, uint8_t is_async, uint8_t is_encrypted,
+ uint8_t message_id, uint8_t command_id,
+ const uint8_t *payload_tlvs, uint16_t payload_len)
+{
+ uint8_t frame[ICCE_MAX_TX_FRAME_LEN] = {0};
+ uint16_t flen = icce_pack_vehicle_icce_frame(frame, (uint16_t)sizeof(frame),
+ is_request, is_async, is_encrypted, message_id, command_id, payload_tlvs, payload_len);
+ if (flen == 0) {
+ return 1;
+ }
+ return ble_icce_send_icce_frame_raw(client_id, conn_id, frame, flen);
+}
+
+/*
+ * icce_changan_build_get_process_data_response_payload
+ *
+ * 拼装长安「取处理数据」同步响应的 body payload(仅 TLV 段,不含 ICCE 帧头 SOF/Length/CRC)。
+ * 方向:手机 → 车;对应规范「取处理数据响应」。
+ *
+ * 顶层 TLV 顺序(与车端请求「01 内封整条 APDU」对称):
+ * Tag 00 Status 1 字节,成功一般为 0x00
+ * Tag 01 APDU 响应 R-APDU = 完整 TLV(77 响应复合数据域) || SW1||SW2(如 90 00),不再单独再发顶层 Tag77
+ * 其中 Tag77 的 Value 内顺序为:
+ * 5A CardSEID(8)
+ * 9F3B CardID(16)
+ * 9F3E CardRnd(8),来自本端 card_rnd_for_resp
+ * 9F05 Card Info1(联调且未定义 ICCE_NO_DEBUG_AES_KEY 时编入)
+ * 73 复合密文:ISO9797_M2(TLV(9F36,CardATC)||TLV(9F37,ReaderRnd)) 再 AES-128-CBC,
+ * Key=SessionKey,IV=ReaderRnd||CardRnd;仅当 g_icce_session_key_valid 且加密成功时编入
+ *
+ * @param pl 输出缓冲区
+ * @param pl_cap pl 可用长度(字节)
+ * @param out_len 成功时写入 payload 总长度
+ * @param reader_rnd_echo 车侧 9F37(8B),与密文内 9F37 及 SessionIV 一致
+ * @param card_rnd_for_resp 本端 9F3E CardRnd(8B)
+ *
+ * @return 0 成功;1 参数非法、inner/pl TLV 组包失败或长度越界
+ */
+static uint8_t icce_changan_build_get_process_data_response_payload(uint8_t *pl, uint16_t pl_cap, uint16_t *out_len,
+ const uint8_t reader_rnd_echo[ICCE_TAG_LEN_READER_RND],
+ const uint8_t card_rnd_for_resp[ICCE_TAG_LEN_CARD_RND])
+{
+ enum { GET_DATA_INNER_CAP = 384, GET_DATA_BUF77_CAP = 400, GET_DATA_RAPDU_CAP = 420 };
+
+ uint8_t *inner = NULL;
+ uint8_t *buf77 = NULL;
+ uint8_t *r_apdu = NULL;
+ uint8_t ret = 1;
+
+ if (pl == NULL || out_len == NULL || pl_cap == 0) {
+ ICCE_LOG("[ICCE GET-DATA build] fail: bad pl/out_len/cap");
+ return 1;
+ }
+ *out_len = 0;
+ ICCE_LOG("[ICCE GET-DATA build] start (pl_cap=%u)", (unsigned)pl_cap);
+
+ inner = (uint8_t *)malloc(GET_DATA_INNER_CAP);
+ buf77 = (uint8_t *)malloc(GET_DATA_BUF77_CAP);
+ r_apdu = (uint8_t *)malloc(GET_DATA_RAPDU_CAP);
+ if (inner == NULL || buf77 == NULL || r_apdu == NULL) {
+ ICCE_LOG("[ICCE GET-DATA build] fail: malloc inner/buf77/r_apdu");
+ goto cleanup;
+ }
+ (void)memset(inner, 0, (size_t)GET_DATA_INNER_CAP);
+ (void)memset(buf77, 0, (size_t)GET_DATA_BUF77_CAP);
+ (void)memset(r_apdu, 0, (size_t)GET_DATA_RAPDU_CAP);
+
+ uint8_t status_ok = 0x00;
+ uint16_t in = 0;
+ uint32_t atc = ++g_icce_auth_card_atc_counter;
+ uint8_t atc_be[ICCE_TAG_LEN_CARD_ATC];
+ /* Tag 9F36 CardATC:4 字节大端(高字节在前),供 Tag73 内层 TLV 与 ISO9797_M2 明文使用 */
+ atc_be[0] = (uint8_t)((atc >> 24) & 0xFF);
+ atc_be[1] = (uint8_t)((atc >> 16) & 0xFF);
+ atc_be[2] = (uint8_t)((atc >> 8) & 0xFF);
+ atc_be[3] = (uint8_t)(atc & 0xFF);
+
+ uint8_t has_73 = 0;
+ uint16_t n;
+ n = icce_tlv_build(inner + in, (uint16_t)(GET_DATA_INNER_CAP - in), ICCE_TAG_CARD_SEID,
+ g_icce_auth_card_seid, ICCE_TAG_LEN_CARD_SEID);
+ if (n == 0) {
+ ICCE_LOG("[ICCE GET-DATA build] fail: tlv 5A CardSEID");
+ goto cleanup;
+ }
+ in = (uint16_t)(in + n);
+ n = icce_tlv_build(inner + in, (uint16_t)(GET_DATA_INNER_CAP - in), ICCE_TAG_9F3B_CARD_ID,
+ g_icce_auth_card_id, ICCE_TAG_LEN_CARD_ID);
+ if (n == 0) {
+ ICCE_LOG("[ICCE GET-DATA build] fail: tlv 9F3B CardID");
+ goto cleanup;
+ }
+ in = (uint16_t)(in + n);
+ n = icce_tlv_build(inner + in, (uint16_t)(GET_DATA_INNER_CAP - in), ICCE_TAG_9F3E_CARD_RND,
+ card_rnd_for_resp, ICCE_TAG_LEN_CARD_RND);
+ if (n == 0) {
+ ICCE_LOG("[ICCE GET-DATA build] fail: tlv 9F3E CardRnd");
+ goto cleanup;
+ }
+ in = (uint16_t)(in + n);
+
+ n = icce_tlv_build(inner + in, (uint16_t)(GET_DATA_INNER_CAP - in), ICCE_TAG_9F05_CARD_INFO1,
+ g_icce_auth_card_info1, ICCE_CARD_INFO1_TEST_LEN);
+ if (n == 0) {
+ ICCE_LOG("[ICCE GET-DATA build] fail: tlv 9F05 CardInfo1");
+ goto cleanup;
+ }
+ in = (uint16_t)(in + n);
+
+ if (g_icce_session_key_valid) {
+ uint8_t card_auth_cipher[32];
+ uint16_t cilen = 0;
+ if (icce_auth_encrypt_73_inner(g_icce_session_key, reader_rnd_echo,
+ card_rnd_for_resp, atc_be, reader_rnd_echo,
+ card_auth_cipher, (uint16_t)sizeof(card_auth_cipher), &cilen) == 0) {
+ n = icce_tlv_build(inner + in, (uint16_t)(GET_DATA_INNER_CAP - in), ICCE_TAG_ICCE_VAR_CIPHER_TEMPLATE,
+ card_auth_cipher, cilen);
+ if (n != 0) {
+ in = (uint16_t)(in + n);
+ has_73 = 1;
+ }
+ } else {
+ ICCE_LOG("[ICCE GET-DATA build] warn: encrypt 73 inner fail (session_key ok but cipher err)");
+ }
+ } else {
+ ICCE_LOG("[ICCE GET-DATA build] warn: no SessionKey (tag 73 omitted)");
+ }
+
+ n = icce_tlv_build(buf77, GET_DATA_BUF77_CAP, ICCE_TAG_RESP_TEMPLATE, inner, in);
+ if (n == 0) {
+ ICCE_LOG("[ICCE GET-DATA build] fail: tlv 77 template (inner_len=%u)", (unsigned)in);
+ goto cleanup;
+ }
+ {
+ uint32_t rlen = (uint32_t)n + 2u;
+ if (rlen > GET_DATA_RAPDU_CAP) {
+ ICCE_LOG("[ICCE GET-DATA build] fail: R-APDU overflow");
+ goto cleanup;
+ }
+ memcpy(r_apdu, buf77, n);
+ r_apdu[n] = 0x90;
+ r_apdu[n + 1u] = 0x00;
+
+ uint16_t p = 0;
+ uint16_t n0 = icce_tlv_build(pl + p, (uint16_t)(pl_cap - p), ICCE_TAG_STATUS, &status_ok, 1);
+ if (n0 == 0) {
+ ICCE_LOG("[ICCE GET-DATA build] fail: tlv 00 Status");
+ goto cleanup;
+ }
+ p = (uint16_t)(p + n0);
+ n0 = icce_tlv_build(pl + p, (uint16_t)(pl_cap - p), ICCE_TAG_MSG_CMD_ID_1, r_apdu, (uint16_t)rlen);
+ if (n0 == 0) {
+ ICCE_LOG("[ICCE GET-DATA build] fail: tlv 01 R-APDU (77+SW, len=%u)", (unsigned)rlen);
+ goto cleanup;
+ }
+ p = (uint16_t)(p + n0);
+ if (p > pl_cap) {
+ ICCE_LOG("[ICCE GET-DATA build] fail: out_len %u > pl_cap %u", (unsigned)p, (unsigned)pl_cap);
+ goto cleanup;
+ }
+ *out_len = p;
+ ICCE_LOG("[ICCE GET-DATA build] ok payload=%u B tlv77=%u B inner(77 value)=%u B ATC=%u tag73=%s session_key=%s",
+ (unsigned)p, (unsigned)n, (unsigned)in, (unsigned)atc, has_73 ? "yes" : "no",
+ g_icce_session_key_valid ? "valid" : "invalid");
+ icce_hex_dump_log("GET-DATA-PL", pl, p);
+ ret = 0;
+ }
+
+cleanup:
+ if (inner != NULL) {
+ free(inner);
+ }
+ if (buf77 != NULL) {
+ free(buf77);
+ }
+ if (r_apdu != NULL) {
+ free(r_apdu);
+ }
+ return ret;
+}
+
+static uint8_t icce_changan_send_get_process_data_response(uint8_t client_id, uint16_t conn_id,
+ const uint8_t reader_rnd_echo[ICCE_TAG_LEN_READER_RND],
+ const uint8_t card_rnd_for_resp[ICCE_TAG_LEN_CARD_RND])
+{
+ uint8_t pl[ICCE_MAX_TX_FRAME_LEN];
+ uint16_t pl_len = 0;
+ if (icce_changan_build_get_process_data_response_payload(pl, (uint16_t)sizeof(pl), &pl_len, reader_rnd_echo,
+ card_rnd_for_resp) != 0) {
+ return 1;
+ }
+ ICCE_LOG("[ICCE RESP] ---- ChangAn 取处理数据回应 body TLV %u B ----", (unsigned)pl_len);
+
+ uint8_t icce_frame[ICCE_MAX_TX_FRAME_LEN];
+ uint16_t icce_len = icce_pack_vehicle_icce_frame(icce_frame, (uint16_t)sizeof(icce_frame),
+ 0 /* response */, 0 /* sync */, 0 /* not encrypted */,
+ ICCE_MSG_AUTH_DATA, ICCE_CMD_AUTH_DATA, pl, pl_len);
+ if (icce_len == 0) {
+ ICCE_LOG("[ICCE RESP] 取处理数据: pack ICCE frame fail");
+ return 1;
+ }
+ ICCE_LOG("[ICCE RESP] ---- 校验用:GATT 下发 len=%u(以 5A 起始,无 cmd 前缀)----", (unsigned)icce_len);
+ icce_hex_dump_log("GET-DATA-WIRE", icce_frame, icce_len);
+
+ uint8_t send_ret = ble_icce_send_icce_frame_raw(client_id, conn_id, icce_frame, icce_len);
+ if (send_ret != 0) {
+ ICCE_LOG("[ICCE RESP] 取处理数据回应 send failed: ret=%u (client_id=%u conn_id=%u)",
+ (unsigned)send_ret, (unsigned)client_id, (unsigned)conn_id);
+ }
+ return send_ret;
+}
+
+/*
+ * 认证响应(钥匙→车):00(Status=成功 0x00) + 01(R-APDU);R-APDU = TLV(77) || SW1SW2(9000)。
+ * Tag77 的 Value = 密文(先 TLV(9F37,ReaderRnd) 再 HASH/M2/AES;密文外不再套 9F37),不含 73/9F31/9F0A。
+ * SessionKey:优先 g_icce_session_key;否则 DKey+缓存 9F0C/9F37 与当前 9F3E 派生。
+ * ICCE 帧打包 is_encrypted=0,与取处理数据回应相同。
+ */
+static uint8_t icce_changan_build_auth_response_payload(uint8_t *pl, uint16_t pl_cap, uint16_t *out_len,
+ const uint8_t reader_rnd_resp[ICCE_TAG_LEN_READER_RND],
+ const uint8_t vehicle_card_rnd[ICCE_TAG_LEN_CARD_RND])
+{
+ if (pl == NULL || out_len == NULL || pl_cap == 0) {
+ return 1;
+ }
+ *out_len = 0;
+
+ uint8_t session_key[16];
+ if (g_icce_session_key_valid) {
+ memcpy(session_key, g_icce_session_key, sizeof(session_key));
+ icce_auth_session_iv_fixed_sync();
+ } else if (g_icce_dkey_valid && g_icce_auth_cache_key_param_valid && g_icce_auth_cache_reader_rnd_valid) {
+ memcpy(g_icce_auth_cache_card_rnd, vehicle_card_rnd, ICCE_TAG_LEN_CARD_RND);
+ g_icce_auth_cache_card_rnd_valid = 1;
+ if (icce_auth_derive_session_key(g_icce_dkey, g_icce_auth_cache_key_param, g_icce_auth_cache_reader_rnd,
+ vehicle_card_rnd, g_icce_auth_cache_key_param, session_key) != 0) {
+ ICCE_LOG("[ICCE AUTH build] fail: derive SessionKey");
+ return 1;
+ }
+ icce_auth_session_iv_fixed_sync();
+ } else {
+ ICCE_LOG("[ICCE AUTH build] fail: no SessionKey (need GET-data cache or derived session)");
+ return 1;
+ }
+
+ if (!g_icce_session_iv_fixed_valid) {
+ ICCE_LOG("[ICCE AUTH build] fail: SessionIV not fixed (cache 9F37+9F3E invalid)");
+ return 1;
+ }
+
+ /* ICCE Status TLV:系统类 0x00=成功,0x01=未知错误(规范表 01—0F) */
+ uint8_t status_ok = 0x00;
+ const size_t heap_len =
+ (size_t)ICCE_AUTH_RESP_HEAP_CIPHER_CAP + ICCE_AUTH_RESP_HEAP_BUF77_CAP + ICCE_AUTH_RESP_HEAP_RAPDU_CAP;
+ uint8_t *heap = (uint8_t *)malloc(heap_len);
+ if (heap == NULL) {
+ ICCE_LOG("[ICCE AUTH build] fail: malloc %u", (unsigned)heap_len);
+ return 1;
+ }
+ memset(heap, 0, heap_len);
+ uint8_t *auth77_cipher = heap;
+ uint8_t *buf77 = heap + ICCE_AUTH_RESP_HEAP_CIPHER_CAP;
+ uint8_t *r_apdu = buf77 + ICCE_AUTH_RESP_HEAP_BUF77_CAP;
+
+ uint8_t rc = 1;
+ uint16_t n = 0;
+ uint16_t cipher_len = 0;
+
+ if (icce_auth_encrypt_auth77_from_9f37_tlv(session_key, reader_rnd_resp, auth77_cipher,
+ (uint16_t)ICCE_AUTH_RESP_HEAP_CIPHER_CAP, &cipher_len) != 0) {
+ ICCE_LOG("[ICCE AUTH build] fail: encrypt 77 value (TLV 9F37→SHA256→M2→AES)");
+ goto auth_resp_build_out;
+ }
+
+ n = icce_tlv_build(buf77, (uint16_t)ICCE_AUTH_RESP_HEAP_BUF77_CAP, ICCE_TAG_RESP_TEMPLATE, auth77_cipher,
+ cipher_len);
+ if (n == 0) {
+ ICCE_LOG("[ICCE AUTH build] fail: tlv 77");
+ goto auth_resp_build_out;
+ }
+
+ {
+ uint32_t rlen = (uint32_t)n + 2u;
+ if (rlen > ICCE_AUTH_RESP_HEAP_RAPDU_CAP) {
+ goto auth_resp_build_out;
+ }
+ memcpy(r_apdu, buf77, n);
+ r_apdu[n] = 0x90;
+ r_apdu[n + 1u] = 0x00;
+
+ uint16_t p = 0;
+ uint16_t n0 = icce_tlv_build(pl + p, (uint16_t)(pl_cap - p), ICCE_TAG_STATUS, &status_ok, 1);
+ if (n0 == 0) {
+ goto auth_resp_build_out;
+ }
+ p = (uint16_t)(p + n0);
+ n0 = icce_tlv_build(pl + p, (uint16_t)(pl_cap - p), ICCE_TAG_MSG_CMD_ID_1, r_apdu, (uint16_t)rlen);
+ if (n0 == 0) {
+ goto auth_resp_build_out;
+ }
+ p = (uint16_t)(p + n0);
+ if (p > pl_cap) {
+ goto auth_resp_build_out;
+ }
+ *out_len = p;
+ ICCE_LOG("[ICCE AUTH build] ok payload=%u B (77 cipher=%u B)", (unsigned)p, (unsigned)cipher_len);
+ rc = 0;
+ }
+
+auth_resp_build_out:
+ free(heap);
+ return rc;
+}
+
+static uint8_t icce_changan_send_auth_response(uint8_t client_id, uint16_t conn_id,
+ const uint8_t reader_rnd_resp[ICCE_TAG_LEN_READER_RND],
+ const uint8_t vehicle_card_rnd[ICCE_TAG_LEN_CARD_RND])
+{
+ uint8_t pl[ICCE_MAX_TX_FRAME_LEN];
+ uint16_t pl_len = 0;
+ if (icce_changan_build_auth_response_payload(pl, (uint16_t)sizeof(pl), &pl_len, reader_rnd_resp,
+ vehicle_card_rnd) != 0) {
+ return 1;
+ }
+ ICCE_LOG("[ICCE RESP] ---- ChangAn 认证响应 body TLV %u B ----", (unsigned)pl_len);
+
+ uint8_t icce_frame[ICCE_MAX_TX_FRAME_LEN];
+ uint16_t icce_len = icce_pack_vehicle_icce_frame(icce_frame, (uint16_t)sizeof(icce_frame),
+ 0, 0, 0, ICCE_MSG_AUTH_DATA, ICCE_CMD_AUTH_DATA, pl, pl_len);
+ if (icce_len == 0) {
+ ICCE_LOG("[ICCE RESP] 认证响应: pack ICCE frame fail");
+ return 1;
+ }
+ icce_hex_dump_log("AUTH-WIRE", icce_frame, icce_len);
+
+ uint8_t send_ret = ble_icce_send_icce_frame_raw(client_id, conn_id, icce_frame, icce_len);
+ if (send_ret != 0) {
+ ICCE_LOG("[ICCE RESP] 认证响应 send failed: ret=%u(若串口见 send_icce_frame_raw NOT_READY/svc=nil:"
+ "ICCE GATT 未 discovery 或 ctrl 句柄无效,与 payload Tag00 成功位无关)",
+ (unsigned)send_ret);
+ }
+ return send_ret;
+}
+
+/*
+ * 取数据成功后的「第二条指令」:不扫 TLV、不判 9F36/9F3E;用取数据阶段已缓存的本端 9F3E(CardRnd) 作认证响应 IV 半段。
+ * @return 1 已按本路径处理并清期待标志;0 未启用或无法处理
+ */
+static int icce_changan_handle_post_getdata_auth_sync(uint8_t client_id, uint16_t conn_id,
+ const icce_frame_body_t *frame_body)
+{
+ if (!g_icce_auth_expect_post_getdata_auth) {
+ return 0;
+ }
+ (void)frame_body;
+ g_icce_auth_expect_post_getdata_auth = 0;
+ if (!g_icce_auth_cache_card_rnd_valid) {
+ ICCE_LOG("[ICCE AUTH] post-GETDATA: second cmd but no cached CardRnd, cannot build auth IV");
+ return 1;
+ }
+ uint8_t reader_rnd_resp[ICCE_TAG_LEN_READER_RND];
+ if (icce_auth_fill_reader_rnd_resp_for_auth(reader_rnd_resp, NULL) != 0) {
+ return 1;
+ }
+ ICCE_LOG("[ICCE AUTH] post-GETDATA: second cmd → auth resp (no tag parse), IV CardRnd=cached 9F3E");
+ (void)icce_changan_send_auth_response(client_id, conn_id, reader_rnd_resp, g_icce_auth_cache_card_rnd);
+ return 1;
+}
+
+/*
+ * 车→机认证指令:已解析到 9F36+9F3E 且非取处理数据;9F37 用车侧取数阶段缓存或本帧 9F37,按规范组 77(仅密文 9F37) 并下发。
+ * @return 1 已按认证路径处理;0 非认证指令
+ */
+static int icce_changan_handle_auth_command_sync(uint8_t client_id, uint16_t conn_id,
+ const icce_frame_body_t *frame_body, const icce_auth_tlv_scan_t *scan_opt)
+{
+ if (frame_body == NULL || frame_body->payload_data == NULL) {
+ return 0;
+ }
+
+ icce_auth_tlv_scan_t scan_local;
+ const icce_auth_tlv_scan_t *scan;
+ if (scan_opt != NULL) {
+ scan = scan_opt;
+ } else {
+ icce_auth_tlv_scan_reset(&scan_local);
+ icce_auth_scan_payload(frame_body->payload_data, frame_body->payload_len, &scan_local);
+ scan = &scan_local;
+ }
+
+ if (!icce_changan_is_auth_command(scan)) {
+ return 0;
+ }
+
+ ICCE_LOG("[ICCE AUTH] vehicle auth cmd (9F36+9F3E), not GET-data");
+ icce_hex_dump_log("AUTH rx card_atc", scan->card_atc, ICCE_TAG_LEN_CARD_ATC);
+ icce_hex_dump_log("AUTH rx card_rnd 9F3E", scan->card_rnd, ICCE_TAG_LEN_CARD_RND);
+
+ uint8_t reader_rnd_resp[ICCE_TAG_LEN_READER_RND];
+ if (icce_auth_fill_reader_rnd_resp_for_auth(reader_rnd_resp, scan) != 0) {
+ return 1;
+ }
+
+ (void)icce_changan_send_auth_response(client_id, conn_id, reader_rnd_resp, scan->card_rnd);
+ return 1;
+}
+
+/*
+ * 车→机「取处理数据」同步回应路径(msg/cmd=0x01/0x01,TLV 含 9F1E ReaderID + 9F37 ReaderRnd + 9F0C ReaderKeyParam)。
+ *
+ * 数据流概要:
+ * - 从 scan 取车侧:9F37 ReaderRnd(8B)、9F0C ReaderKeyParam(16B,作密钥分散因子/会话相关输入)。
+ * - 卡端随机数:本端维护 9F3E CardRnd(8B),icce_auth_ensure_session_card_rnd() 保证已生成并写入 g_icce_auth_cache_card_rnd;
+ * 后续整 body 解密时 SessionIV = ReaderRnd‖CardRnd(各 8B 拼成 16B)。
+ * - SessionKey:主密钥 DKey(g_icce_dkey)与 ReaderKeyParam、ReaderRnd、CardRnd 等按 icce_auth_derive_session_key 派生 16B;
+ * 成功则写入 g_icce_session_key 并 icce_auth_session_iv_fixed_sync();派生失败则清会话密钥/固定 IV 有效位并直接返回(不下发取数据应答,避免无 SessionKey 仍置位「已应答」);不得用 SessionKey 覆盖 g_icce_dkey。
+ * - 下发取数据回应帧:将车端 ReaderRnd 与本端 CardRnd 填入规范 TLV;发送成功则记录「上次已应答」并置位期待「取数后第二条认证」。
+ *
+ * @return 1 已按取数据路径处理(含重复 ReaderRnd+9F0C 跳过下发);0 非取数据指令。
+ */
+static int icce_changan_handle_get_process_data_sync(uint8_t client_id, uint16_t conn_id,
+ const icce_frame_body_t *frame_body, const icce_auth_tlv_scan_t *scan_opt)
+{
+ if (frame_body == NULL || frame_body->payload_data == NULL) {
+ return 0;
+ }
+
+ /* 认证域 TLV 扫描:scan_opt 非空则与上层共用一次 icce_auth_scan_payload 结果 */
+ icce_auth_tlv_scan_t scan_local;
+ const icce_auth_tlv_scan_t *scan;
+ if (scan_opt != NULL) {
+ scan = scan_opt;
+ } else {
+ icce_auth_tlv_scan_reset(&scan_local);
+ icce_auth_scan_payload(frame_body->payload_data, frame_body->payload_len, &scan_local);
+ scan = &scan_local;
+ }
+
+ if (!icce_changan_is_get_process_data_cmd(scan)) {
+ return 0;
+ }
+
+ /* 缓存车侧 9F0C、9F37,供派生 SessionKey 及后续流程 */
+ memcpy(g_icce_auth_cache_key_param, scan->reader_key_param, ICCE_TAG_LEN_READER_KEY_PARAM);
+ g_icce_auth_cache_key_param_valid = 1;
+ memcpy(g_icce_auth_cache_reader_rnd, scan->reader_rnd, ICCE_TAG_LEN_READER_RND);
+ g_icce_auth_cache_reader_rnd_valid = 1;
+
+ /* 与上次已成功应答的 ReaderRnd+9F0C 完全相同则不再重复下发(仍视为已处理) */
+ if (g_icce_auth_last_ack_valid &&
+ memcmp(g_icce_auth_cache_reader_rnd, g_icce_auth_last_ack_reader_rnd, ICCE_TAG_LEN_READER_RND) == 0 &&
+ memcmp(g_icce_auth_cache_key_param, g_icce_auth_last_ack_reader_kp, ICCE_TAG_LEN_READER_KEY_PARAM) == 0) {
+ ICCE_LOG("ChangAn GET-data: duplicate ReaderRnd+9F0C, skip response");
+ return 1;
+ }
+
+ /* 回应里带回的车端随机数副本(与 g_icce_auth_cache_reader_rnd 一致) */
+ uint8_t reader_rnd_use[ICCE_TAG_LEN_READER_RND];
+ memcpy(reader_rnd_use, g_icce_auth_cache_reader_rnd, ICCE_TAG_LEN_READER_RND);
+
+ /* 卡端随机数 CardRnd(9F3E):本端生成,用于 SessionKey 派生与会话 IV 半段 */
+ icce_auth_ensure_session_card_rnd();
+ const uint8_t *card_rnd = g_icce_auth_cache_card_rnd;
+
+ {
+ uint8_t dkey[16];
+ memcpy(dkey, g_icce_dkey, sizeof(dkey));
+ uint8_t session_key[16];
+ /* SessionKey = f(DKey, ReaderKeyParam, ReaderRnd, CardRnd, …),见 icce_auth_derive_session_key */
+ if (icce_auth_derive_session_key(dkey, g_icce_auth_cache_key_param,
+ g_icce_auth_cache_reader_rnd, card_rnd, g_icce_auth_cache_key_param, session_key) != 0) {
+ ICCE_LOG("ChangAn GET-data: derive session key fail");
+ g_icce_session_key_valid = 0;
+ g_icce_session_iv_fixed_valid = 0;
+ return 1;
+ }
+ memcpy(g_icce_session_key, session_key, sizeof(g_icce_session_key));
+ g_icce_session_key_valid = 1;
+ icce_auth_session_iv_fixed_sync();
+ ICCE_LOG("[ICCE] SessionKey (AES-128, last CBC block) derived for GET-data:");
+ icce_hex_dump_log("SessionKey", session_key, 16);
+ }
+
+ {
+ /* 组包并发送「取处理数据」应答(内含 ReaderRnd 与 CardRnd 等按表字段) */
+ uint8_t send_ret = icce_changan_send_get_process_data_response(client_id, conn_id, reader_rnd_use,
+ g_icce_auth_cache_card_rnd);
+ if (send_ret == 0) {
+ memcpy(g_icce_auth_last_ack_reader_rnd, g_icce_auth_cache_reader_rnd, ICCE_TAG_LEN_READER_RND);
+ memcpy(g_icce_auth_last_ack_reader_kp, g_icce_auth_cache_key_param, ICCE_TAG_LEN_READER_KEY_PARAM);
+ g_icce_auth_last_ack_valid = 1;
+ /* 下一条 0x01/0x01 可走「取数后第二条认证」捷径(icce_changan_handle_post_getdata_auth_sync) */
+ g_icce_auth_expect_post_getdata_auth = 1;
+ }
+ }
+ return 1;
+}
+
+/* 落盘 v1:魔数 + 版本 + bd_addr(存车端 BLE)+ card_seid + card_id + card_info1;文件名由车辆 id 区分 */
+#define BLE_ICCE_AUTH_CARD_FILE_MAGIC0 'I'
+#define BLE_ICCE_AUTH_CARD_FILE_MAGIC1 'C'
+#define BLE_ICCE_AUTH_CARD_FILE_MAGIC2 'A'
+#define BLE_ICCE_AUTH_CARD_FILE_MAGIC3 '1'
+#define BLE_ICCE_AUTH_CARD_FILE_VER 1u
+
+static int ble_icce_changan_sanitize_vehicle_car_id_for_path(const char *car_id, char *out, size_t out_cap)
+{
+ size_t j = 0;
+
+ if (car_id == NULL || out == NULL || out_cap < 2U) {
+ return -1;
+ }
+ for (size_t i = 0; car_id[i] != '\0' && j + 1U < out_cap; i++) {
+ char c = car_id[i];
+
+ if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c == '-') {
+ out[j++] = c;
+ }
+ }
+ out[j] = '\0';
+ return (j > 0U) ? 0 : -1;
+}
+
+static int ble_icce_changan_auth_card_identity_build_path(char *path, size_t path_cap, const char *car_id)
+{
+ char safe_id[96];
+ int nwr;
+
+ if (path == NULL || path_cap == 0U || car_id == NULL || car_id[0] == '\0') {
+ return -1;
+ }
+ if (ble_icce_changan_sanitize_vehicle_car_id_for_path(car_id, safe_id, sizeof(safe_id)) != 0) {
+ return -1;
+ }
+ nwr = snprintf(path, path_cap, "%s%s.bin", BLE_ICCE_CHANGAN_AUTH_CARD_STORE_PREFIX, safe_id);
+ if (nwr <= 0 || (size_t)nwr >= path_cap) {
+ return -1;
+ }
+ return 0;
+}
+
+static int ble_icce_changan_save_auth_card_identity_file(const bd_addr_t *ble_addr, const char *car_id,
+ const uint8_t *card_seid, const uint8_t *card_id, const uint8_t *card_info1)
+{
+ char path[192];
+ FILE *fp;
+ uint8_t hdr[16];
+
+ if (car_id == NULL || car_id[0] == '\0' || card_seid == NULL || card_id == NULL || card_info1 == NULL) {
+ return -1;
+ }
+ if (ble_icce_changan_auth_card_identity_build_path(path, sizeof(path), car_id) != 0) {
+ ICCE_LOG("ChangAn auth card: invalid car_id for path");
+ return -1;
+ }
+ fp = fopen(path, "wb");
+ if (fp == NULL) {
+ ICCE_LOG("ChangAn auth card: fopen fail %s", path);
+ return -1;
+ }
+ hdr[0] = BLE_ICCE_AUTH_CARD_FILE_MAGIC0;
+ hdr[1] = BLE_ICCE_AUTH_CARD_FILE_MAGIC1;
+ hdr[2] = BLE_ICCE_AUTH_CARD_FILE_MAGIC2;
+ hdr[3] = BLE_ICCE_AUTH_CARD_FILE_MAGIC3;
+ hdr[4] = BLE_ICCE_AUTH_CARD_FILE_VER;
+ hdr[5] = 0;
+ hdr[6] = 0;
+ hdr[7] = 0;
+ if (ble_addr != NULL) {
+ (void)memcpy(&hdr[8], ble_addr->addr, BD_ADDR_LEN);
+ hdr[14] = ble_addr->type;
+ } else {
+ (void)memset(&hdr[8], 0, (size_t)BD_ADDR_LEN);
+ hdr[14] = 0;
+ }
+ hdr[15] = 0;
+ if (fwrite(hdr, 1U, sizeof(hdr), fp) != sizeof(hdr) ||
+ fwrite(card_seid, 1U, (size_t)ICCE_TAG_LEN_CARD_SEID, fp) != (size_t)ICCE_TAG_LEN_CARD_SEID ||
+ fwrite(card_id, 1U, (size_t)ICCE_TAG_LEN_CARD_ID, fp) != (size_t)ICCE_TAG_LEN_CARD_ID ||
+ fwrite(card_info1, 1U, (size_t)ICCE_CARD_INFO1_TEST_LEN, fp) != (size_t)ICCE_CARD_INFO1_TEST_LEN) {
+ (void)fclose(fp);
+ ICCE_LOG("ChangAn auth card: fwrite fail %s", path);
+ return -1;
+ }
+ if (fclose(fp) != 0) {
+ ICCE_LOG("ChangAn auth card: fclose fail %s", path);
+ return -1;
+ }
+ ICCE_LOG("ChangAn auth card: saved %s", path);
+ return 0;
+}
+
+static void ble_icce_dkey_install(const uint8_t *dkey_16)
+{
+ if (dkey_16 == NULL) {
+ g_icce_dkey_valid = 0;
+ return;
+ }
+ (void)memcpy(g_icce_dkey, dkey_16, 16);
+ g_icce_dkey_valid = 1;
+}
+
+void ble_icce_changan_set_auth_card_identity(const bd_addr_t *ble_addr, const char *changan_vehicle_car_id,
+ const uint8_t card_seid[ICCE_TAG_LEN_CARD_SEID],
+ const uint8_t card_id[ICCE_TAG_LEN_CARD_ID], const uint8_t card_info1[ICCE_CARD_INFO1_TEST_LEN],
+ const uint8_t *opt_dkey_master_16)
+{
+ if (card_seid != NULL) {
+ memcpy(g_icce_auth_card_seid, card_seid, ICCE_TAG_LEN_CARD_SEID);
+ }
+ if (card_id != NULL) {
+ memcpy(g_icce_auth_card_id, card_id, ICCE_TAG_LEN_CARD_ID);
+ }
+ if (card_info1 != NULL) {
+ memcpy(g_icce_auth_card_info1, card_info1, ICCE_CARD_INFO1_TEST_LEN);
+ }
+
+ if (opt_dkey_master_16 != NULL) {
+ ble_icce_dkey_install(opt_dkey_master_16);
+ }
+
+ if (changan_vehicle_car_id != NULL && changan_vehicle_car_id[0] != '\0' && card_seid != NULL && card_id != NULL &&
+ card_info1 != NULL) {
+ (void)ble_icce_changan_save_auth_card_identity_file(ble_addr, changan_vehicle_car_id, card_seid, card_id,
+ card_info1);
+ }
+}
+
+static bool ble_icce_changan_auth_card_identity_ram_non_empty(void)
+{
+ size_t i;
+ bool seid_ok = false;
+ bool info1_ok = false;
+
+ for (i = 0; i < ICCE_TAG_LEN_CARD_SEID; i++) {
+ if (g_icce_auth_card_seid[i] != 0U) {
+ seid_ok = true;
+ break;
+ }
+ }
+ for (i = 0; i < ICCE_CARD_INFO1_TEST_LEN; i++) {
+ if (g_icce_auth_card_info1[i] != 0U) {
+ info1_ok = true;
+ break;
+ }
+ }
+ return seid_ok && info1_ok;
+}
+
+bool ble_icce_changan_auth_card_identity_ready(const char *changan_vehicle_car_id)
+{
+ char path[192];
+ FILE *fp;
+ uint8_t hdr[16];
+ uint8_t seid[ICCE_TAG_LEN_CARD_SEID];
+ uint8_t cid[ICCE_TAG_LEN_CARD_ID];
+ uint8_t info1[ICCE_CARD_INFO1_TEST_LEN];
+ const long need_sz = (long)sizeof(hdr) + (long)ICCE_TAG_LEN_CARD_SEID + (long)ICCE_TAG_LEN_CARD_ID +
+ (long)ICCE_CARD_INFO1_TEST_LEN;
+ long sz;
+ size_t i;
+ bool seid_ok = false;
+ bool info1_ok = false;
+
+ if (changan_vehicle_car_id == NULL || changan_vehicle_car_id[0] == '\0') {
+ return false;
+ }
+ if (ble_icce_changan_auth_card_identity_ram_non_empty()) {
+ return true;
+ }
+ if (ble_icce_changan_auth_card_identity_build_path(path, sizeof(path), changan_vehicle_car_id) != 0) {
+ return false;
+ }
+ fp = fopen(path, "rb");
+ if (fp == NULL) {
+ return false;
+ }
+ if (fseek(fp, 0, SEEK_END) != 0) {
+ (void)fclose(fp);
+ return false;
+ }
+ sz = ftell(fp);
+ if (sz < need_sz) {
+ (void)fclose(fp);
+ return false;
+ }
+ if (fseek(fp, 0, SEEK_SET) != 0) {
+ (void)fclose(fp);
+ return false;
+ }
+ if (fread(hdr, 1U, sizeof(hdr), fp) != sizeof(hdr)) {
+ (void)fclose(fp);
+ return false;
+ }
+ if (hdr[0] != BLE_ICCE_AUTH_CARD_FILE_MAGIC0 || hdr[1] != BLE_ICCE_AUTH_CARD_FILE_MAGIC1 ||
+ hdr[2] != BLE_ICCE_AUTH_CARD_FILE_MAGIC2 || hdr[3] != BLE_ICCE_AUTH_CARD_FILE_MAGIC3 ||
+ hdr[4] != BLE_ICCE_AUTH_CARD_FILE_VER) {
+ (void)fclose(fp);
+ return false;
+ }
+ if (fread(seid, 1U, sizeof(seid), fp) != sizeof(seid) || fread(cid, 1U, sizeof(cid), fp) != sizeof(cid) ||
+ fread(info1, 1U, sizeof(info1), fp) != sizeof(info1)) {
+ (void)fclose(fp);
+ return false;
+ }
+ (void)fclose(fp);
+
+ for (i = 0; i < sizeof(seid); i++) {
+ if (seid[i] != 0U) {
+ seid_ok = true;
+ break;
+ }
+ }
+ for (i = 0; i < sizeof(info1); i++) {
+ if (info1[i] != 0U) {
+ info1_ok = true;
+ break;
+ }
+ }
+ if (!seid_ok || !info1_ok) {
+ return false;
+ }
+ (void)memcpy(g_icce_auth_card_seid, seid, sizeof(seid));
+ (void)memcpy(g_icce_auth_card_id, cid, sizeof(cid));
+ (void)memcpy(g_icce_auth_card_info1, info1, sizeof(info1));
+ return true;
+}
+
+/*
+ * msg/cmd=0x01/0x01 同步请求(车→机):
+ * - 若已标记「取数据后第二条」:免 TLV,直接按表组认证响应;
+ * - 否则按上层已归类的 app_command(与 icce_resolve_app_command_kind 一致)分支,复用 auth_scan_opt 组取数据/认证回应,不再重复扫描分类。
+ */
+static int icce_auth_handle_sync_request(uint8_t client_id, uint16_t conn_id,
+ const icce_frame_header_t *header, const icce_frame_body_t *frame_body,
+ icce_app_command_kind_t app_cmd, const icce_auth_tlv_scan_t *auth_scan_opt)
+{
+ if (header == NULL || frame_body == NULL) {
+ return 0;
+ }
+ if (!header->is_request || header->is_async) {
+ return 0;
+ }
+ if (frame_body->message_id != ICCE_MSG_AUTH_DATA || frame_body->command_id != ICCE_CMD_AUTH_DATA) {
+ return 0;
+ }
+ if (icce_changan_handle_post_getdata_auth_sync(client_id, conn_id, frame_body)) {
+ return 1;
+ }
+ if (frame_body->payload_data == NULL || frame_body->payload_len == 0) {
+ return 0;
+ }
+
+ switch (app_cmd) {
+ case ICCE_APP_CMD_AUTH01_GET_PROCESS_DATA:
+ ICCE_LOG("[ICCE] msg01/cmd01 sync reply → GET PROCESS DATA (per table)");
+ return icce_changan_handle_get_process_data_sync(client_id, conn_id, frame_body, auth_scan_opt) ? 1 : 0;
+ case ICCE_APP_CMD_AUTH01_VEHICLE_AUTH:
+ ICCE_LOG("[ICCE] msg01/cmd01 sync reply → AUTH (per table)");
+ return icce_changan_handle_auth_command_sync(client_id, conn_id, frame_body, auth_scan_opt) ? 1 : 0;
+ case ICCE_APP_CMD_AUTH01_UNRESOLVED:
+ default:
+ ICCE_LOG("[ICCE] msg01/cmd01 sync: no reply (app_command=%s)",
+ icce_app_command_kind_str(app_cmd));
+ return 0;
+ }
+}
+
+static void icce_setup_cb(uint8_t client_id, uint16_t conn_id, errcode_t status)
+{
+ ICCE_LOG("setup client_id=%u conn_id=%u status=%d", client_id, conn_id, (int)status);
+ if (status != ERRCODE_BT_SUCCESS) {
+ return;
+ }
+ /* 建立成功后自动订阅状态 Notify */
+ (void)ble_icce_client_subscribe_status(client_id, conn_id, ICCE_CLIENT_NOTIFY_ENABLE);
+}
+
+static void icce_subscribe_cb(uint8_t client_id, uint16_t conn_id, gatt_status_t status)
+{
+ ICCE_LOG("subscribe client_id=%u conn_id=%u status=0x%x", client_id, conn_id, status);
+}
+
+typedef struct {
+ uint8_t in_use;
+ uint16_t conn_id;
+ uint8_t control;
+ uint8_t fsn_start;
+ uint8_t fsn_last;
+ uint16_t total_len;
+ uint8_t buf[ICCE_MAX_REASM_BODY]; /* 原始 body 拼接(message_id 起,密文/明文) */
+} icce_reasm_ctx_t;
+
+static icce_reasm_ctx_t g_icce_reasm[ICCE_MAX_REASM_CONN];
+
+static void icce_reasm_reset(icce_reasm_ctx_t *ctx)
+{
+ if (ctx == NULL) {
+ return;
+ }
+ ctx->in_use = 0;
+ ctx->conn_id = 0;
+ ctx->control = 0;
+ ctx->fsn_start = 0;
+ ctx->fsn_last = 0;
+ ctx->total_len = 0;
+}
+
+static icce_reasm_ctx_t *icce_reasm_get(uint16_t conn_id, int create_if_empty)
+{
+ icce_reasm_ctx_t *free_ctx = NULL;
+ for (uint32_t i = 0; i < ICCE_MAX_REASM_CONN; i++) {
+ if (g_icce_reasm[i].in_use && g_icce_reasm[i].conn_id == conn_id) {
+ return &g_icce_reasm[i];
+ }
+ if (!g_icce_reasm[i].in_use && free_ctx == NULL) {
+ free_ctx = &g_icce_reasm[i];
+ }
+ }
+ if (!create_if_empty || free_ctx == NULL) {
+ return NULL;
+ }
+ memset(free_ctx, 0, sizeof(*free_ctx));
+ free_ctx->in_use = 1;
+ free_ctx->conn_id = conn_id;
+ return free_ctx;
+}
+
+static void icce_reasm_clear_by_conn(uint16_t conn_id)
+{
+ for (uint32_t i = 0; i < ICCE_MAX_REASM_CONN; i++) {
+ if (g_icce_reasm[i].in_use && g_icce_reasm[i].conn_id == conn_id) {
+ icce_reasm_reset(&g_icce_reasm[i]);
+ }
+ }
+}
+
+/* CRC16-CCITT (poly 0x1021, init 0xFFFF),计算不包含最后 2 字节的校验值 */
+static uint16_t icce_crc16_ccitt(const uint8_t *buf, uint16_t len)
+{
+ uint16_t crc = 0xFFFF;
+ while (len--) {
+ crc ^= (uint16_t)(*buf++) << 8;
+ for (int i = 0; i < 8; i++) {
+ if (crc & 0x8000) {
+ crc = (crc << 1) ^ 0x1021;
+ } else {
+ crc = crc << 1;
+ }
+ }
+ }
+ return crc;
+}
+
+/* 帧头 Length、尾 CheckSum:大端序(高字节在前) */
+static uint16_t icce_put_be16(uint8_t *dst, uint16_t v)
+{
+ dst[0] = (uint8_t)((v >> 8) & 0xFF);
+ dst[1] = (uint8_t)(v & 0xFF);
+ return 2;
+}
+
+/* Tag/Length 编码;主机侧一致性验证见 zhihui/ChangAan/icce_auth_payload_selftest.c(须同步修改) */
+static uint16_t icce_tlv_build(uint8_t *dst, uint16_t dst_cap, uint16_t tag_number,
+ const uint8_t *value, uint16_t value_len)
+{
+ uint16_t off = 0;
+ if (dst == NULL) {
+ return 0;
+ }
+ /* Tag:1 或 2 字节 */
+ if (tag_number <= 0xFF) {
+ if (dst_cap < 1) {
+ return 0;
+ }
+ dst[off++] = (uint8_t)tag_number;
+ } else {
+ if (dst_cap < 2) {
+ return 0;
+ }
+ dst[off++] = (uint8_t)((tag_number >> 8) & 0xFF);
+ dst[off++] = (uint8_t)(tag_number & 0xFF);
+ }
+
+ /* Length:短格式(<=127) 或 0x81+len(<=255) */
+ if (value_len <= ICCE_LENGTH_SHORT_FORM_MAX) {
+ if (dst_cap < off + 1) {
+ return 0;
+ }
+ dst[off++] = (uint8_t)value_len;
+ } else if (value_len <= 0xFF) {
+ if (dst_cap < off + 2) {
+ return 0;
+ }
+ dst[off++] = ICCE_LENGTH_INDICATOR_ONE_FOLLOWING_BYTE;
+ dst[off++] = (uint8_t)value_len;
+ } else {
+ return 0;
+ }
+
+ if (value_len > 0) {
+ if (value == NULL || dst_cap < off + value_len) {
+ return 0;
+ }
+ memcpy(dst + off, value, value_len);
+ off = (uint16_t)(off + value_len);
+ }
+ return off;
+}
+
+uint8_t ble_icce_send_frame(uint8_t client_id, uint16_t conn_id,
+ uint8_t is_request, uint8_t is_async, uint8_t is_encrypted,
+ uint8_t message_id, uint8_t command_id,
+ uint16_t tag_number, const uint8_t *value, uint16_t value_len)
+{
+ uint8_t *const frame = s_ble_icce_tx_frame;
+ (void)memset(frame, 0, ICCE_MAX_TX_FRAME_LEN);
+ uint16_t off = 0;
+
+ /* SOF */
+ frame[off++] = ICCE_FRAME_SOF;
+
+ /* Length 占位 */
+ uint16_t len_pos = off;
+ off += 2;
+
+ /* Control */
+ uint8_t control = 0;
+ control |= ICCE_CTRL_FRAGMENT_FULL;
+ if (is_async) {
+ control |= ICCE_CTRL_ASYNC_BIT;
+ }
+ if (is_encrypted) {
+ control |= ICCE_CTRL_ENCRYPT_BIT;
+ }
+ if (is_request) {
+ control |= ICCE_CTRL_REQUEST_BIT;
+ }
+ frame[off++] = control;
+
+ /* FRAGMENT_FULL:FSN 固定 0;仅将来若实现 START/MID/END 分片,再在「同一包」内对 FSN 递增 */
+ frame[off++] = ICCE_FSN_FULL_SINGLE_FRAME;
+
+ if (!is_encrypted) {
+ /* body 明文:message_id + command_id + TLV */
+ frame[off++] = message_id;
+ frame[off++] = command_id;
+ uint16_t tlv_len = icce_tlv_build(frame + off, (uint16_t)(ICCE_MAX_TX_FRAME_LEN - off - 2),
+ tag_number, value, value_len);
+ if (tlv_len == 0) {
+ return 1;
+ }
+ off = (uint16_t)(off + tlv_len);
+ } else {
+ /* 与 icce_body_parse_inner 对称:整段 body = ISO9797_M2(msg||cmd||TLV) 再 AES-128-CBC(SessionKey, SessionIV) */
+ if (!g_icce_session_key_valid || !g_icce_auth_cache_reader_rnd_valid || !g_icce_auth_cache_card_rnd_valid) {
+ ICCE_LOG("[ICCE] send_frame encrypt: need SessionKey + ReaderRnd + CardRnd (after GET-data)");
+ return 1;
+ }
+ uint8_t *const plain = s_ble_icce_tx_enc_plain;
+ (void)memset(plain, 0, ICCE_MAX_TX_FRAME_LEN);
+ uint16_t plen_body = 0;
+ plain[plen_body++] = message_id;
+ plain[plen_body++] = command_id;
+ uint16_t tlv_len = icce_tlv_build(plain + plen_body, (uint16_t)(ICCE_MAX_TX_FRAME_LEN - plen_body),
+ tag_number, value, value_len);
+ if (tlv_len == 0) {
+ return 1;
+ }
+ plen_body = (uint16_t)(plen_body + tlv_len);
+ uint8_t *const padded = s_ble_icce_tx_enc_m2;
+ (void)memset(padded, 0, ICCE_MAX_TX_FRAME_LEN);
+ uint16_t plen = icce_iso9797_m2_pad(plain, plen_body, padded, (uint16_t)ICCE_MAX_TX_FRAME_LEN);
+ if (plen == 0) {
+ return 1;
+ }
+ uint8_t session_iv[16];
+ memcpy(session_iv, g_icce_auth_cache_reader_rnd, ICCE_TAG_LEN_READER_RND);
+ memcpy(session_iv + ICCE_TAG_LEN_READER_RND, g_icce_auth_cache_card_rnd, ICCE_TAG_LEN_CARD_RND);
+ mbedtls_aes_context aes;
+ mbedtls_aes_init(&aes);
+ if (mbedtls_aes_setkey_enc(&aes, g_icce_session_key, 128) != 0) {
+ mbedtls_aes_free(&aes);
+ return 1;
+ }
+ if (mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_ENCRYPT, plen, session_iv, padded, padded) != 0) {
+ mbedtls_aes_free(&aes);
+ return 1;
+ }
+ mbedtls_aes_free(&aes);
+ if ((uint32_t)off + (uint32_t)plen + 2u > (uint32_t)ICCE_MAX_TX_FRAME_LEN) {
+ return 1;
+ }
+ (void)memcpy(frame + off, padded, plen);
+ off = (uint16_t)(off + plen);
+ }
+
+ /* 线上 Length = Control..payload 末(不含 CRC);总长 = 3 + len_field + 2 */
+ uint16_t len_field = (uint16_t)(off - 3);
+ (void)icce_put_be16(&frame[len_pos], len_field);
+
+ /* CRC16:不含 CRC 字段本身 */
+ uint16_t crc = icce_crc16_ccitt(frame, off);
+ off += icce_put_be16(frame + off, crc);
+
+ return ble_icce_send_icce_frame_raw(client_id, conn_id, frame, off);
+}
+
+static void icce_put_u32_be_buf(uint8_t d[4], uint32_t v)
+{
+ d[0] = (uint8_t)(v >> 24);
+ d[1] = (uint8_t)(v >> 16);
+ d[2] = (uint8_t)(v >> 8);
+ d[3] = (uint8_t)v;
+}
+
+uint8_t ble_icce_send_rke03_vehicle_control_ex(uint32_t counter_be, uint32_t control_code_be)
+{
+ uint8_t inner[24];
+ uint8_t c4[4];
+ uint8_t t4[4];
+ uint16_t in;
+
+ if (g_changan_icce_sub_conn_id == 0) {
+ ICCE_LOG("[ICCE] TX RKE03: no active link (g_changan_icce_sub_conn_id=0)");
+ return 1;
+ }
+ icce_put_u32_be_buf(c4, counter_be);
+ icce_put_u32_be_buf(t4, control_code_be);
+ in = icce_tlv_build(inner, (uint16_t)sizeof(inner), (uint16_t)ICCE_RKE03_INNER_COUNTER, c4, 4u);
+ if (in == 0) {
+ return 1;
+ }
+ {
+ uint16_t n2 = icce_tlv_build(inner + in, (uint16_t)(sizeof(inner) - in), (uint16_t)ICCE_RKE03_INNER_CTRL_CODE, t4, 4u);
+ if (n2 == 0) {
+ return 1;
+ }
+ in = (uint16_t)(in + n2);
+ }
+ ICCE_LOG("[ICCE] TX RKE03 tag61: client=%u conn=%u counter=0x%08X code=0x%08X (enc fixed)",
+ (unsigned)g_changan_icce_sub_client_id, (unsigned)g_changan_icce_sub_conn_id,
+ (unsigned)counter_be, (unsigned)control_code_be);
+ return ble_icce_send_frame(g_changan_icce_sub_client_id, g_changan_icce_sub_conn_id,
+ 1u,
+ 0u,
+ 1u,
+ ICCE_MSG_RKE_CTRL,
+ ICCE_CMD_RKE_REMOTE_CTRL,
+ (uint16_t)ICCE_TAG_RKE03_RKE_CTRL_ROOT,
+ inner,
+ in);
+}
+
+uint8_t ble_icce_send_rke03_vehicle_control(uint32_t control_code_be)
+{
+ uint32_t c = g_icce_rke03_tx_counter;
+ g_icce_rke03_tx_counter++;
+ return ble_icce_send_rke03_vehicle_control_ex(c, control_code_be);
+}
+
+/* 从 buf 起始解析一个 TLV(Tag 1/2 字节 + Length 短/长格式 + Value),value 在 buf 内 */
+int icce_tlv_parse(const uint8_t *buf, uint16_t buf_len, icce_tlv_header_t *out)
+{
+ if (buf == NULL || out == NULL || buf_len < 2) {
+ return -1;
+ }
+ memset(out, 0, sizeof(icce_tlv_header_t));
+
+ uint8_t b0 = buf[0];
+ out->tag_type = (uint8_t)(b0 & ICCE_TAG_TYPE_MASK);
+ out->tag_encoding = (uint8_t)(b0 & ICCE_TAG_ENCODING_MASK);
+
+ uint16_t tag_len;
+ if ((b0 & ICCE_TAG_NUMBER_MASK) != ICCE_TAG_NUMBER_EXTENDED) {
+ /* 单字节 Tag,编号在 bit0-4,整体 Tag 值按首字节 */
+ out->tag_number = (uint16_t)b0;
+ tag_len = 1;
+ } else {
+ /* 扩展 Tag:至少 2 字节,第二字节 bit7=0 表示最后一字节 */
+ if (buf_len < 3) {
+ return -1;
+ }
+ out->tag_number = ((uint16_t)buf[0] << 8) | buf[1];
+ tag_len = 2;
+ }
+
+ uint16_t len_byte = buf[tag_len];
+ uint16_t len_len;
+ uint16_t value_len;
+ if ((len_byte & ICCE_LENGTH_LONG_FORM_FLAG) == ICCE_LENGTH_SHORT_FORM_FLAG) {
+ value_len = len_byte & ICCE_LENGTH_NUM_BYTES_MASK;
+ len_len = 1;
+ } else if (len_byte == ICCE_LENGTH_INDICATOR_ONE_FOLLOWING_BYTE) {
+ if (buf_len < tag_len + 2) {
+ return -1;
+ }
+ value_len = buf[tag_len + 1];
+ len_len = 2;
+ } else {
+ return -2; /* 不支持的 Length 格式 */
+ }
+
+ if (buf_len < tag_len + len_len + value_len) {
+ return -1;
+ }
+ out->value_len = value_len;
+ out->value = buf + tag_len + len_len;
+ return (int)(tag_len + len_len);
+}
+
+int icce_frame_parse(const uint8_t *raw, uint16_t raw_len,
+ icce_frame_header_t *out_header,
+ const uint8_t **out_body_raw, uint16_t *out_body_raw_len)
+{
+ if (raw == NULL || out_header == NULL || out_body_raw == NULL || out_body_raw_len == NULL || raw_len < ICCE_FRAME_MIN_LEN) {
+ return -1;
+ }
+ memset(out_header, 0, sizeof(icce_frame_header_t));
+ *out_body_raw = NULL;
+ *out_body_raw_len = 0;
+
+ if (raw[0] != ICCE_FRAME_SOF) {
+ return -2;
+ }
+
+ /* Length 大端:Control..payload 末,不含 CRC 2 字节;总长 raw_len == 3 + len_field + 2 */
+ uint16_t len_field = ((uint16_t)raw[1] << 8) | (uint16_t)raw[2];
+ if (raw_len < 7 || raw_len != (uint16_t)(3u + len_field + 2u)) {
+ return -3;
+ }
+ uint16_t body_len = (uint16_t)(len_field + 2u); /* Control..CheckSum(含),供 header 与 body_raw_len 推导 */
+
+ /* 仅解析 header:Control + FSN,不解析 body */
+ uint8_t control = raw[3];
+ out_header->body_len = body_len;
+ out_header->control = control;
+ out_header->fragment_type = control & ICCE_CTRL_FRAGMENT_MASK;
+ out_header->is_async = (control & ICCE_CTRL_ASYNC_BIT) ? 1 : 0;
+ out_header->is_encrypted = (control & ICCE_CTRL_ENCRYPT_BIT) ? 1 : 0;
+ out_header->is_request = (control & ICCE_CTRL_REQUEST_BIT) ? 1 : 0;
+ out_header->fsn = raw[4];
+
+ /* body 原始区:message_id + command_id + payload(不含 checksum),供组包;完成组包后由 icce_body_parse 解析 */
+ uint16_t body_raw_len = (uint16_t)(body_len - 4u); /* body_len = Control+FSN+msg/cmd/payload+CRC(2) */
+ if (body_raw_len < 2) {
+ return -3;
+ }
+ *out_body_raw = raw + 5;
+ *out_body_raw_len = body_raw_len;
+
+ uint16_t crc_len = raw_len - 2;
+ uint16_t crc_calc = icce_crc16_ccitt(raw, crc_len);
+ uint16_t crc_recv = ((uint16_t)raw[crc_len] << 8) | (uint16_t)raw[crc_len + 1];
+ out_header->checksum_ok = (crc_calc == crc_recv) ? 1 : 0;
+ if (!out_header->checksum_ok) {
+ return -4;
+ }
+ return 0;
+}
+
+/*
+ * 统一入口:解析 body(message_id + command_id + payload)。
+ *
+ * 当 ICCE 帧头 Control 置「整 body 加密」时(header->is_encrypted):
+ * - 规范:加密数据 = AES128-CBC(SessionKey, SessionIV, …),SessionIV(16B)= ReaderRnd || CardRnd;
+ * 算法 ALG_AES_CBC_ISO9797_M2(与 Tag73 等一致)。
+ * - 实现:Key = g_icce_session_key(取处理数据成功后派生);IV = 缓存的 g_icce_auth_cache_reader_rnd ||
+ * g_icce_auth_cache_card_rnd;解密后 ISO9797-1 M2 去填充。不得用主密钥 DKey 或 9F0C(CardIV) 充当本处 IV。
+ * - 若 Control 未置加密位,则 body 不解密,直接解析。
+ * 说明:认证指令 TLV 内 Tag73 复合密文仍由 icce_auth_try_decrypt_vehicle_auth_cipher73 单独处理。
+ */
+static int icce_body_parse_inner(const icce_frame_header_t *header,
+ const uint8_t *body_raw, uint16_t body_raw_len,
+ icce_frame_body_t *out_body,
+ uint8_t *body_out_buf, uint16_t body_out_cap)
+{
+ if (header == NULL || body_raw == NULL || out_body == NULL || body_raw_len < 2) {
+ return -1;
+ }
+ memset(out_body, 0, sizeof(icce_frame_body_t));
+
+ const uint8_t *plain = body_raw;
+ uint16_t plain_len = body_raw_len;
+
+ if (header->is_encrypted) {
+ if (!g_icce_session_key_valid) {
+ ICCE_LOG("[ICCE] body decrypt: SessionKey not ready (derive after GET-data)");
+ return -2;
+ }
+ if (!g_icce_auth_cache_reader_rnd_valid || !g_icce_auth_cache_card_rnd_valid) {
+ ICCE_LOG("[ICCE] body decrypt: SessionIV needs ReaderRnd+CardRnd cache");
+ return -2;
+ }
+ if (body_out_buf == NULL || body_out_cap < body_raw_len) {
+ return -3;
+ }
+ if ((body_raw_len % 16) != 0) {
+ return -4;
+ }
+ memcpy(body_out_buf, body_raw, body_raw_len);
+ uint8_t session_iv[16];
+ memcpy(session_iv, g_icce_auth_cache_reader_rnd, ICCE_TAG_LEN_READER_RND);
+ memcpy(session_iv + ICCE_TAG_LEN_READER_RND, g_icce_auth_cache_card_rnd, ICCE_TAG_LEN_CARD_RND);
+ mbedtls_aes_context aes;
+ mbedtls_aes_init(&aes);
+ int ret = mbedtls_aes_setkey_dec(&aes, g_icce_session_key, 128);
+ if (ret != 0) {
+ mbedtls_aes_free(&aes);
+ return -4;
+ }
+ ret = mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_DECRYPT, body_raw_len, session_iv, body_out_buf, body_out_buf);
+ mbedtls_aes_free(&aes);
+ if (ret != 0) {
+ return -4;
+ }
+ uint16_t out_len = icce_iso9797_m2_unpad(body_out_buf, body_raw_len, body_out_buf, body_out_cap);
+ if (out_len == 0) {
+ ICCE_LOG("[ICCE] body decrypt: ISO9797 M2 unpad fail");
+ return -4;
+ }
+ plain = body_out_buf;
+ plain_len = out_len;
+ if (plain_len < 2) {
+ return -1;
+ }
+ }
+
+ out_body->message_id = plain[0];
+ out_body->command_id = plain[1];
+ out_body->payload_data = plain + 2;
+ out_body->payload_len = (uint16_t)(plain_len - 2);
+ return 0;
+}
+
+int icce_body_parse(const icce_frame_header_t *header,
+ const uint8_t *body_raw, uint16_t body_raw_len,
+ icce_frame_body_t *out_body,
+ uint8_t *body_plain_buf, uint16_t body_plain_cap)
+{
+ return icce_body_parse_inner(header, body_raw, body_raw_len, out_body, body_plain_buf, body_plain_cap);
+}
+
+/* 完成组包后:统一在此对 payload 做 TLV 解析,再上报事件 */
+static void icce_handle_complete_frame(uint8_t client_id, uint16_t conn_id,
+ const icce_frame_header_t *header, const icce_frame_body_t *frame_body)
+{
+ if (header == NULL || frame_body == NULL) {
+ return;
+ }
+
+ if (frame_body->payload_data == NULL) {
+ return;
+ }
+ /* 使用 s_icce_handle_complete_ev,避免 64 节点 tlv_list 占栈 1K+ 在 BT_SERVICE_TASK 溢出 */
+ icce_body_event_t *const ev = &s_icce_handle_complete_ev;
+ (void)memset(ev, 0, sizeof(*ev));
+
+ if (frame_body->payload_len == 0) {
+ ICCE_LOG("[ICCE APP] msg=0x%02X cmd=0x%02X payload_len=0 enc=%u dir=%s",
+ frame_body->message_id,
+ frame_body->command_id,
+ (unsigned)header->is_encrypted,
+ header->is_request ? "peer_request" : "peer_response");
+ } else {
+ uint8_t fb = frame_body->payload_data[0];
+ uint16_t n_top = icce_tlv_count_top_level(frame_body->payload_data, frame_body->payload_len);
+ ICCE_LOG("[ICCE APP] msg=0x%02X cmd=0x%02X payload=%u first_tag_byte=0x%02X class=%s top_tlv_cnt=%u enc=%u dir=%s",
+ frame_body->message_id,
+ frame_body->command_id,
+ (unsigned)frame_body->payload_len,
+ (unsigned)fb,
+ icce_tlv_classify_first_tag_byte(fb),
+ (unsigned)n_top,
+ (unsigned)header->is_encrypted,
+ header->is_request ? "peer_request" : "peer_response");
+ }
+
+ /* 多 TLV + 嵌套展开到 ev->tlv_list */
+ (void)icce_payload_tlv_parse_command(frame_body->payload_data, frame_body->payload_len, &ev->tlv_list);
+ icce_parsed_body_t parsed = {0};
+ icce_parsed_from_tlv_list_first_top(&ev->tlv_list, &parsed, frame_body->payload_data, frame_body->payload_len);
+ if (ev->tlv_list.count == 0) {
+ ICCE_LOG("[ICCE APP] TLV command parse: no TLV node (raw payload as fallback)");
+ } else {
+ ICCE_LOG("[ICCE APP] TLV command parse: count=%u truncated=%u",
+ (unsigned)ev->tlv_list.count, (unsigned)ev->tlv_list.truncated);
+ ICCE_LOG("[ICCE APP] first top-level TLV tag=0x%04X (%s) value_len=%u",
+ (unsigned)parsed.tag_number, icce_tlv_tag_label(parsed.tag_number), (unsigned)parsed.value_len);
+ }
+
+ icce_auth_tlv_scan_t auth_scan = {0};
+ const icce_auth_tlv_scan_t *auth_scan_ptr = NULL;
+ if (frame_body->message_id == ICCE_MSG_AUTH_DATA && frame_body->command_id == ICCE_CMD_AUTH_DATA &&
+ frame_body->payload_data != NULL && frame_body->payload_len > 0) {
+ icce_auth_scan_payload(frame_body->payload_data, frame_body->payload_len, &auth_scan);
+ auth_scan_ptr = &auth_scan;
+ }
+
+ icce_app_command_kind_t app_cmd = icce_resolve_app_command_kind(frame_body, &ev->tlv_list, &parsed, auth_scan_ptr);
+ ICCE_LOG("[ICCE APP] app_command=%s", icce_app_command_kind_str(app_cmd));
+
+ ev->client_id = client_id;
+ ev->conn_id = conn_id;
+ ev->message_id = frame_body->message_id;
+ ev->command_id = frame_body->command_id;
+ ev->tag_number = parsed.tag_number;
+ ev->payload_len = parsed.value_len;
+ ev->payload_data = parsed.value;
+ ev->is_encrypted = header->is_encrypted;
+ ev->is_request = header->is_request;
+ ev->app_command = app_cmd;
+
+ /*
+ * Control 方向位(bleICCE.h 文件头):0=response,1=request — 本端收包时表示对端这一帧是「命令」还是「响应」。
+ * 对端 request:可能要立即同步回复(取处理数据/认证等)或默认 Status。
+ * 对端 response:对端在回答本端先前请求,仅解析并 dispatch,不自动再发 Status。
+ */
+ if (header->is_request) {
+ if (!header->is_async) {
+ if (!icce_auth_handle_sync_request(client_id, conn_id, header, frame_body, app_cmd, auth_scan_ptr)) {
+ uint8_t status = 0x00;
+ uint8_t enc = header->is_encrypted ? (uint8_t)1 : (uint8_t)0;
+ if (ble_icce_send_frame(client_id, conn_id,
+ 0 /* response */, 0 /* sync */, enc,
+ frame_body->message_id, frame_body->command_id,
+ ICCE_TAG_STATUS, &status, 1) != 0) {
+ ICCE_LOG("[ICCE] default Status send failed (reply enc=%u)", (unsigned)enc);
+ }
+ }
+ }
+ } else {
+ /* 对端为 response 帧,不跑取数/认证同步应答,也不发默认 Status */
+ }
+
+ icce_changan_dispatch(ev);
+ if (g_icce_body_handler != NULL) {
+ g_icce_body_handler(ev);
+ }
+}
+
+/* 长安实际定义:按 tag_number(TLV 解析出的 Tag)分发到各指令,具体处理在各 case 内补充 */
+void icce_changan_dispatch(const icce_body_event_t *ev)
+{
+ if (ev == NULL) {
+ return;
+ }
+
+ ICCE_LOG("[ICCE] changan_dispatch app_command=%s tag=0x%04X",
+ icce_app_command_kind_str(ev->app_command), (unsigned)ev->tag_number);
+
+ switch (ev->app_command) {
+ case ICCE_APP_CMD_RKE03_RKE61:
+ case ICCE_APP_CMD_RKE03_PARK62:
+ case ICCE_APP_CMD_RKE03_HB63:
+ case ICCE_APP_CMD_RKE03_C3B64:
+ case ICCE_APP_CMD_RKE03_WATCH12:
+ case ICCE_APP_CMD_RKE03_VEHICLE_RESP:
+ case ICCE_APP_CMD_RKE03_UNRESOLVED:
+ icce_changan_dispatch_rke03(ev);
+ return;
+ case ICCE_APP_CMD_V03_C02_VEH_STATUS_NOTIFY:
+ icce_changan_handle_v03_c02_veh_status_notify(ev);
+ return;
+ default:
+ break;
+ }
+
+ switch (ev->tag_number) {
+ case ICCE_TAG_CA_APP_RKE:
+ /* APP RKE控车指令 len=4 */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_APP_HEARTBEAT:
+ /* APP心跳 len=4 */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_VEHICLE_REQ_APP:
+ /* 车端请求APP下发数据 len=8 */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_VEHICLE_STATUS:
+ /* 车辆状态数据主动上传 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_RKE_PARK_COUNTER:
+ /* APP RKE/泊车控车指令计数器 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_RKE_PARK_SIGNAL:
+ /* RKE控车码/泊车控车指令信号 len=4 */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_APP_CTRL_FEEDBACK:
+ /* APP控车反馈 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_NORMAL_DATA:
+ /* 普通数据 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_APA_DATA:
+ /* APA数据 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_BACKEND_IF_ID:
+ /* 后台提供接口ID VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_VEHICLE_PARAM:
+ /* 车端传参 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_BACKEND_RESP:
+ /* 后台接口响应数据 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_BLE_UWB_KEY_STATUS:
+ /* 蓝牙UWB实体钥匙状态/响应 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_VEHICLE_UPLOAD:
+ /* 车端数据上传 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_APP_PARK_CTRL:
+ /* APP 泊车控车指令 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_APP_HEARTBEAT_DATA:
+ /* APP 心跳数据下发 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_RKE_FEEDBACK_PLAIN:
+ /* RKE控车反馈上传明文格式 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_VEHICLE_PARK_RESP:
+ /* 车端泊车控车指令响应 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_VEHICLE_HB_RESP:
+ /* 车端心跳数据响应 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_SEC_CH_VEHICLE:
+ /* 车端通过手机安全通道调用后台接口 VAR */
+ (void)ev;
+ break;
+ case ICCE_TAG_CA_SEC_CH_BACKEND:
+ /* 后台通过手机安全通道响应车端请求 VAR */
+ (void)ev;
+ break;
+ default:
+ /* 非长安自定义 Tag(如 ICCE 规范 0x00/0x5A/0x77/0x9Fxx 等)或未知 */
+ ICCE_LOG("changan unknown tag=0x%04x", (unsigned)ev->tag_number);
+ break;
+ }
+}
+
+/*
+ * icce_body_parse 需大体量明文/解密落区;在 BT_SERVICE_TASK 上勿再使用 body_plain[ICCE_MAX_REASM_BODY] 栈阵,易与
+ * icce_handle_complete_frame 内大结构(含 icce_payload_tlv_list_t)同栈导致栈溢出。
+ */
+static void icce_notify_run_body_parse_and_dispatch(uint8_t client_id, uint16_t conn_id,
+ const icce_frame_header_t *hdr, const uint8_t *body_raw, uint16_t body_raw_len)
+{
+ uint8_t *body_plain = (uint8_t *)malloc((size_t)ICCE_MAX_REASM_BODY);
+ if (body_plain == NULL) {
+ ICCE_LOG("[ICCE] notify: malloc body_plain %u fail", (unsigned)ICCE_MAX_REASM_BODY);
+ return;
+ }
+ (void)memset(body_plain, 0, (size_t)ICCE_MAX_REASM_BODY);
+ icce_frame_body_t frag_body = {0};
+ int bret = icce_body_parse(hdr, body_raw, body_raw_len, &frag_body, body_plain, (uint16_t)ICCE_MAX_REASM_BODY);
+ if (bret != 0) {
+ ICCE_LOG("body_parse fail=%d", bret);
+ free(body_plain);
+ return;
+ }
+ icce_handle_complete_frame(client_id, conn_id, hdr, &frag_body);
+ free(body_plain);
+}
+
+/*
+ * 处理一帧 ICCE Notify 原始字节流(与协议栈 notify 回调路径一致)。
+ * 供 AT^CHANGAN_ICCE_NOTIFY_RAW 注入测试数据,勿在 ISR 中调用。
+ */
+void ble_icce_notify_frame_process(uint8_t client_id, uint16_t conn_id, const uint8_t *data, uint16_t len)
+{
+ ICCE_LOG("notify client_id=%u conn_id=%u len=%u", client_id, conn_id, (unsigned)len);
+ if (data == NULL || len == 0) {
+ return;
+ }
+
+ /* 车端/协议栈可能下发空/占位 Notify(如 2 字节 0x00),或测试工具短包;非 ICCE 线帧则跳过,不进入解析、不清重组状态。 */
+ if (len < ICCE_FRAME_MIN_LEN || data[0] != ICCE_FRAME_SOF) {
+ ICCE_LOG("notify skip: not ICCE SOF frame (len=%u min=%u first=0x%02X, need SOF=0x%02X)",
+ (unsigned)len, (unsigned)ICCE_FRAME_MIN_LEN, data[0], ICCE_FRAME_SOF);
+ return;
+ }
+
+ icce_frame_header_t frag_header = {0};
+ const uint8_t *body_raw = NULL;
+ uint16_t body_raw_len = 0;
+ int ret = icce_frame_parse(data, len, &frag_header, &body_raw, &body_raw_len);
+ if (ret != 0) {
+ ICCE_LOG("parse fail ret=%d", ret);
+ icce_reasm_clear_by_conn(conn_id);
+ return;
+ }
+
+ ICCE_LOG("[ICCE] frame ok ctl=0x%02X fsn=0x%02X body_span=%u crc_ok=%u enc=%u req=%u",
+ frag_header.control,
+ frag_header.fsn,
+ (unsigned)frag_header.body_len,
+ (unsigned)frag_header.checksum_ok,
+ (unsigned)frag_header.is_encrypted,
+ (unsigned)frag_header.is_request);
+
+ uint8_t frag_type = frag_header.fragment_type & ICCE_CTRL_FRAGMENT_MASK;
+ icce_reasm_ctx_t *ctx = NULL;
+
+ switch (frag_type) {
+ case ICCE_CTRL_FRAGMENT_FULL: {
+ /* 完整帧:body 解析缓冲用堆,避免与 icce_handle_complete_frame 大结构同栈爆栈 */
+ icce_notify_run_body_parse_and_dispatch(client_id, conn_id, &frag_header, body_raw, body_raw_len);
+ break;
+ }
+
+ case ICCE_CTRL_FRAGMENT_START:
+ ctx = icce_reasm_get(conn_id, 1);
+ if (ctx == NULL) {
+ ICCE_LOG("reasm no ctx for conn %u", conn_id);
+ return;
+ }
+ memset(ctx, 0, sizeof(*ctx));
+ ctx->in_use = 1;
+ ctx->conn_id = conn_id;
+ ctx->control = frag_header.control;
+ ctx->fsn_start = frag_header.fsn;
+ ctx->fsn_last = frag_header.fsn;
+ {
+ uint16_t copy_len = body_raw_len; /* body_raw 为 message_id 起(密文/明文) */
+ if (copy_len > ICCE_MAX_REASM_BODY) {
+ ICCE_LOG("reasm start overflow len=%u", (unsigned)copy_len);
+ icce_reasm_reset(ctx);
+ return;
+ }
+ memcpy(ctx->buf, body_raw, copy_len);
+ ctx->total_len = copy_len;
+ }
+ break;
+
+ case ICCE_CTRL_FRAGMENT_MID:
+ ctx = icce_reasm_get(conn_id, 0);
+ if (ctx == NULL || !ctx->in_use) {
+ ICCE_LOG("reasm mid no ctx conn=%u", conn_id);
+ return;
+ }
+ if ((uint8_t)(ctx->fsn_last + 1u) != frag_header.fsn) {
+ ICCE_LOG("reasm mid fsn mismatch last=%u now=%u", ctx->fsn_last, frag_header.fsn);
+ icce_reasm_reset(ctx);
+ return;
+ }
+ ctx->fsn_last = frag_header.fsn;
+ {
+ uint16_t copy_len = body_raw_len;
+ if ((uint32_t)ctx->total_len + copy_len > ICCE_MAX_REASM_BODY) {
+ ICCE_LOG("reasm mid overflow total=%u add=%u", (unsigned)ctx->total_len, (unsigned)copy_len);
+ icce_reasm_reset(ctx);
+ return;
+ }
+ memcpy(ctx->buf + ctx->total_len, body_raw, copy_len);
+ ctx->total_len = (uint16_t)(ctx->total_len + copy_len);
+ }
+ break;
+
+ case ICCE_CTRL_FRAGMENT_END:
+ ctx = icce_reasm_get(conn_id, 0);
+ if (ctx == NULL || !ctx->in_use) {
+ ICCE_LOG("reasm end no ctx conn=%u", conn_id);
+ return;
+ }
+ if ((uint8_t)(ctx->fsn_last + 1u) != frag_header.fsn) {
+ ICCE_LOG("reasm end fsn mismatch last=%u now=%u", ctx->fsn_last, frag_header.fsn);
+ icce_reasm_reset(ctx);
+ return;
+ }
+ ctx->fsn_last = frag_header.fsn;
+ {
+ uint16_t copy_len = body_raw_len;
+ if ((uint32_t)ctx->total_len + copy_len > ICCE_MAX_REASM_BODY) {
+ ICCE_LOG("reasm end overflow total=%u add=%u", (unsigned)ctx->total_len, (unsigned)copy_len);
+ icce_reasm_reset(ctx);
+ return;
+ }
+ memcpy(ctx->buf + ctx->total_len, body_raw, copy_len);
+ ctx->total_len = (uint16_t)(ctx->total_len + copy_len);
+ }
+
+ {
+ icce_frame_header_t full_header = frag_header;
+ full_header.fragment_type = ICCE_CTRL_FRAGMENT_FULL;
+ full_header.control = (uint8_t)((frag_header.control & ~ICCE_CTRL_FRAGMENT_MASK) | ICCE_CTRL_FRAGMENT_FULL);
+ full_header.fsn = ctx->fsn_start;
+ icce_notify_run_body_parse_and_dispatch(client_id, conn_id, &full_header, ctx->buf, ctx->total_len);
+ }
+ icce_reasm_reset(ctx);
+ break;
+
+ default:
+ ICCE_LOG("unknown frag_type=%u", frag_type);
+ break;
+ }
+}
+
+static void icce_notify_cb(uint8_t client_id, uint16_t conn_id, uint8_t *data, uint16_t len)
+{
+ ble_icce_notify_frame_process(client_id, conn_id, data, len);
+}
+
+static void icce_status_read_cb(uint8_t client_id, uint16_t conn_id, const uint8_t *data, uint16_t len)
+{
+ ICCE_LOG("status_read client_id=%u conn_id=%u len=%u", client_id, conn_id, (unsigned)len);
+ (void)data;
+}
+
+static void icce_write_cb(uint8_t client_id, uint16_t conn_id, gatt_status_t status)
+{
+ ICCE_LOG("write client_id=%u conn_id=%u status=0x%x", client_id, conn_id, status);
+}
+
+/** 应用层注册的 body 统一处理回调 */
+
+void ble_icce_register_body_handler(icce_body_handler_t handler)
+{
+ g_icce_body_handler = handler;
+}
+
+/** 是否已注册过 ICCE 回调(只注册一次) */
+static uint8_t g_icce_callbacks_registered = 0;
+
+static void icce_register_callbacks_once(void)
+{
+ if (g_icce_callbacks_registered) {
+ return;
+ }
+ ble_icce_client_callbacks_t cb = {0};
+ cb.setup_cb = icce_setup_cb;
+ cb.subscribe_cb = icce_subscribe_cb;
+ cb.notify_cb = icce_notify_cb;
+ cb.status_read_cb = icce_status_read_cb;
+ cb.write_cb = icce_write_cb;
+ if (ble_icce_client_register_callbacks(&cb) == ERRCODE_BT_SUCCESS) {
+ g_icce_callbacks_registered = 1;
+ }
+}
+
+uint8_t ble_icce_setup_and_subscribe(uint8_t client_id, uint16_t conn_id)
+{
+ icce_register_callbacks_once();
+ errcode_t ret = ble_icce_client_setup_service(client_id, conn_id);
+ return (ret == ERRCODE_BT_SUCCESS || ret == ERRCODE_BT_DONE) ? 0 : 1;
+}
+
+uint8_t ble_icce_subscribe_status(uint8_t client_id, uint16_t conn_id, uint8_t enable)
+{
+ icce_client_notify_enable_t en = enable ? ICCE_CLIENT_NOTIFY_ENABLE : ICCE_CLIENT_NOTIFY_DISABLE;
+ errcode_t ret = ble_icce_client_subscribe_status(client_id, conn_id, en);
+ return (ret == ERRCODE_BT_SUCCESS) ? 0 : 1;
+}
+
+uint8_t ble_icce_send_vehicle_cmd(uint8_t client_id, uint16_t conn_id,
+ icce_vehicle_cmd_id_t cmd_id, const uint8_t *payload, uint16_t payload_len)
+{
+ errcode_t ret = ble_icce_client_send_vehicle_cmd(client_id, conn_id,
+ (uint8_t)cmd_id, payload, payload_len);
+ return (ret == ERRCODE_BT_SUCCESS) ? 0 : 1;
+}
+
+uint8_t ble_icce_send_icce_frame_raw(uint8_t client_id, uint16_t conn_id,
+ const uint8_t *frame, uint16_t frame_len)
+{
+ /* 勿在 BT 任务里逐字节 printf,易加深栈/阻塞;用 ICCE_LOG 行缓冲 */
+ icce_hex_dump_log("ICCE send raw", frame, frame_len);
+ errcode_t ret = ble_icce_client_send_icce_frame_raw(client_id, conn_id, frame, frame_len);
+ return (ret == ERRCODE_BT_SUCCESS) ? 0 : 1;
+}
+
+void ble_icce_clear_by_conn(uint8_t client_id, uint16_t conn_id)
+{
+ ble_icce_client_clear_remote_by_conn(client_id, conn_id);
+ icce_reasm_clear_by_conn(conn_id);
+ if (g_changan_icce_sub_conn_id == conn_id) {
+ g_changan_icce_sub_conn_id = 0;
+ g_changan_icce_sub_client_id = 0;
+ }
+ g_icce_auth_cache_key_param_valid = 0;
+ g_icce_auth_cache_reader_rnd_valid = 0;
+ g_icce_auth_cache_card_rnd_valid = 0;
+ g_icce_session_iv_fixed_valid = 0;
+ (void)memset(g_icce_session_iv_fixed, 0, sizeof(g_icce_session_iv_fixed));
+ g_icce_session_key_valid = 0;
+ g_icce_auth_card_atc_counter = 0;
+ g_icce_auth_last_ack_valid = 0;
+ g_icce_auth_expect_post_getdata_auth = 0;
+ g_icce_rke03_tx_counter = 1u;
+}
+
+bool ble_icce_connect_to_device(bd_addr_t *addr)
+{
+ errcode_t ret = gap_ble_connect_remote_device(addr);
+ printf("gap_ble_connect_remote_device %d\r\n",ret);
+ return (ret == ERRCODE_BT_SUCCESS) ? true : false;
+}
+
+bool ble_icce_start_scan_for_device(bd_addr_t *addr)
+{
+ bool ret = ble_start_scan(addr, 30000u);
+ if(ret==false)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble_start_scan fail");
+ return false;
+ }
+
+ ret = ble_connect_to_device(addr);
+ if(ret==false)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble_connect_to_device fail");
+ return false;
+ }
+ return ret;
+}
--- /dev/null
+/*
+ * Copyright (c) @CompanyNameMagicTag 2024. All rights reserved.
+ * Description: ICCE 车辆控制应用层接口,参考 bleANCS,调用 protocol 层 ble_icce_client.
+ */
+
+#ifndef BLE_ICCE_H
+#define BLE_ICCE_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "ble_icce_client.h"
+#include "bts_def.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+header:
+ SOF:
+ 1Byte 帧起始标识 固定值 0x5A(或规范定义的固定值),用于帧同步
+ Length :
+ 2Byte 帧体长度 从 Control 到「message_id+command_id+payload」最后一字节(不含 CheckSum 2 字节),大端序。
+ 整帧字节数 = 1(SOF)+2(Length)+Length值 + 2(CheckSum)。
+ Control :
+ 1Byte 控制位域
+ 包含 4 个 1bit 指示位:
+ ・分包指示位:标识是否为分包帧
+ 00,完整帧
+ 01,分包帧开始帧
+ 10,过程帧
+ 11,分包结束帧
+ ・响应指示位:请求 / 响应帧区分
+ 0,同步响应
+ 1,异步响应
+ ・加密指示位:标识 body 是否加密
+ 0不加密
+ 1加密。采用 aes-128-cbc。长安实际场景下,对 body(message_id+command_id+payload) 整段进行加密/解密处理。
+ ・方向指示位:标识通信方向(车→手机 / 手机→车)
+ 0, response
+ 1, request
+ 后 4 个 bit 位:
+ 0000 都保留,目前不使用
+ FSN:
+ 1Byte 帧序号 顺序递增,用于分包帧的同步
+body:
+ message id:
+ 1Byte 消息ID
+ command id:
+ 1Byte 命令ID
+ payload:
+ type
+ length
+ data
+checksum:
+ 2Byte 校验和 CRC16 校验值,计算从 SOF 到 CheckSum 字段(不包括)的所有字节的 CRC16 值 ccitt模式(大端序)
+*/
+
+/* Payload TLV:type(Tag) + length(Length) + data(Value),以下为 Tag/Length 编码定义 */
+
+/* ---------- 3.5.1.1 Tag(对应 payload 的 type),最多 2 字节 ---------- */
+#define ICCE_TAG_TYPE_MASK (0xC0) /* bit6-7: TLV 类型 */
+#define ICCE_TAG_TYPE_PRIMITIVE_FRAME (0x00) /* 00: 基本帧 */
+#define ICCE_TAG_TYPE_PRIVATE_FRAME (0x40) /* 01: 私有帧 */
+#define ICCE_TAG_ENCODING_MASK (0x20) /* bit5: Value 编码方式 */
+#define ICCE_TAG_ENCODING_PRIMITIVE_DATA (0x00) /* 0: 原始数据 */
+#define ICCE_TAG_ENCODING_CONSTRUCTED_DATA (0x20) /* 1: 构造数据(嵌套 TLV) */
+#define ICCE_TAG_NUMBER_MASK (0x1F) /* bit0-4: Tag 编号或扩展标志 */
+#define ICCE_TAG_NUMBER_EXTENDED (0x1F) /* 0x1F 表示 Tag 在后续字节延续 */
+#define ICCE_TAG_CONTINUATION_FLAG_MASK (0x80) /* 后续字节 bit7: 是否还有 Tag 字节 */
+#define ICCE_TAG_HAS_MORE_BYTES (0x80) /* 1: 还有后续 Tag 字节 */
+#define ICCE_TAG_LAST_BYTE (0x00) /* 0: 当前为 Tag 最后一字节 */
+#define ICCE_TAG_VALUE_PART_MASK (0x7F) /* 后续字节 bit0-6: Tag 值片段 */
+
+/* ---------- 3.5.1.2 Length(对应 payload 的 length),DefiniteForm,最多 255 字节 ---------- */
+#define ICCE_LENGTH_SHORT_FORM_FLAG (0x00) /* 短格式:bit7=0,长度 0~127 */
+#define ICCE_LENGTH_SHORT_FORM_MAX (0x7F) /* 短格式最大长度 */
+#define ICCE_LENGTH_LONG_FORM_FLAG (0x80) /* 长格式:bit7=1 */
+#define ICCE_LENGTH_NUM_BYTES_MASK (0x7F) /* 长格式首字节 bit0-6: 后续表示长度的字节数 */
+#define ICCE_LENGTH_INDICATOR_ONE_FOLLOWING_BYTE (0x81) /* 长格式:0x81 表示长度占 1 个后续字节,Value 最长 255 */
+
+/** 解析后的 TLV 头(Tag + Length),value 指针指向 payload 中 data 起始 */
+typedef struct {
+ uint8_t tag_type; /* ICCE_TAG_TYPE_* */
+ uint8_t tag_encoding; /* ICCE_TAG_ENCODING_* */
+ uint16_t tag_number; /* 解析得到的 Tag 编号(含扩展字节) */
+ uint16_t value_len; /* Value 字节数(0~255) */
+ const uint8_t *value; /* 指向 payload 中 Value 数据,不持有内存 */
+} icce_tlv_header_t;
+
+/* 与 ICCE_TAG_CARD_SEID 同值 0x5A:仅 raw[0] 表示 SOF,payload 内 0x5A 为 Card SEID TLV */
+#define ICCE_FRAME_SOF 0x5A
+
+/* Control 字节位域 */
+#define ICCE_CTRL_FRAGMENT_MASK 0x03 /* bit0-1: 分包指示 */
+#define ICCE_CTRL_FRAGMENT_FULL 0x00 /* 完整帧 */
+#define ICCE_CTRL_FRAGMENT_START 0x01 /* 分包开始 */
+#define ICCE_CTRL_FRAGMENT_MID 0x02 /* 过程帧 */
+#define ICCE_CTRL_FRAGMENT_END 0x03 /* 分包结束 */
+#define ICCE_CTRL_ASYNC_BIT (1u << 2) /* 1=异步响应 */
+#define ICCE_CTRL_ENCRYPT_BIT (1u << 3) /* 1=body 加密 */
+#define ICCE_CTRL_REQUEST_BIT (1u << 4) /* 1=request, 0=response */
+
+/*
+ * FSN:仅用于同一笔业务数据拆成多物理帧时,在 START→MID→…→END 链内顺序编号(收端校验 fsn 较上一片 +1)。
+ * 单帧即传完(FRAGMENT_FULL)时 FSN 固定为 0,禁止用全局递增计数器冒充分片序号。
+ */
+#define ICCE_FSN_FULL_SINGLE_FRAME 0u
+
+/* ---------- ICCE 规范内定义 Tag(len 为长安实际使用时的固定长度,VAR 表示可变) ---------- */
+#define ICCE_TAG_STATUS 0x00 /* len 0x01 Status */
+#define ICCE_TAG_MSG_CMD_ID_1 0x01 /* VAR Message ID/Command Id;长安: APP RKE控车指令 len=4 */
+#define ICCE_TAG_MSG_CMD_ID_2 0x02 /* VAR Message ID/Command Id;长安: APP心跳 len=4 */
+#define ICCE_TAG_MSG_CMD_ID_3 0x03 /* VAR Message ID/Command Id;长安: 车端请求APP下发数据 len=8 */
+#define ICCE_TAG_CARD_SEID 0x5A /* 0x08 车钥匙应用卡片唯一标识 CardSEID */
+#define ICCE_TAG_RESP_TEMPLATE 0x77 /* VAR 响应复合数据域模板 */
+#define ICCE_TAG_9F0A_READER_AUTH_PARAM 0x9F0A /* VAR 车侧自定义认证数据 ReaderAuthParameter */
+#define ICCE_TAG_9F0C_READER_KEY_PARAM 0x9F0C /* 0x10 车侧会话密钥分散因子 RFU ReaderKeyParameter */
+#define ICCE_TAG_9F1E_READER_ID 0x9F1E /* 0x10 车侧唯一标识 ReaderID */
+#define ICCE_TAG_9F31_CARD_AUTH_PARAM 0x9F31 /* VAR 钥匙侧自定义认证数据 CardAuthParameter */
+#define ICCE_TAG_9F35_READER_TYPE 0x9F35 /* 0x06 车侧设备种类 ReaderType */
+#define ICCE_TAG_9F36_CARD_ATC 0x9F36 /* 0x04 车钥匙应用卡片计数器 CardATC(Value 4B 大端) */
+#define ICCE_TAG_9F37_READER_RND 0x9F37 /* 0x08 车侧随机数 ReaderRnd(仅由车端经 BLE/ICCE 下发,本端不从本地生成) */
+#define ICCE_TAG_9F3B_CARD_ID 0x9F3B /* 0x10 车钥匙应用数字Key ID唯一标识 CardID */
+#define ICCE_TAG_9F3E_CARD_RND 0x9F3E /* 0x08 钥匙侧卡片随机数 CardRnd(本端生成;与车侧 9F37 ReaderRnd 区分) */
+#define ICCE_TAG_9F05_CARD_INFO1 0x9F05 /* VAR 车钥匙应用自定义数据 Card Info1(长安表) */
+#define ICCE_TAG_ICCE_VAR_CIPHER_TEMPLATE 0x73 /* VAR 复合数据域密文模板(CardAuthRes 等) */
+
+/* Message ID / Command ID:认证数据;其中「取处理数据」车→机 payload 内 Tag01 命令数据含 9F1E+9F37+9F0C 时单独应答取数据回应 */
+#define ICCE_MSG_AUTH_DATA 0x01
+#define ICCE_CMD_AUTH_DATA 0x01
+
+/** Message ID:RKE/遥控与心跳等业务(规范表 msg=0x02) */
+#define ICCE_MSG_RKE_CTRL 0x02
+/** Command ID:RKE 主命令(payload 内 TLV 区分 RKE/心跳/车端请求等) */
+#define ICCE_CMD_RKE_MAIN 0x01
+/**
+ * Command ID:RKE 远程车控(规范/表:Message ID=0x02, Command ID=0x03;首 TLV=0x61 等为控车/泊车/心跳等)
+ * 与 ICCE_CMD_RKE_MAIN(0x01) 为不同命令字,按首 TLV 继续区分。
+ */
+#define ICCE_CMD_RKE_REMOTE_CTRL 0x03
+
+/**
+ * Message ID=0x03、Command ID=0x02:车端主动向手机通知(车辆状态变化等),payload 内 Tag01/02/03 同规范表;与此 msg/cmd
+ * 唯一配对,解析时仅依据 message_id+command_id 即判定,勿依赖首 TLV。
+ */
+#define ICCE_MSG_VEHICLE_STATUS_NOTIFY 0x03
+#define ICCE_CMD_VEH_STATUS_EVENT 0x02
+
+/** Tag02「异步响应结果」Value 长 0x16(22)字节,见规范表 */
+#define ICCE_LEN_V03_TAG02_ASYNC_SEC_RESULT 0x16u
+
+/**
+ * 应用层命令枚举:在 TLV 解析后由 icce_resolve_app_command_kind 归类。
+ * 注释内为典型 TLV 组成(规范/长安表),便于与首 TLV Tag 对照。
+ */
+typedef enum {
+ ICCE_APP_CMD_UNKNOWN = 0,
+
+ /* ---- msg=0x01 cmd=0x01 认证数据(ICCE_MSG_AUTH_DATA)---- */
+ /** 取处理数据 车→机:Tag01→C-APDU,Lc 数据内含 9F1E(ReaderID)+9F37(ReaderRnd)+9F0C(ReaderKeyParam) */
+ ICCE_APP_CMD_AUTH01_GET_PROCESS_DATA,
+ /** 认证指令 车→机:Tag01→C-APDU,内含 77/9F36/9F3E 或 73 复合密文等(与取处理数据 TLV 组合互斥) */
+ ICCE_APP_CMD_AUTH01_VEHICLE_AUTH,
+ /** 0x01/0x01 但无法归入取数或认证 */
+ ICCE_APP_CMD_AUTH01_UNRESOLVED,
+
+ /* ---- msg=0x02 cmd=0x01 RKE(ICCE_MSG_RKE_CTRL + ICCE_CMD_RKE_MAIN),payload 首 TLV 为长安自定义 Tag ---- */
+ /** TLV Tag=0x01 len=4:APP RKE 控车指令 */
+ ICCE_APP_CMD_RKE_APP_CONTROL,
+ /** TLV Tag=0x02 len=4:APP 心跳 */
+ ICCE_APP_CMD_RKE_APP_HEARTBEAT,
+ /** TLV Tag=0x03 len=8:车端请求 APP 下发数据 */
+ ICCE_APP_CMD_RKE_VEHICLE_REQ_APP,
+ /** msg=0x02 cmd=0x01 但首 TLV 非上述已知值 */
+ ICCE_APP_CMD_RKE_UNRESOLVED,
+
+ /* ---- msg=0x02 cmd=0x03 RKE 远程车控/泊车/心跳(ICCE_CMD_RKE_REMOTE_CTRL;会话密钥加解密,见表)---- */
+ /** Tag=0x61:手机→车 APP RKE 控车请求;Value 内 TLV:0x01 计数(4B) + 0x02 控车码(4B) */
+ ICCE_APP_CMD_RKE03_RKE61,
+ /** 首 TLV=0x62:规范「APP 泊车控车」根,内 0x01 计数(4) + 0x02 泊车信号(VAR) */
+ ICCE_APP_CMD_RKE03_PARK62,
+ /** 首 TLV=0x63:规范「APP 心跳数据下发」根,内 0x40 心跳(VAR) */
+ ICCE_APP_CMD_RKE03_HB63,
+ /** 首 TLV=0x64:规范「APP C3B 泊车控车」根,内 0x01 计数(4) + 0x02 C3B 指令(VAR) */
+ ICCE_APP_CMD_RKE03_C3B64,
+ /** Tag=0x12:手表 RKE 等 */
+ ICCE_APP_CMD_RKE03_WATCH12,
+ /** 首 TLV=0x00 Status:车→机响应(0x00+0x01 内可含 0x71 RKE 反馈明文) */
+ ICCE_APP_CMD_RKE03_VEHICLE_RESP,
+ /** msg=0x02,cmd=0x03 但首 TLV 未归类 */
+ ICCE_APP_CMD_RKE03_UNRESOLVED,
+
+ /** msg=0x03 cmd=0x02 车端主动通知(与 ICCE_MSG_VEHICLE_STATUS_NOTIFY+ICCE_CMD_VEH_STATUS_EVENT 唯一配对) */
+ ICCE_APP_CMD_V03_C02_VEH_STATUS_NOTIFY,
+
+ /* ---- 其它 msg/cmd 下 payload 首 TLV 为长安自定义 Tag(与 icce_changan_dispatch 列表一致)---- */
+ /** Tag=0x06 VAR:车辆状态数据主动上传 */
+ ICCE_APP_CMD_CA_VEHICLE_STATUS,
+ /** Tag=0x07 VAR:APP RKE/泊车控车指令计数器 */
+ ICCE_APP_CMD_CA_RKE_PARK_COUNTER,
+ /** Tag=0x08 len=4:RKE 控车码/泊车控车指令信号 */
+ ICCE_APP_CMD_CA_RKE_PARK_SIGNAL,
+ /** Tag=0x09 VAR:APP 控车反馈 */
+ ICCE_APP_CMD_CA_APP_CTRL_FEEDBACK,
+ /** Tag=0x0A VAR:普通数据 */
+ ICCE_APP_CMD_CA_NORMAL_DATA,
+ /** Tag=0x11 VAR:APA 数据 */
+ ICCE_APP_CMD_CA_APA_DATA,
+ /** Tag=0x31 VAR:后台提供接口 ID */
+ ICCE_APP_CMD_CA_BACKEND_IF_ID,
+ /** Tag=0x40 VAR:车端传参 */
+ ICCE_APP_CMD_CA_VEHICLE_PARAM,
+ /** Tag=0x61 VAR:后台接口响应(与 RKE 规范 0x61 同值;msg=0x02,cmd=0x03 时首 TLV 0x61 见 ICCE_APP_CMD_RKE03_RKE61) */
+ ICCE_APP_CMD_CA_BACKEND_RESP,
+ /** Tag=0x62 VAR:蓝牙 UWB 实体钥匙状态/响应 */
+ ICCE_APP_CMD_CA_BLE_UWB_KEY_STATUS,
+ /** Tag=0x63 VAR:车端数据上传 */
+ ICCE_APP_CMD_CA_VEHICLE_UPLOAD,
+ /** Tag=0x71 VAR:APP 泊车控车指令 */
+ ICCE_APP_CMD_CA_APP_PARK_CTRL,
+ /** Tag=0x72 VAR:APP 心跳数据下发 */
+ ICCE_APP_CMD_CA_APP_HEARTBEAT_DATA,
+ /** Tag=0x73 VAR:RKE 控车反馈上传明文格式 */
+ ICCE_APP_CMD_CA_RKE_FEEDBACK_PLAIN,
+ /** Tag=0x82 VAR:车端泊车控车指令响应 */
+ ICCE_APP_CMD_CA_VEHICLE_PARK_RESP,
+ /** Tag=0x83 VAR:车端心跳数据响应 */
+ ICCE_APP_CMD_CA_VEHICLE_HB_RESP,
+ /** Tag=0xF1 VAR:车端经手机安全通道调后台 */
+ ICCE_APP_CMD_CA_SEC_CH_VEHICLE,
+ /** Tag=0xF2 VAR:后台经手机安全通道回车端 */
+ ICCE_APP_CMD_CA_SEC_CH_BACKEND,
+} icce_app_command_kind_t;
+
+/* 固定长度(长安实际) */
+#define ICCE_TAG_LEN_STATUS 0x01
+#define ICCE_TAG_LEN_CARD_SEID 0x08
+#define ICCE_TAG_LEN_READER_KEY_PARAM 0x10
+#define ICCE_TAG_LEN_READER_ID 0x10
+#define ICCE_TAG_LEN_READER_TYPE 0x06
+#define ICCE_TAG_LEN_CARD_ATC 0x04
+#define ICCE_TAG_LEN_READER_RND 0x08
+#define ICCE_TAG_LEN_CARD_ID 0x10
+#define ICCE_TAG_LEN_CARD_RND 0x08
+#define ICCE_TAG_LEN_SHA256_DIGEST 32u /* SHA256 输出长度(认证响应 73:先 TLV(9F37) 再对 TLV 字节做 SHA256) */
+/** 联调 card info(9F05)测试向量长度,与 bleICCE.c 中默认 hex 一致;正式环境由 NV 注入 */
+#define ICCE_CARD_INFO1_TEST_LEN 123u
+/* 历史:CardAuthRes 曾用明文 CardATC||CardRnd;现 0x73 内为 TLV(9F36)||TLV(9F37) 再 M2+CBC,勿用此长度作新逻辑 */
+#define ICCE_LEN_CARD_AUTH_RES_PLAIN (ICCE_TAG_LEN_CARD_ATC + ICCE_TAG_LEN_CARD_RND)
+
+/* 会话密钥派生明文:ReaderRnd(8) || CardRnd(8) || ReaderKeyParameter/9F0C(16) */
+#define ICCE_LEN_SESSION_KEY_PLAIN (ICCE_TAG_LEN_READER_RND + ICCE_TAG_LEN_CARD_RND + \
+ ICCE_TAG_LEN_READER_KEY_PARAM)
+
+/*
+ * 文档/SE 侧常见命名:ALG_AES_CBC_ISO9797_M2(AES-128-CBC + ISO/IEC 9797-1 Method 2 填充)。
+ * 本模块:icce_iso9797_m2_pad() 后 mbedtls_aes_crypt_cbc;SessionKey 用 IV=CardIV(9F0C),0x73 密文用 IV=ReaderRnd||CardRnd。
+ */
+
+/* ---------- 长安自定义 Tag ---------- */
+#define ICCE_TAG_CA_APP_RKE 0x01 /* 0x04 APP RKE控车指令 */
+#define ICCE_TAG_CA_APP_HEARTBEAT 0x02 /* 0x04 APP心跳 */
+#define ICCE_TAG_CA_VEHICLE_REQ_APP 0x03 /* 0x08 车端请求APP下发数据 */
+#define ICCE_TAG_CA_VEHICLE_STATUS 0x06 /* VAR 车辆状态数据主动上传 */
+#define ICCE_TAG_CA_RKE_PARK_COUNTER 0x07 /* VAR APP RKE/泊车控车指令计数器 */
+#define ICCE_TAG_CA_RKE_PARK_SIGNAL 0x08 /* 0x04 RKE控车码/泊车控车指令信号 */
+#define ICCE_TAG_CA_APP_CTRL_FEEDBACK 0x09 /* VAR APP控车反馈 */
+#define ICCE_TAG_CA_NORMAL_DATA 0x0A /* VAR 普通数据 */
+#define ICCE_TAG_CA_APA_DATA 0x11 /* VAR APA数据 */
+#define ICCE_TAG_CA_BACKEND_IF_ID 0x31 /* VAR 后台提供接口ID */
+#define ICCE_TAG_CA_VEHICLE_PARAM 0x40 /* VAR 车端传参;与 63 子 Tag0x40(APP心跳) 同值,按 msg/cmd 与父 Tag 区分 */
+#define ICCE_TAG_CA_BACKEND_RESP 0x61 /* VAR 后台接口响应;与 RKE 规范 0x61「APP RKE 控车指令根」同值,非 RKE03 时保留此语义 */
+#define ICCE_TAG_CA_BLE_UWB_KEY_STATUS 0x62 /* VAR 蓝牙UWB实体钥匙状态/响应;与 RKE 规范 0x62「APP 泊车控车指令根」同值,按 msg/cmd 区分 */
+#define ICCE_TAG_CA_VEHICLE_UPLOAD 0x63 /* VAR 车端数据上传;与 RKE 规范 0x63「APP 心跳数据下发根」同值,按 msg/cmd 区分 */
+#define ICCE_TAG_CA_APP_PARK_CTRL 0x71 /* VAR APP 泊车控车指令 */
+#define ICCE_TAG_CA_APP_HEARTBEAT_DATA 0x72 /* VAR APP 心跳数据下发 */
+#define ICCE_TAG_CA_RKE_FEEDBACK_PLAIN 0x73 /* VAR RKE控车反馈上传明文格式 */
+#define ICCE_TAG_CA_VEHICLE_PARK_RESP 0x82 /* VAR 车端泊车控车指令响应 */
+#define ICCE_TAG_CA_VEHICLE_HB_RESP 0x83 /* VAR 车端心跳数据响应 */
+#define ICCE_TAG_CA_SEC_CH_VEHICLE 0xF1 /* VAR 车端通过手机安全通道调用后台接口 */
+#define ICCE_TAG_CA_SEC_CH_BACKEND 0xF2 /* VAR 后台通过手机安全通道响应车端请求 */
+
+#define ICCE_TAG_LEN_CA_APP_RKE 0x04
+#define ICCE_TAG_LEN_CA_APP_HEARTBEAT 0x04
+#define ICCE_TAG_LEN_CA_VEHICLE_REQ_APP 0x08
+#define ICCE_TAG_LEN_CA_RKE_PARK_SIGNAL 0x04
+
+/*
+ * 规范表(ICCE 车辆 ICCE/蓝牙;msg=0x02, cmd=0x03,会话密钥加密)首层与内层 Tag 摘要,实现须与此一致:
+ * 手机→车 Request
+ * 0x61 APP RKE 控车:内 0x01 控车指令计数(4B) + 0x02 RKE 控车码(4B)
+ * 0x62 APP 泊车控车:内 0x01 控车指令计数(4B) + 0x02 泊车控车指令信号(VAR)
+ * 0x63 APP 心跳:内 0x40 APP 心跳(VAR)
+ * 0x64 APP C3B 泊车控车:内 0x01 控车指令计数(4B) + 0x02 C3B 泊车指令(VAR)
+ * 车→机 RKE 控车 Response(典型)
+ * 0x00 状态(1B) + 0x01 控车响应数据(VAR) + 0x71 控车反馈定义(VAR)(71 内 0x01/0x02/0x03 同下列 INNER_* 名)
+ * 0x61/0x62/0x63 可能与 ICCE_TAG_CA_* 同值,语义由 msg/cmd + 首层 Tag/嵌套 区分,勿改数值。
+ */
+#define ICCE_TAG_RKE03_RKE_CTRL_ROOT 0x61u /* 规范名:APP RKE 控车指令根;历史 ICCE_TAG_CA_BACKEND_RESP(0x61) 非本场景 */
+#define ICCE_TAG_RKE03_ROOT_RKE61 ICCE_TAG_RKE03_RKE_CTRL_ROOT
+#define ICCE_TAG_RKE03_ROOT_PARK62 0x62u /* 规范名:APP 泊车控车指令根;UWB 等见 ICCE_TAG_CA_BLE_UWB_KEY_STATUS(0x62) */
+#define ICCE_TAG_RKE03_ROOT_HB63 0x63u /* 规范名:APP 心跳数据下发根;与 ICCE_TAG_CA_VEHICLE_UPLOAD(0x63) 同值 */
+#define ICCE_TAG_RKE03_ROOT_C3B64 0x64u /* 规范名:APP C3B 泊车控车根 */
+
+/* 与 ICCE_TAG_CA_APP_PARK_CTRL(0x71) 同值:RKE 车端反馈/嵌套 71(内 0x01/0x02/0x03) */
+#define ICCE_TAG_RKE03_RKE_FEEDBACK_INNER ICCE_TAG_CA_APP_PARK_CTRL
+#define ICCE_RKE03_INNER_COUNTER 0x01u
+#define ICCE_RKE03_INNER_CTRL_CODE 0x02u
+#define ICCE_RKE03_INNER_APP_FB 0x03u /* APP 控车反馈 8B(规范:71 下 Tag03) */
+
+/* 0x61 根内子 Tag(= 上表「内 0x01/0x02」) */
+/* 0x62 根内子 Tag */
+#define ICCE_RKE03_P62_INNER_COUNTER 0x01u
+#define ICCE_RKE03_P62_INNER_PARK_SIG 0x02u
+/* 0x63 根内子 Tag:0x40 = APP 心跳 */
+#define ICCE_RKE03_H63_INNER_APP_HB 0x40u
+/* 0x64 根内子 Tag */
+#define ICCE_RKE03_C3B64_INNER_COUNTER 0x01u
+#define ICCE_RKE03_C3B64_INNER_CMD 0x02u
+
+/** RKE 控车码(4 字节,大端序,与表一致;用于 0x61/0x02 Value) */
+#define ICCE_RKE_CODE_OPEN_TRUNK 0x01010100u
+#define ICCE_RKE_CODE_CLOSE_TRUNK 0x01010200u
+#define ICCE_RKE_CODE_UNLOCK_4DOORS 0x01020100u
+#define ICCE_RKE_CODE_LOCK_4DOORS 0x01020200u
+#define ICCE_RKE_CODE_FIND_VEHICLE 0x01040100u
+
+// 迎宾解锁四门 0x01020101 0x01020101
+// 送宾闭锁四门 0x01020201 0x01020201
+#define ICCE_RKE_CODE_UNLOCK_4DOORS_WELCOME 0x01020101u
+#define ICCE_RKE_CODE_LOCK_4DOORS_WELCOME 0x01020201u
+
+
+/** 帧头:仅包含 SOF(校验)/Length/Control/FSN,不含 body 内容 */
+typedef struct {
+ uint16_t body_len; /* 从 Control 到 CheckSum(含)的字节数,= 线上 Length 字段值 + 2 */
+ uint8_t control; /* 原始 Control 字节 */
+ uint8_t fragment_type; /* 0=完整 1=分包开始 2=过程 3=分包结束 */
+ uint8_t is_async; /* 0=同步响应 1=异步响应 */
+ uint8_t is_encrypted; /* 0=不加密 1=加密 */
+ uint8_t is_request; /* 方向位:0=对端为 response 帧, 1=对端为 request 命令帧(同 header 中 Control 方向位) */
+ uint8_t fsn; /* 帧序号 */
+ uint8_t checksum_ok; /* 1=CRC 校验通过 0=未校验或失败 */
+} icce_frame_header_t;
+
+/** 帧 body:message_id + command_id + payload(type, length, data),payload 为原始 TLV 段 */
+typedef struct {
+ uint8_t message_id;
+ uint8_t command_id;
+ uint16_t payload_len; /* 原始 payload 长度(type+length+data) */
+ const uint8_t *payload_data; /* 指向 payload,不持有内存 */
+} icce_frame_body_t;
+
+/** 完成组包后对 payload 做 TLV 解析得到的结果(仅 payload 的 type/length/data 解析) */
+typedef struct {
+ uint16_t tag_number; /* TLV Tag(1 字节 0x00~0xFF,2 字节如 0x9F0A) */
+ uint16_t value_len; /* Value 长度 */
+ const uint8_t *value; /* 指向 Value 数据,不持有内存 */
+} icce_parsed_body_t;
+
+/** 单条 TLV 节点(命令形式解析:含嵌套;value 指向原始 payload 内) */
+typedef struct {
+ uint16_t tag_number;
+ uint16_t value_len;
+ const uint8_t *value;
+ uint8_t depth; /* 0=顶层顺序 TLV;递增表示 Tag01 内 APDU、77/73 内子 TLV */
+} icce_tlv_parse_node_t;
+
+#ifndef ICCE_PAYLOAD_TLV_MAX_NODES
+#define ICCE_PAYLOAD_TLV_MAX_NODES 64u
+#endif
+
+/** 整段 payload 递归解析结果(与 icce_payload_tlv_dump 下钻规则一致) */
+typedef struct {
+ uint16_t count; /* 已填入 node 条数 */
+ uint8_t truncated; /* 1:超过 ICCE_PAYLOAD_TLV_MAX_NODES,后续未收录 */
+ icce_tlv_parse_node_t node[ICCE_PAYLOAD_TLV_MAX_NODES];
+} icce_payload_tlv_list_t;
+
+/**
+ * 解析一帧:仅输出 header(SOF/Length/Control/FSN),不解析 body;body 以原始指针+长度返回供组包使用。
+ * 完成组包后由调用方通过 icce_body_parse 统一解析 body。
+ * @param out_body_raw 输出 body 原始数据指针(指向 raw 内,即 message_id 起)
+ * @param out_body_raw_len 输出 body 原始长度(message_id + command_id + payload,不含 checksum)
+ * @return 0 成功,<0 失败(-1 长度不足,-2 SOF 错误,-3 长度不一致,-4 CRC 错误)
+ */
+int icce_frame_parse(const uint8_t *raw, uint16_t raw_len,
+ icce_frame_header_t *out_header,
+ const uint8_t **out_body_raw, uint16_t *out_body_raw_len);
+
+/**
+ * 统一入口:解析 body 原始数据(message_id + command_id + payload)为 icce_frame_body_t。
+ * 若 header.is_encrypted=1:AES-128-CBC 解密 Key=派生 SessionKey,IV=SessionIV(ReaderRnd||CardRnd),
+ * 去填充为 ISO9797-1 M2(与规范 ALG_AES_CBC_ISO9797_M2 一致);须已完成取处理数据并派生会话密钥。
+ * 解析后再由上层对 payload 做 icce_payload_tlv_parse_command(多 TLV + 嵌套)或 icce_tlv_parse(单 TLV)。
+ *
+ * @param header 当前帧 header(用于判断是否加密)
+ * @param body_raw/body_raw_len 原始 body(message_id 起,不含 checksum)
+ * @param out_body 输出解析结果;如发生解密,payload_data 将指向 body_plain_buf 内部
+ * @param body_plain_buf/body_plain_cap 解密输出缓冲(仅在加密帧需要,建议 >= body_raw_len)
+ * @return 0 成功,<0 失败(-1 长度不足,-2 未配置解密,-3 缓冲不足,-4 解密失败)
+ */
+int icce_body_parse(const icce_frame_header_t *header,
+ const uint8_t *body_raw, uint16_t body_raw_len,
+ icce_frame_body_t *out_body,
+ uint8_t *body_plain_buf, uint16_t body_plain_cap);
+
+/** 完整 body 内容上报(单帧完整或分帧重组后的统一入口) */
+typedef struct {
+ uint8_t client_id;
+ uint16_t conn_id;
+ uint8_t message_id;
+ uint8_t command_id;
+ uint16_t tag_number; /* 首个「顶层」TLV 的 Tag,与 payload_data 一致;多 TLV 见 tlv_list */
+ uint16_t payload_len;
+ const uint8_t *payload_data; /* 首个顶层 TLV 的 Value;完整树见 tlv_list */
+ uint8_t is_encrypted;
+ uint8_t is_request; /* 方向位:0=对端 response, 1=对端 request(同 Control 方向位) */
+ icce_app_command_kind_t app_command; /* TLV 解析后归类的具体命令,见 icce_app_command_kind_t */
+ icce_payload_tlv_list_t tlv_list; /* 命令形式:多 TLV 递归解析(含 Tag01/77/73 内层) */
+} icce_body_event_t;
+
+typedef void (*icce_body_handler_t)(const icce_body_event_t *ev);
+
+/** 注册“完整 body”统一处理回调,收到完整消息(单帧或重组后)时调用;仅支持一个 handler,重复注册覆盖 */
+void ble_icce_register_body_handler(icce_body_handler_t handler);
+
+/**
+ * 从 buf 起始解析一个 TLV(Tag + Length + Value),填充 out,value 指向 Value 起始。
+ * @return 成功返回 Tag+Length 占用字节数,<0 失败(-1 长度不足,-2 非法 Length)
+ */
+int icce_tlv_parse(const uint8_t *buf, uint16_t buf_len, icce_tlv_header_t *out);
+
+/**
+ * 命令形式 payload:按与 icce_payload_tlv_dump 相同规则递归解析全部 TLV(顶层顺序 + Tag01 内 C-APDU/R-APDU + 77/73/3C 内层)。
+ * @return 0 成功(count 可能为 0);-1 参数非法
+ */
+int icce_payload_tlv_parse_command(const uint8_t *payload, uint16_t payload_len, icce_payload_tlv_list_t *out);
+
+/**
+ * 遍历 payload 中全部 TLV 并输出日志(含 3C/77/73 等容器 Tag 内一层子 TLV,不依赖 constructed 位以免误判 9Fxx)。
+ */
+void icce_payload_tlv_dump(const uint8_t *payload, uint16_t payload_len);
+
+/** 将数据以十六进制完整打印(每行 16 字节,多行),便于查看整帧/整段内容 */
+void icce_hex_dump_log(const char *label, const uint8_t *data, uint16_t len);
+
+/** Tag 可读名(静态字符串,仅供日志/UI;未知 Tag 返回 "?") */
+const char *icce_tlv_tag_label(uint16_t tag_number);
+
+/** 应用命令枚举可读名(日志/UI) */
+const char *icce_app_command_kind_str(icce_app_command_kind_t kind);
+
+/**
+ * 长安实际定义指令解析与分发:根据 tag_number(TLV 解析出的 Tag)通过 switch 对应到各指令,
+ * 具体业务处理可在各 case 内补充。可在 body_handler 中调用。
+ */
+void icce_changan_dispatch(const icce_body_event_t *ev);
+
+/* 应用层直接复用 protocol 层的命令枚举类型 */
+typedef icce_vehicle_cmd_t icce_vehicle_cmd_id_t;
+
+/** 发起 ICCE 服务发现并订阅状态通知 (client_id 由上层传入,通常为 0) */
+uint8_t ble_icce_setup_and_subscribe(uint8_t client_id, uint16_t conn_id);
+
+/** 订阅/取消订阅车辆状态 Notify */
+uint8_t ble_icce_subscribe_status(uint8_t client_id, uint16_t conn_id, uint8_t enable);
+
+/** 发送车辆控制命令(GATT 载荷 = cmd_id 1 字节 + payload,与完整 ICCE 线帧二选一) */
+uint8_t ble_icce_send_vehicle_cmd(uint8_t client_id, uint16_t conn_id,
+ icce_vehicle_cmd_id_t cmd_id, const uint8_t *payload, uint16_t payload_len);
+
+/** 发送完整 ICCE 线帧(以 0x5A 起始),不在帧前附加 cmd_id;规范组包/取数据回应应使用本接口 */
+uint8_t ble_icce_send_icce_frame_raw(uint8_t client_id, uint16_t conn_id,
+ const uint8_t *frame, uint16_t frame_len);
+
+/**
+ * 统一发送接口:组 ICCE 帧(SOF/Length/Control/FSN/body/payloadTLV/CRC)并发送。
+ * 底层使用 ble_icce_send_icce_frame_raw,整段以 5A 下发。
+ *
+ * @param is_request 1=request, 0=response
+ * @param is_async 1=异步响应, 0=同步响应(需要立即回复的场景)
+ * @param is_encrypted 1=与收包 icce_body_parse 一致:整 body 为 M2 填充后 AES-128-CBC(SessionKey, ReaderRnd||CardRnd),
+ * 需已成功取数并派生 SessionKey;0=明文 body
+ * @param message_id body.message_id
+ * @param command_id body.command_id
+ * @param tag_number payload TLV Tag(1 字节 0x00~0xFF,2 字节如 0x9F0A)
+ * @param value/value_len payload TLV Value
+ * @return 0 成功,非 0 失败
+ */
+uint8_t ble_icce_send_frame(uint8_t client_id, uint16_t conn_id,
+ uint8_t is_request, uint8_t is_async, uint8_t is_encrypted,
+ uint8_t message_id, uint8_t command_id,
+ uint16_t tag_number, const uint8_t *value, uint16_t value_len);
+
+/**
+ * 发送 RKE 远程控车指令(规范:msg=ICCE_MSG_RKE_CTRL, cmd=ICCE_CMD_RKE_REMOTE_CTRL;顶层 TLV 0x61,
+ * 内层 0x01 计数(4B 大端) + 0x02 控车码(4B 大端),与 ICCE_RKE_CODE_* 一致)。
+ * 方向:手机/钥匙 → 车(request)。**固定对整段 body 做 M2+AES-CBC**(须已取处理数据并派生 SessionKey)。
+ * 使用当前长安 ICCE BLE 连接:`g_changan_icce_sub_client_id` / `g_changan_icce_sub_conn_id`(见 bleService.h),无连接时返回非 0。
+ * @return 0 成功,非 0 失败
+ */
+uint8_t ble_icce_send_rke03_vehicle_control_ex(uint32_t counter_be, uint32_t control_code_be);
+
+/** 同上,命令计数器使用内部自增(从 1 起,断链后 ble_icce_clear_by_conn 复位) */
+uint8_t ble_icce_send_rke03_vehicle_control(uint32_t control_code_be);
+
+/** 断开时清理该连接的 ICCE 服务信息 */
+void ble_icce_clear_by_conn(uint8_t client_id, uint16_t conn_id);
+
+/**
+ * GAP 直接连接指定 BLE 地址(与 AT^CHANGAN_ICCE_CONNECT 一致)。
+ * bd_addr_t 的字节序须同 ChangAan/changan_parse_bt_address:对人眼 MAC 从左到右按反序写入 addr[0]..[5]。
+ */
+bool ble_icce_connect_to_device(bd_addr_t *addr);
+
+/**
+ * 处理一帧 ICCE Notify 原始数据(与 GATT notify 回调内逻辑一致,可用于 AT 注入联调)。
+ * @param client_id / conn_id 与当前 BLE 连接一致,分片重组按 conn_id 索引。
+ */
+void ble_icce_notify_frame_process(uint8_t client_id, uint16_t conn_id, const uint8_t *data, uint16_t len);
+
+#ifndef BLE_ICCE_CHANGAN_AUTH_CARD_STORE_PREFIX
+/** 钥匙落盘路径前缀;完整路径为 prefix + 车辆 id(仅字母数字与 _-)+ ".bin",一车一文件;文件头内仍保存蓝牙地址。 */
+#define BLE_ICCE_CHANGAN_AUTH_CARD_STORE_PREFIX "/user/icce_changan_auth_"
+#endif
+
+/**
+ * 长安数字钥匙:写入卡身份(TLV 5A 用 8B、9F3B CardID 16B、9F05 CardInfo1)并可选写入协议主密钥 DKey。
+ * @param ble_addr 车端 BLE 地址;写入落盘文件头(可为 NULL,则头内地址域填 0)。
+ * @param changan_vehicle_car_id 长安控车/数字钥匙侧车辆 id(与 download-owner-key 请求中 carId 一致);非 NULL 且非空时
+ * 将卡数据写入 BLE_ICCE_CHANGAN_AUTH_CARD_STORE_PREFIX + 净化后的车辆 id + ".bin"(一车一钥匙文件)。
+ * 为 NULL 或空串时仅更新内存,不写文件。
+ * @param card_seid 指向 8 字节,常为 BLE 线 TLV 5A 载荷;download-owner-key 解密路径下规范 CardInfo 无独立 SEID 时由调用方用 CardID 前 8B 等填充。
+ * @param opt_dkey_master_16 非 NULL 时写入 16B 主密钥 DKey(与 download-owner-key 明文 dkey 一致);NULL 则不修改 DKey。派生 SessionKey 时的 9F0C 仍来自 BLE 缓存 g_icce_auth_cache_key_param,不使用已删除的全局 CardIV。
+ */
+void ble_icce_changan_set_auth_card_identity(const bd_addr_t *ble_addr, const char *changan_vehicle_car_id,
+ const uint8_t card_seid[ICCE_TAG_LEN_CARD_SEID],
+ const uint8_t card_id[ICCE_TAG_LEN_CARD_ID], const uint8_t card_info1[ICCE_CARD_INFO1_TEST_LEN],
+ const uint8_t *opt_dkey_master_16);
+
+/**
+ * 指定车辆是否已具备可用的长安 ICCE 卡身份。
+ * 若内存中 TLV5A 用 8B 与 CardInfo1 均已非空(及 CardID),直接返回 true。
+ * 否则若对应落盘文件存在且格式与内容有效,则将文件中 8B、CardID、CardInfo1 读入内存缓存后返回 true。
+ * @param changan_vehicle_car_id 与 download-owner-key / set_auth 使用的车辆 id 一致;NULL 或空串返回 false。
+ */
+bool ble_icce_changan_auth_card_identity_ready(const char *changan_vehicle_car_id);
+
+/** AT:ZhixingApp GPDPayload 同刻向量会话密钥派生自测(与 icce_session_key_selftest.c 金样一致),不改动运行时演示数据 */
+void ble_icce_changan_session_key_zhixing_at_test(void);
+
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* BLE_ICCE_H */
-/**\r
- * Copyright (c) CompanyNameMagicTag 2023-2023. All rights reserved.\r
- * Description: alipay bluetooth module.\r
- * Author:\r
- * Create:\r
- */\r
-\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif\r
-\r
-#include "common_def.h"\r
-#include "bts_def.h"\r
-#include "bts_gatt_stru.h"\r
-#include "bts_a2dp_source.h"\r
-#include "bts_gatt_server.h"\r
-#include "bts_le_gap.h"\r
-#include "osal_task.h"\r
-#include "securec.h"\r
-#include "wearable_log.h"\r
-#include <stdint.h>\r
-#include <stdio.h>\r
-#include "stdbool.h"\r
-\r
-#include "bts_le_gap.h"\r
-#include "bts_br_gap.h"\r
-\r
-#ifdef SUPPORT_BATTERY_SERVICE\r
-#include "battery_hal.h"\r
-#endif\r
-\r
-#include "bleService.h"\r
-#ifdef SUPPORT_ALIPAY_SEC\r
-#include "alipay_feature.h"\r
-#endif\r
-#ifdef AILPAY_SUPPORT\r
-// #include "alipay_bluetooth.h"\r
-#endif\r
-#include "bts_a2dp_sink.h"\r
-#include "osal_timer.h"\r
-#include "bleEvent.h"\r
-#ifdef SUPPORT_HID_SERVICE\r
-#include "hidService.h"\r
-#endif\r
-#ifdef SUPPORT_FACTORY_SERVICE\r
-#include "factorytestService.h"\r
-#endif\r
-#ifdef SUPPORT_PPG_BLE_SERVICE\r
-#include "ppgBleService.h"\r
-#endif\r
-\r
-#include "build_version.h"\r
-#include "custom_runtime.h"\r
-#include "custom_utils.h"\r
-#ifdef BLE_INSTRUCT\r
-#ifdef BLE_INSTRUCT\r
-#include "bleInstruct.h"\r
-#endif\r
-#endif\r
-\r
-#include "ConfigModelC.h"\r
-#ifdef SUPPORT_CYWEE_BLE_SERVICE\r
-#include "cywee_ble_service.h"\r
-#endif\r
-#ifdef SUPPORT_OHOSFWK\r
-#include "BluetoothWrapper.h"\r
-#endif\r
-#include "custom_save_runtime.h"\r
-\r
-\r
-// extern void bts_data_to_uuid_len2(uint16_t uuid_data, bt_uuid_t *out_uuid);\r
-// extern void bts_init_128bit_uuid(const bt_uuid_t *uuid);\r
-// #include "ble_hid_take_photo_server.h"\r
-/* Gatt service UUID */\r
-#define BLE_SERVICE_UUID 0x18e0\r
-/* Gatt Characteristic UUID */\r
-//自定义 ota 文件传输特征值\r
-#define BLE_ZHIHUI_OTA_ID 0x2ae6\r
-#define BLE_ZHIHUI_OTA_REPLY_ID 0x2ae7\r
-\r
-#define BLE_ZHIHUI_AI_ID 0x2ae8\r
-\r
-#define BLE_CHARACTERISTIC_RECV_ID 0x2ae5\r
-#define BLE_CHARACTERISTIC_SNED_SHORT_ID 0x2ae3\r
-\r
-#define BLE_CHARACTERISTIC_SNED_LONG_ID 0x2ae4\r
-#define BLE_CHARACTERISTIC_SNED_OTA_ID 0x2ae0\r
-#define BLE_CHARACTERISTIC_SNED_ANDRIOD_ID 0x2ae1\r
-#define BLE_CHARACTERISTIC_READ_BATTERY_ID 0x2ae2\r
-/* Client Characteristic Configuration UUID */\r
-#define BLE_UUID_CLIENT_CHARACTERISTIC_CONF 0x2902\r
-/*user Characteristic Configuration UUID*/\r
-#define BLE_UUID_USER_CHARACTERISTIC_CONF 0x2901\r
-/* Gatt Characteristic max length */\r
-#define BLE_CHARACTERISTIC_MAX_LENGTH 256\r
-#define BLE_ADV_ID 1\r
-#define BLE_ADV_DATA_MAX_LENGTH 31\r
-#define BLE_ADV_BLE_NAME_MAX_LENGTH 31 // 31-4-2-3-9 = 13\r
-#define BLE_NAME_LENGTH 32\r
-#define BLE_ADV_MAC_HEAD_LENTH 4\r
-#define BLE_ADV_MAC_LENTH 10\r
-#define BLE_SCAN_DATA_LENTH 31 //扫描数据\r
-#define BLE_ADV_TYPE_LENTH 3\r
-#define BLE_ADV_UUID_LENTH 4\r
-\r
-#define BLE_DEFAULT_NAME_LEN 32\r
-#define BLE_MAC_MAX_LEN 6 //蓝牙mac地址最大个数6个\r
-\r
-\r
-\r
-#define SWAP_U16(x) ((uint16_t)((((uint16_t)(x) & (uint16_t)0x00ffU) << 8) | \\r
- (((uint16_t)(x) & (uint16_t)0xff00U) >> 8)))\r
-\r
-static uint8_t exit_alipay_gui = 0;\r
-// 蓝牙模块全局变量\r
-static gap_ble_callbacks_t g_ble_gapble_cbs;\r
-static gatts_callbacks_t g_ble_gatts_cbs;\r
-static gap_call_backs_t g_btGapCallBacks;\r
-\r
-\r
-static bool g_ble_adv_start_state = false;\r
-uint16_t g_ble_server_id = 1;\r
-\r
-static uint16_t g_ble_read_handle = 0;\r
-uint16_t g_ble_conn_id = 0;\r
-uint16_t g_ble_Alipay_conn_id = 0;\r
-uint16_t g_ble_server_handle = 0;\r
-static uint8_t g_ble_character_buf[BLE_CHARACTERISTIC_MAX_LENGTH] = {0};\r
-static const uint8_t ble_adv_type[BLE_ADV_TYPE_LENTH] = {2, 1, 0xA};\r
-static const uint8_t ble_adv_uuid[BLE_ADV_UUID_LENTH] = {0x3, 0x3, 0xe0, 0x18};\r
-static const uint8_t ble_adv_tx[4] = {0x03,0x03,0xe0,0x18};\r
-static bool AdverFlag = false;\r
-\r
-static uint8_t scan_data[BLE_SCAN_DATA_LENTH] = {0};\r
-\r
-uint8_t phone_mac_data[6]={0};\r
-\r
-#define ble_add_max_num 10\r
-static bd_addr_t phone_addr[ble_add_max_num]={0};\r
-static uint16_t ble_conn_id[ble_add_max_num]={0};\r
-\r
-\r
-bd_addr_t disconect_addr;//断开连接地址不需要反序\r
-\r
-uint8_t Bleconnect = 0;//蓝牙默认是断开 0 1 为连接\r
-uint8_t devpair_state = 0;//设备配对状态 0 未配对 1已配对成功\r
-uint8_t bond_flag = 0;//绑定标识\r
-uint16_t ble_nus_max_data_len = SDK_BLE_MTU_MIN - 3; \r
-\r
-uint16_t data2ae3Cmd = 0;//2ae3短指令特征值\r
-uint16_t data2ae4Cmd = 0;\r
-uint16_t data2ae5Cmd = 0;\r
-uint16_t data2ae2Cmd = 0;//read\r
-uint16_t data2ae1Cmd = 0;//安卓消息来电\r
-uint16_t data2ae0Cmd = 0;//OTA\r
-uint16_t data2ae6Cmd = 0;//自定义OTA \r
-uint16_t data2ae7Cmd = 0;//自定义OTA \r
-uint16_t data2ae8Cmd = 0;//AI\r
-\r
-#define handle_max_len 40\r
-\r
-static uint16_t Is_value_handle[handle_max_len]={0};\r
-\r
-static uint32_t handle_num=0;\r
-\r
-\r
-void get_phone_addr(bd_addr_t *addr,uint16_t conn_id)\r
-{\r
- if (addr==NULL)\r
- return;\r
-\r
- for(int i=0;i<ble_add_max_num;i++)\r
- {\r
- if(conn_id==ble_conn_id[i])\r
- {\r
- memcpy(addr,&phone_addr[i],sizeof(bd_addr_t));\r
- }\r
- }\r
- \r
-}\r
-static uint16_t add_num=0;\r
-\r
-static void set_phone_info(bd_addr_t *addr,uint16_t conn_id)//保存手机信息 包含手机mac地址\r
-{\r
- memcpy(&phone_addr[add_num],addr,sizeof(bd_addr_t));\r
- ble_conn_id[add_num]=conn_id;\r
-\r
- add_num++;\r
- if(add_num==ble_add_max_num)\r
- {\r
- add_num=0;\r
- }\r
-}\r
-\r
-\r
-static void clean_phone_info(uint16_t conn_id)//保存手机信息 包含手机mac地址\r
-{\r
- for(int i=0;i<ble_add_max_num;i++)\r
- {\r
- if(conn_id==ble_conn_id[i])\r
- {\r
- bd_addr_t addr={0};\r
- memcpy(&phone_addr[i],&addr,sizeof(bd_addr_t));\r
- ble_conn_id[i]=0;\r
- return;\r
- }\r
- }\r
-}\r
-\r
-\r
-bool get_ble_connect(void)//保存手机信息 包含手机mac地址\r
-{\r
- for(int i=0;i<ble_add_max_num;i++)\r
- {\r
- if(ble_conn_id[i]!=0)\r
- {\r
- return true;\r
- }\r
- }\r
- return false;\r
-}\r
-\r
-bool get_Alipay_ble_connect(void)//保存手机信息 包含手机mac地址\r
-{\r
- uint8_t connect=0;\r
- for(int i=0;i<ble_add_max_num;i++)\r
- {\r
- if(ble_conn_id[i]!=0)\r
- {\r
- if(g_ble_Alipay_conn_id==ble_conn_id[i])\r
- return true;\r
- }\r
- }\r
-\r
- {\r
- return false;\r
- }\r
-\r
-}\r
-\r
-enum{\r
- BLE_CHARACTERISTIC_RECV_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_NOTIFY|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP|GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_READ,\r
- BLE_CHARACTERISTIC_SNED_SHORT_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,\r
- BLE_CHARACTERISTIC_SNED_LONG_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,\r
- BLE_CHARACTERISTIC_SNED_OTA_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,\r
- BLE_CHARACTERISTIC_SNED_ANDRIOD_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,\r
- BLE_CHARACTERISTIC_READ_BATTERY_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_READ|GATT_CHARACTER_PROPERTY_BIT_NOTIFY,\r
- BLE_ZHIHUI_OTA_ID_ID_PROPERTIES=GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,\r
- BLE_ZHIHUI_AI_ID_ID_PROPERTIES=GATT_CHARACTER_PROPERTY_BIT_NOTIFY|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP|GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_READ,\r
- BLE_ZHIHUI_OTA_REPLY_ID_PROPERTIES=GATT_CHARACTER_PROPERTY_BIT_NOTIFY|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP|GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_READ,\r
-};\r
-static uint8_t ble_adv_falg = 0;\r
-static bool g_custom_ble_init_flag = false;\r
-\r
-errcode_t svr_ble_adv_stop(void)\r
-{\r
- ble_adv_falg = 0;\r
- return gap_ble_stop_adv(BLE_ADV_ID);\r
-}\r
-void svr_ble_adv_start(void)\r
-{\r
- ble_adv_falg = 1;\r
- if(AdverFlag==true)\r
- gap_ble_start_adv(BLE_ADV_ID);\r
-}\r
-\r
-\r
-void br_adv_start(uint8_t sec)\r
-{\r
- //ble广播开启\r
- svr_ble_adv_start_param();\r
-\r
- if(!get_br_is_pair())\r
- { \r
-\r
- }\r
-}\r
-\r
-void br_adv_stop(void)\r
-{\r
- gap_br_set_bt_scan_mode(GAP_SCAN_MODE_NONE, 0);\r
-}\r
-//留档保存,方便后面查看此数据是否正确\r
-static uint8_t save_adv_data[BLE_ADV_DATA_MAX_LENGTH] = {0};\r
-\r
-void get_adv_data(char *data)\r
-{\r
- uint32_t data_len=0;\r
- for(int i=0;i<BLE_ADV_DATA_MAX_LENGTH;i++)\r
- {\r
- char UintBUF[3]={0};\r
- sprintf(UintBUF,"%02X",save_adv_data[i]);\r
- memcpy_s(data+data_len,2,UintBUF,2);\r
- data_len+=2;\r
- }\r
-\r
-}\r
-\r
-/* adapt ios adv data. *///设置广播和扫描数据\r
-static void svr_ble_adv_data_set(int adv_id)\r
-{\r
- uint8_t ble_name[BLE_NAME_LENGTH] = {0};\r
- uint8_t ble_name_len = BLE_NAME_LENGTH;\r
- uint8_t adv_data[BLE_ADV_DATA_MAX_LENGTH] = {0};\r
- uint8_t adv_data_len = 0;\r
- uint8_t scan_data_len = 0;\r
- uint8_t ble_data_name[BLE_ADV_BLE_NAME_MAX_LENGTH + 1 ] = {0}; // +TYPE LENGTH\r
- uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};\r
- uint8_t adv_mac_head[BLE_ADV_MAC_LENTH] = {0x9, 0x16, 0x02, 0x38};\r
- gap_ble_config_adv_data_t adv_data_info;\r
- memset_s(&adv_data_info, sizeof(gap_ble_config_adv_data_t), 0, sizeof(gap_ble_config_adv_data_t));\r
- unsigned char addr[BLE_MAC_MAX_LEN] = {0};\r
- unsigned int len = BLE_MAC_MAX_LEN;\r
- errcode_t ret = 0;\r
-\r
- memset(addr,0,6); \r
- bluetooth_get_local_addr(&addr[0],len);\r
- ret = bluetooth_get_local_name(ble_name, &ble_name_len);\r
- if (ret != 0) {\r
- memset_s(ble_name, BLE_NAME_LENGTH, 0, BLE_NAME_LENGTH);\r
- (void)sprintf_s((char*)ble_name, BLE_NAME_LENGTH, "%s %02X%02X",BLE_DEFAULT_NAME,addr[1],addr[0]);\r
- ble_name_len = strlen((char*)ble_name) + 1; \r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_get_local_name fail,rename name:%s,len:%u,ret:%u.", ble_name, ble_name_len, ret);\r
- }\r
- int k = BD_ADDR_LEN;\r
- for (int i = 0; i < BD_ADDR_LEN; i++) {\r
- ble_data_mac_switch[--k] = addr[i];\r
- }\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_get_local_name name:%s,len:%u,ret:%u.", ble_name, ble_name_len, ret);\r
- memcpy_s(adv_data, sizeof(ble_adv_type), ble_adv_type, sizeof(ble_adv_type));//0x02 0x01 0x02\r
- adv_data_len = sizeof(ble_adv_type);\r
- // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"adv_data_len!!!!:%d\r\n",adv_data_len);\r
-\r
- // 2. 添加心率服务UUID(0x180D)\r
- if(uapi_dev_runtime_get_hrs_ble_status())\r
- {\r
- // 格式:[长度(0x03)][类型(0x03)][UUID低字节(0x0D)][UUID高字节(0x18)]\r
- if (adv_data_len + 4 <= BLE_ADV_DATA_MAX_LENGTH) {\r
- adv_data[adv_data_len++] = 0x03; // 长度:3字节(类型+UUID)\r
- adv_data[adv_data_len++] = 0x03; // 类型:16位服务UUID列表\r
- adv_data[adv_data_len++] = 0x0D; // 心率服务UUID低字节\r
- adv_data[adv_data_len++] = 0x18; // 心率服务UUID高字节\r
- } else {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "No space for heart rate UUID");\r
- }\r
- }\r
-\r
- adv_data[adv_data_len++] = 0x0f;//长度 \r
- adv_data[adv_data_len++] = 0xff;//数据类型 manufactory data\r
-#if defined(BOARD_W9) \r
- adv_data[adv_data_len++] = 'W';\r
- adv_data[adv_data_len++] = '9';\r
-// #elif defined(BOARD_N9)\r
-// adv_data[adv_data_len++] = 'N';\r
-// adv_data[adv_data_len++] = '9';\r
-#else \r
- adv_data[adv_data_len++] = 'J';\r
- adv_data[adv_data_len++] = 'H';\r
-#endif\r
- adv_data[adv_data_len++] = bond_flag;//是否绑定\r
- adv_data[adv_data_len++] = ble_data_mac_switch[5];\r
- adv_data[adv_data_len++] = ble_data_mac_switch[4];\r
- adv_data[adv_data_len++] = ble_data_mac_switch[3];\r
- adv_data[adv_data_len++] = ble_data_mac_switch[2];\r
- adv_data[adv_data_len++] = ble_data_mac_switch[1];\r
- adv_data[adv_data_len++] = ble_data_mac_switch[0];\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "adv_data_info.adv_length.adv_data_len:%d\r\n",adv_data_len);\r
-#if defined(BOARD_W9) \r
- adv_data[adv_data_len++] = 0x06; //w9 app\r
- adv_data[adv_data_len++] = 0x06;\r
-// #elif defined(BOARD_N9) \r
-// adv_data[adv_data_len++] = 0x07; //n9 app\r
-// adv_data[adv_data_len++] = 0x07;\r
-#else\r
- adv_data[adv_data_len++] = 0x05;\r
- adv_data[adv_data_len++] = 0x05;\r
-#endif\r
-\r
- uint8_t _major,_mid,_minor;\r
- uapi_get_fw_version(&_major,&_mid,&_minor);\r
- adv_data[adv_data_len++] = _major;\r
- adv_data[adv_data_len++] = _mid;\r
- adv_data[adv_data_len++] = _minor;\r
- \r
- if(adv_data_len > BLE_ADV_DATA_MAX_LENGTH)\r
- {\r
- adv_data_len = BLE_ADV_DATA_MAX_LENGTH;\r
- }\r
-\r
- //scan_data \r
- if (ble_name_len > BLE_ADV_BLE_NAME_MAX_LENGTH) {\r
- ble_name_len = BLE_ADV_BLE_NAME_MAX_LENGTH;\r
- }\r
- ble_data_name[0] = ble_name_len;\r
- ble_data_name[1] = 0x9;\r
- memcpy_s(&ble_data_name[2], ble_name_len - 1, ble_name, ble_name_len - 1);\r
-\r
- memcpy_s(scan_data + scan_data_len, ble_name_len + 1, ble_data_name, ble_name_len + 1);\r
-\r
- scan_data_len = scan_data_len + ble_name_len + 1;\r
- // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"scan_data_len!!!22:%d ble_name_len:%d\r\n",scan_data_len,ble_name_len);\r
- memcpy_s(scan_data + scan_data_len, sizeof(ble_adv_uuid), ble_adv_uuid, sizeof(ble_adv_uuid));//这是tx power\r
- scan_data_len = scan_data_len + sizeof(ble_adv_uuid);\r
- // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"scan_data_len!!!!3333:%d\r\n",scan_data_len);\r
- \r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble_info:%02x:%02x:%02x:%02x:%02x:%02x", ble_data_mac_switch[0], ble_data_mac_switch[1],\r
- ble_data_mac_switch[2], ble_data_mac_switch[3], ble_data_mac_switch[4], ble_data_mac_switch[5]); \r
- \r
- memcpy_s(adv_mac_head + BLE_ADV_MAC_HEAD_LENTH, BD_ADDR_LEN, ble_data_mac_switch, BD_ADDR_LEN);\r
-\r
- memcpy_s(scan_data + scan_data_len, sizeof(adv_mac_head), adv_mac_head, sizeof(adv_mac_head));\r
- scan_data_len = scan_data_len + sizeof(adv_mac_head);\r
- // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"adv_data_len!!!!4444:%d\r\n",scan_data_len);\r
- \r
-\r
- if (scan_data_len > BLE_SCAN_DATA_LENTH){\r
- scan_data_len = BLE_SCAN_DATA_LENTH;\r
- }\r
- //\r
- memcpy_s(save_adv_data,BLE_ADV_DATA_MAX_LENGTH,adv_data,BLE_ADV_DATA_MAX_LENGTH);\r
- \r
- adv_data_info.scan_rsp_data = scan_data;//扫描数据\r
- adv_data_info.scan_rsp_length = scan_data_len;//扫描长度\r
- adv_data_info.adv_data = adv_data;//广播数据 \r
- adv_data_info.adv_length = adv_data_len;//广播长度\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "adv_data_info.adv_length:%u. scan_data_len:%d\r\n", adv_data_len,scan_data_len);\r
-\r
- gap_ble_set_adv_data(adv_id, &adv_data_info);\r
-\r
- return;\r
-}\r
-\r
-\r
-void svr_ble_adv_factory_test_start_param(void)\r
-{\r
- errcode_t ret = 0;\r
- int adv_id = BLE_ADV_ID;\r
- if (ble_adv_falg == 1) { //已经开始广播了,不需要重复开启广播\r
- ret=gap_ble_stop_adv(adv_id);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble adv need restart , gap_ble_stop_adv ret %x\n",ret);\r
- osDelay(50);\r
- }\r
-\r
- gap_ble_adv_params_t adv_para;\r
- memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));\r
-\r
- adv_para.min_interval = 0x64;//0x640;\r
- adv_para.max_interval = 0x64;\r
- adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;\r
- //adv_para.tx_power=20;\r
- adv_para.channel_map = 0x07;\r
- adv_para.duration = 0;\r
-\r
- gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数\r
- gap_ble_set_local_appearance(GAP_BLE_APPEARANCE_TYPE_GENERIC_WATCH);//仅是手表\r
- svr_ble_adv_data_set(adv_id);//开始广播和扫描数据\r
- ble_adv_falg = 1;\r
- ret = gap_ble_start_adv(adv_id);\r
- if (ret) {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_adv_start bt gap_ble_start_adv1 ret = 0x%x", ret);\r
- }\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_adv_start bt gap_ble_start_adv2 ret = 0x%x", ret);\r
-}\r
-\r
-\r
-static int8_t ble_adv_init_falg=100;\r
-\r
-static osTimerId_t ble_adv_timer=NULL;\r
-\r
-static uint32_t last_package_id=0;\r
-\r
-static void ble_adv_Timer_CallBack(int data)\r
-{\r
- ble_adv_init_falg--;\r
-\r
- if(ble_adv_init_falg<=0)\r
- {\r
- int adv_id = BLE_ADV_ID;\r
-\r
- errcode_t ret = 0;\r
- if(get_ble_adv_status())\r
- {\r
- ret=gap_ble_stop_adv(adv_id);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble adv need restart , gap_ble_stop_adv ret %x\n",ret);\r
- osDelay(50);\r
-\r
- if(!uapi_dev_runtime_get_factory_test_status_flag())\r
- {\r
- gap_ble_adv_params_t adv_para;\r
- memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));\r
- adv_para.min_interval = 0x640;\r
- adv_para.max_interval = 0x640;\r
- adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;\r
- adv_para.channel_map = 0x7;\r
- adv_para.duration = 0;\r
-\r
- ret=gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble adv need restart , gap_ble_set_adv_param ret %x\n",ret);\r
-\r
- }\r
- if(get_ble_connect()==false)\r
- {\r
- ret=gap_ble_start_adv(adv_id);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble adv need restart , gap_ble_start_adv ret %x\n",ret);\r
- }\r
- \r
-\r
- }\r
- else\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "no sdv\n");\r
- if(!uapi_dev_runtime_get_factory_test_status_flag())\r
- {\r
-\r
- gap_ble_adv_params_t adv_para;\r
- memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));\r
- adv_para.min_interval = 0x640;\r
- adv_para.max_interval = 0x640;\r
- adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;\r
- adv_para.channel_map = 0x7;\r
- adv_para.duration = 0;\r
- ret=gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble adv need restart , gap_ble_set_adv_param ret %x\n",ret);\r
-\r
- }\r
- \r
-\r
- \r
- }\r
-\r
-\r
- osTimerStop(ble_adv_timer);\r
- osTimerDelete(ble_adv_timer);\r
- ble_adv_timer = NULL;\r
- \r
- }\r
-}\r
-\r
-\r
-\r
-void svr_ble_adv_start_param(void)\r
-{\r
- errcode_t ret = 0;\r
- int adv_id = BLE_ADV_ID;\r
- if (ble_adv_falg == 1) { //已经开始广播了,不需要重复开启广播\r
- ret=gap_ble_stop_adv(adv_id);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble adv need restart , gap_ble_stop_adv ret %x\n",ret);\r
- osDelay(50);\r
- }\r
-\r
- if(ble_adv_init_falg)\r
- {\r
- gap_ble_adv_params_t adv_para;\r
- memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));\r
- adv_para.min_interval = 0x64;\r
- adv_para.max_interval = 0x64;\r
- adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;\r
- adv_para.channel_map = 0x7;\r
- adv_para.duration = 0;\r
- gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数\r
-\r
- uint32_t tick;\r
- osStatus_t retTimer;\r
- if(ble_adv_timer!=NULL)\r
- {\r
- osTimerStop(ble_adv_timer);\r
- osTimerDelete(ble_adv_timer);\r
- ble_adv_timer = NULL;\r
- }\r
-\r
- ble_adv_timer = osTimerNew((osTimerFunc_t)ble_adv_Timer_CallBack, osTimerPeriodic, NULL, NULL);\r
- tick =osMs2Tick(1000);\r
- retTimer = osTimerStart(ble_adv_timer, tick);\r
- if (retTimer != osOK && ble_adv_timer != NULL) {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"StartCallTimer osTimerStart failed, ret = %lx!!", retTimer);\r
- osTimerDelete(ble_adv_timer);\r
- ble_adv_timer = NULL;\r
- return;\r
- }\r
-\r
- }\r
- else\r
- {\r
- if(!uapi_dev_runtime_get_factory_test_status_flag())\r
- {\r
- gap_ble_adv_params_t adv_para;\r
- memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));\r
- adv_para.min_interval = 0x640;\r
- adv_para.max_interval = 0x640;\r
- adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;\r
- adv_para.channel_map = 0x7;\r
- adv_para.duration = 0;\r
- gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数\r
- }\r
- else\r
- {\r
- gap_ble_adv_params_t adv_para;\r
- memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));\r
- adv_para.min_interval = 0x64;\r
- adv_para.max_interval = 0x64;\r
- adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;\r
- adv_para.channel_map = 0x7;\r
- adv_para.duration = 0;\r
- gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数\r
- }\r
-\r
- }\r
- \r
- gap_ble_set_local_appearance(GAP_BLE_APPEARANCE_TYPE_GENERIC_WATCH);//仅是手表\r
- svr_ble_adv_data_set(adv_id);//开始广播和扫描数据\r
- ble_adv_falg = 1;\r
- ret = gap_ble_start_adv(adv_id);\r
- if (ret) {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_adv_start bt gap_ble_start_adv1 ret = 0x%x", ret);\r
- }\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_adv_start bt gap_ble_start_adv2 ret = 0x%x", ret);\r
-}\r
-\r
-void svr_ble_connstate_change_cb(unsigned short conn_id, bd_addr_t *addr, gap_ble_conn_state_t conn_state,\r
- gap_ble_pair_state_t pair_state, gap_ble_disc_reason_t disc_reason)\r
-{\r
- \r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,\r
- "svr_ble_connstate_change_cb gap_ble_conn_state_t conn_state:%d pair_state:%d disc_reason:%d\r\n",\r
- conn_state,pair_state,disc_reason);\r
-\r
- if (GAP_BLE_STATE_DISCONNECTED == conn_state) \r
- { // restart ble adv when disconnected\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "GAP_BLE_STATE_DISCONNECTED!!! \r\n");\r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_DISCONNECT);\r
-\r
- clean_phone_info(conn_id);\r
-\r
- //如果ble连接全部断连,则需要重新开启广播\r
- //可能因ble连接不够稳定,快速断开ble连接,无法将连接判定为app连接导致断连的时候没有正确重新开启广播\r
- \r
- if(conn_id==g_ble_conn_id || !get_ble_connect())\r
- {\r
- free_ble_data(); \r
- \r
- ble_disconnect_ok();\r
-\r
- g_ble_conn_id=0;\r
-\r
- //APP断连\r
- Bleconnect = GAP_BLE_STATE_DISCONNECTED;//蓝牙已断开\r
-\r
- if(get_ble_pair())\r
- {\r
- ble_ancs_client_clear(conn_id);\r
- }\r
-\r
- svr_ble_adv_start();\r
- }\r
- else if (ble_is_Alipay_bind()==true)\r
- {\r
- //如果当前页面处于支付宝界面,则重新开广播\r
- svr_ble_adv_start();\r
- }\r
-\r
- if(g_ble_Alipay_conn_id==conn_id)\r
- {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "支付宝断开连接 \r\n");\r
- }\r
- \r
- } \r
- else \r
- {\r
- devpair_state = 0;//\r
-\r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_CONNECT);\r
-\r
-\r
- if( g_ble_conn_id !=0 && conn_id!=g_ble_conn_id)\r
- {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"支付宝连接");\r
- }\r
-\r
- \r
- int ret =svr_ble_adv_stop();\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"%x",ret);\r
- \r
- set_phone_info(addr,conn_id);\r
- \r
- ble_connect_ok();\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "addr: ****%02x%02x%02x%02x \n",\r
- addr->addr[3], addr->addr[2], addr->addr[1], addr->addr[0]); /* 3 2 1 0 idx */\r
-\r
-\r
- Bleconnect = GAP_BLE_STATE_CONNECTED;//蓝牙已连接\r
- \r
-\r
- }\r
-\r
- uapi_dev_runtime_set_ble_connect_stat(Bleconnect);\r
-}\r
-\r
-static uint16_t need_update_connect_param=BLE_CONNECT_INTERVAL_HIGH;\r
-\r
-static osTimerId_t ble_connect_timer=NULL;\r
-\r
-static int8_t connect_updata_count=3;\r
-\r
-static void ble_connect_Timer_CallBack(int data)\r
-{\r
- if(get_ble_connect() && connect_updata_count>0)\r
- {\r
- gap_conn_param_update_t conn_param = { 0 };\r
- conn_param.conn_handle = g_ble_conn_id; /* param 0: conn_handle */\r
- conn_param.interval_min =need_update_connect_param; /* param 1: interval_min 1.25ms */\r
- conn_param.interval_max = need_update_connect_param; /* param 2: interval_max */\r
- conn_param.slave_latency = 6; /* param 3: slave_latency */\r
- conn_param.timeout_multiplier = 500; /* param 4: timeout_multiplier 10ms */\r
- int ret = gap_ble_connect_param_update(&conn_param);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "触发 连接参数timer更新");\r
- connect_updata_count--;\r
-\r
- }\r
- else\r
- {\r
- osTimerStop(ble_connect_timer);\r
- osTimerDelete(ble_connect_timer);\r
- ble_connect_timer = NULL;\r
- }\r
-}\r
-\r
-static uint16_t ble_interval=50; \r
-\r
-uint16_t get_ble_interval(void)\r
-{\r
- float temp_data =(float)ble_interval*1.25f;\r
-\r
- return (uint16_t)temp_data;\r
- \r
-}\r
-\r
-void srv_gap_ble_connect_param_update_callback(uint16_t conn_id, errcode_t status,\r
- const gap_ble_conn_param_update_t *param)\r
-{\r
- if(param->interval==50)\r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_CONNECT_UPDATE_50);\r
- else if(param->interval==12)\r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_CONNECT_UPDATE_12);\r
- else\r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_CONNECT_UPDATE|param->interval);\r
-\r
- ble_interval=param->interval;\r
-\r
- if(ble_connect_timer!=NULL)\r
- {\r
- osTimerStop(ble_connect_timer);\r
- osTimerDelete(ble_connect_timer);\r
- ble_connect_timer = NULL;\r
- }\r
-\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, \r
- "conn_id %d status %d gap_ble_conn_param_update_t interval %d latency%d timeout %d ",conn_id,status,param->interval,param->latency,param->timeout);\r
-}\r
-\r
-\r
-\r
-void uapi_ble_connect_param_update(uint16_t data)\r
-{\r
- gap_conn_param_update_t conn_param = { 0 };\r
- conn_param.conn_handle = g_ble_conn_id; /* param 0: conn_handle */\r
- conn_param.interval_min =data; /* param 1: interval_min 1.25ms */\r
- conn_param.interval_max = data; /* param 2: interval_max */\r
- conn_param.slave_latency = 6; /* param 3: slave_latency */\r
- conn_param.timeout_multiplier = 500; /* param 4: timeout_multiplier 10ms */\r
- int ret = gap_ble_connect_param_update(&conn_param);\r
-\r
- need_update_connect_param=data;\r
-\r
- \r
-\r
- uint32_t tick;\r
- osStatus_t retTimer;\r
- if(ble_connect_timer!=NULL)\r
- {\r
- osTimerStop(ble_connect_timer);\r
- osTimerDelete(ble_connect_timer);\r
- ble_connect_timer = NULL;\r
- }\r
-\r
- ble_connect_timer = osTimerNew((osTimerFunc_t)ble_connect_Timer_CallBack, osTimerPeriodic, NULL, NULL);\r
- tick =osMs2Tick(3000);\r
- retTimer = osTimerStart(ble_connect_timer, tick);\r
- if (retTimer != osOK && ble_connect_timer != NULL) {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"StartCallTimer osTimerStart failed, ret = %lx!!", retTimer);\r
- osTimerDelete(ble_connect_timer);\r
- ble_connect_timer = NULL;\r
- return;\r
- }\r
- connect_updata_count=3;\r
-\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"gap ble update connection parameters %d ret: %X\n",data,ret); \r
-}\r
-void svr_pair_result_cbt_cb(uint16_t conn_id, const bd_addr_t *addr, errcode_t status)\r
-{\r
- devpair_state = 1;//代表配对成功了\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, \r
- "svr_pair_result_cbt_cb!!! addr 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x status:0x%x\r\n",addr->addr[0],addr->addr[1],\r
- addr->addr[2],addr->addr[3],addr->addr[4],addr->addr[5],status);\r
- if(status==ERRCODE_SUCC)\r
- {\r
- if(get_ble_pair())\r
- ble_ancs_client_cmd_setup_and_subscribe(conn_id);\r
-\r
- if(get_ctkd_flag() && uapi_dev_runtime_get_bt_powerstat())\r
- {\r
-\r
- if(get_ble_pair()&&( cm_get_A2DP_switch() || cm_get_HFP_switch()))\r
- {\r
- if(cm_get_A2DP_switch() && cm_get_A2DP_switch())\r
- {\r
- int ret=gap_reconnect_media_device(addr);\r
- }\r
- else if(cm_get_A2DP_switch())\r
- {\r
- uapi_a2dp_snk_connect();\r
- }\r
- else if(cm_get_HFP_switch())\r
- {\r
- uapi_hfp_connect();\r
- }\r
-\r
-\r
- }\r
- else\r
- { \r
- if(get_br_is_pair())\r
- {\r
- bd_addr_t bdaddr={0};\r
- uapi_get_br_address(&bdaddr);\r
- if(false==(bt_is_acl_connected(&bdaddr)))\r
- {\r
- if(cm_get_A2DP_switch() || cm_get_HFP_switch())\r
- {\r
- int ret=gap_reconnect_media_device(&bdaddr);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_reconnect_media_device!!! %X\r\n",ret);\r
- }\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "gap_reconnect_media_device!!! \r\n"); \r
- }\r
- else\r
- {\r
- if(cm_get_A2DP_switch() || cm_get_HFP_switch())\r
- uapi_a2dp_snk_connect();\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_a2dp_snk_connect!!! \r\n");\r
- }\r
- }\r
- } \r
- }\r
- hand_watch_first_time_Paired();\r
-\r
- }\r
-}\r
- \r
-//添加ota特征值\r
-static void srv_ble_add_chart_decr_ota(uint8_t server_id,uint16_t srv_handle)\r
-{ \r
- errcode_t ret = 0;\r
- static uint8_t ota_point_val[] = {0x00, 0x00};\r
- gatts_add_chara_info_t character;\r
- gatts_add_desc_info_t descriptor;\r
- bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_OTA_ID, &character.chara_uuid);\r
- character.permissions = GATT_ATTRIBUTE_PERMISSION_READ;\r
- character.properties = BLE_CHARACTERISTIC_SNED_OTA_ID_PROPERTIES;\r
- character.value_len = (uint16_t)sizeof(ota_point_val);\r
- character.value = ota_point_val;\r
-\r
- ret = gatts_add_characteristic(server_id, srv_handle, &character);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);\r
- }\r
- bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;\r
- descriptor.value_len = (uint16_t)sizeof(ota_point_val);\r
- descriptor.value = ota_point_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
-}\r
-\r
-//自定义 ota 文件传输协议\r
-static void srv_ble_add_chart_decr_Zhihui_ota(uint8_t server_id,uint16_t srv_handle)\r
-{ \r
- errcode_t ret = 0;\r
- static uint8_t ota_val[] = {0x00, 0x00};\r
- gatts_add_chara_info_t character;\r
- gatts_add_desc_info_t descriptor;\r
- bts_data_to_uuid_len2(BLE_ZHIHUI_OTA_ID, &character.chara_uuid);\r
- character.permissions = GATT_ATTRIBUTE_PERMISSION_READ;\r
- character.properties = BLE_ZHIHUI_OTA_ID_ID_PROPERTIES;\r
- character.value_len = (uint16_t)sizeof(ota_val);\r
- character.value = ota_val;\r
-\r
- ret = gatts_add_characteristic(server_id, srv_handle, &character);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);\r
- }\r
- bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;\r
- descriptor.value_len = (uint16_t)sizeof(ota_val);\r
- descriptor.value = ota_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
-}\r
-\r
-static void srv_ble_add_Zhihui_AI(uint8_t server_id,uint16_t srv_handle)\r
-{\r
- errcode_t ret = 0;\r
- static uint8_t battery_point_val[] = {0x00, 0x00};\r
- gatts_add_chara_info_t character;\r
- gatts_add_desc_info_t descriptor;\r
-\r
- bts_data_to_uuid_len2(BLE_ZHIHUI_AI_ID, &character.chara_uuid);\r
- character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;\r
- character.properties = BLE_ZHIHUI_AI_ID_ID_PROPERTIES;\r
- character.value_len = (uint16_t)sizeof(battery_point_val);\r
- character.value = battery_point_val;\r
-\r
- ret = gatts_add_characteristic(server_id, srv_handle, &character);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);\r
- }\r
- bts_data_to_uuid_len2(BLE_UUID_CLIENT_CHARACTERISTIC_CONF, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE;\r
- descriptor.value_len = (uint16_t)sizeof(battery_point_val);\r
- descriptor.value = battery_point_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
-\r
- bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE | GATT_ATTRIBUTE_PERMISSION_READ;;\r
- descriptor.value_len = (uint16_t)sizeof(battery_point_val);\r
- descriptor.value = battery_point_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
-}\r
-\r
-\r
-//用于adnriod发送消息添加特征值和描述符\r
-static void srv_ble_add_chart_decr_andriod(uint8_t server_id,uint16_t srv_handle)\r
-{ \r
- errcode_t ret = 0;\r
- static uint8_t andriod_point_val[] = {0x00, 0x00};\r
- gatts_add_chara_info_t character;\r
- gatts_add_desc_info_t descriptor;\r
-\r
- bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_ANDRIOD_ID, &character.chara_uuid);\r
- character.permissions = GATT_ATTRIBUTE_PERMISSION_READ;\r
- character.properties = BLE_CHARACTERISTIC_SNED_ANDRIOD_ID_PROPERTIES;\r
- character.value_len = (uint16_t)sizeof(andriod_point_val);\r
- character.value = andriod_point_val;\r
-\r
- ret = gatts_add_characteristic(server_id, srv_handle, &character);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);\r
- }\r
- bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;\r
- descriptor.value_len = (uint16_t)sizeof(andriod_point_val);\r
- descriptor.value = andriod_point_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
-}\r
-//添加battery特征值和描述符\r
-static void srv_ble_add_chart_decr_battery(uint8_t server_id,uint16_t srv_handle)\r
-{\r
- errcode_t ret = 0;\r
- static uint8_t battery_point_val[20] = {0};\r
- uint8_t battery_value[20];\r
- memset(battery_value,0,20);\r
- // 获取电池电压值\r
- float voltage = 0.0F;\r
- uint8_t power = 0;\r
- power = battery_get_voltage(&voltage);\r
- battery_point_val[0] = power;//电量90\r
-\r
- uint16_t dial = ble_get_dial_id();\r
- memcpy_s(&battery_point_val[1],2,&dial,2);\r
-\r
- uint8_t _major,_mid,_minor;\r
- uapi_get_fw_version(&_major,&_mid,&_minor);\r
-\r
- battery_point_val[3] = _major;//固件版本号\r
- battery_point_val[4] = _mid;\r
- battery_point_val[5] = _minor;\r
-\r
- bd_addr_t addr_info;\r
- ret = gap_ble_get_local_addr(&addr_info);\r
- battery_point_val[6] = addr_info.addr[5];\r
- battery_point_val[7] = addr_info.addr[4];\r
- battery_point_val[8] = addr_info.addr[3];\r
- battery_point_val[9] = addr_info.addr[2];\r
- battery_point_val[10] = addr_info.addr[1];\r
- battery_point_val[11] = addr_info.addr[0];\r
-\r
- battery_point_val[12] = 0;//消息推送开关 默认是关闭 0\r
- battery_point_val[13] = 0;//多媒体开关\r
- #if defined(BOARD_W9) \r
- battery_point_val[14] = 6;//客户编号\r
- battery_point_val[15] = 6;//产品编号\r
- // #elif defined(BOARD_N9) \r
- // battery_point_val[14] = 7;//客户编号\r
- // battery_point_val[15] = 7;//产品编号\r
- #else\r
- battery_point_val[14] = 5;//客户编号\r
- battery_point_val[15] = 5;//产品编号\r
- #endif\r
-\r
- battery_point_val[16] = 0;//硬件版本号\r
- battery_point_val[17] = 1;\r
-\r
- battery_point_val[18] = 0;//ble版本号\r
- battery_point_val[19] = 1;\r
- gatts_add_chara_info_t character;\r
- gatts_add_desc_info_t descriptor;\r
-\r
- bts_data_to_uuid_len2(BLE_CHARACTERISTIC_READ_BATTERY_ID, &character.chara_uuid);\r
- character.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE;\r
- character.properties = BLE_CHARACTERISTIC_READ_BATTERY_ID_PROPERTIES;\r
- character.value_len = (uint16_t)sizeof(battery_point_val);\r
- character.value = battery_point_val;\r
-\r
- ret = gatts_add_characteristic(server_id, srv_handle, &character);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);\r
- }\r
- static uint8_t report_reference_val_output[] = {0x01, 0x00};\r
- bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;\r
- descriptor.value_len = (uint16_t)sizeof(battery_point_val);\r
- descriptor.value = battery_point_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
-\r
-}\r
-//添加短指令特征值和描述符 20个字节\r
-static void srv_ble_add_chart_decr_short_cmd(uint8_t server_id,uint16_t srv_handle)\r
-{\r
- errcode_t ret = 0;\r
- static uint8_t battery_point_val[] = {0x00, 0x00};\r
- gatts_add_chara_info_t character;\r
- gatts_add_desc_info_t descriptor;\r
-\r
- bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_SHORT_ID, &character.chara_uuid);\r
- character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;\r
- character.properties = BLE_CHARACTERISTIC_SNED_SHORT_ID_PROPERTIES;\r
- character.value_len = (uint16_t)sizeof(battery_point_val);\r
- character.value = battery_point_val;\r
-\r
- ret = gatts_add_characteristic(server_id, srv_handle, &character);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);\r
- }\r
- bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;\r
- descriptor.value_len = (uint16_t)sizeof(battery_point_val);\r
- descriptor.value = battery_point_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
-}\r
-//添加长指令特征值和描述符 大于20个字节\r
-static void srv_ble_add_chart_decr_long_cmd(uint8_t server_id,uint16_t srv_handle)\r
-{\r
- errcode_t ret = 0;\r
- static uint8_t battery_point_val[] = {0x00, 0x00};\r
- gatts_add_chara_info_t character;\r
- gatts_add_desc_info_t descriptor;\r
-\r
- bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_LONG_ID, &character.chara_uuid);\r
- character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;\r
- character.properties = BLE_CHARACTERISTIC_SNED_LONG_ID_PROPERTIES;\r
- character.value_len = (uint16_t)sizeof(battery_point_val);\r
- character.value = battery_point_val;\r
-\r
- ret = gatts_add_characteristic(server_id, srv_handle, &character);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);\r
- }\r
- bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;\r
- descriptor.value_len = (uint16_t)sizeof(battery_point_val);\r
- descriptor.value = battery_point_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
-}\r
-//添加客户端接收特征值和描述符 \r
-static void srv_ble_add_chart_decr_recv_cmd(uint8_t server_id,uint16_t srv_handle)\r
-{\r
- errcode_t ret = 0;\r
- static uint8_t battery_point_val[] = {0x00, 0x00};\r
- gatts_add_chara_info_t character;\r
- gatts_add_desc_info_t descriptor;\r
-\r
- bts_data_to_uuid_len2(BLE_CHARACTERISTIC_RECV_ID, &character.chara_uuid);\r
- character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;\r
- character.properties = BLE_CHARACTERISTIC_RECV_ID_PROPERTIES;\r
- character.value_len = (uint16_t)sizeof(battery_point_val);\r
- character.value = battery_point_val;\r
-\r
- ret = gatts_add_characteristic(server_id, srv_handle, &character);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);\r
- }\r
- bts_data_to_uuid_len2(BLE_UUID_CLIENT_CHARACTERISTIC_CONF, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE;\r
- descriptor.value_len = (uint16_t)sizeof(battery_point_val);\r
- descriptor.value = battery_point_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
-\r
- bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE | GATT_ATTRIBUTE_PERMISSION_READ;;\r
- descriptor.value_len = (uint16_t)sizeof(battery_point_val);\r
- descriptor.value = battery_point_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
-}\r
-\r
-\r
-static void srv_ble_add_ZHIHUIOTA_REPLY_chart_decr_recv_cmd(uint8_t server_id,uint16_t srv_handle)\r
-{\r
- errcode_t ret = 0;\r
- static uint8_t battery_point_val[] = {0x00, 0x00};\r
- gatts_add_chara_info_t character;\r
- gatts_add_desc_info_t descriptor;\r
-\r
- bts_data_to_uuid_len2(BLE_ZHIHUI_OTA_REPLY_ID, &character.chara_uuid);\r
- character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;\r
- character.properties = BLE_ZHIHUI_OTA_REPLY_ID_PROPERTIES;\r
- character.value_len = (uint16_t)sizeof(battery_point_val);\r
- character.value = battery_point_val;\r
-\r
- ret = gatts_add_characteristic(server_id, srv_handle, &character);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);\r
- }\r
- bts_data_to_uuid_len2(BLE_UUID_CLIENT_CHARACTERISTIC_CONF, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE;\r
- descriptor.value_len = (uint16_t)sizeof(battery_point_val);\r
- descriptor.value = battery_point_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
-\r
- bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE | GATT_ATTRIBUTE_PERMISSION_READ;;\r
- descriptor.value_len = (uint16_t)sizeof(battery_point_val);\r
- descriptor.value = battery_point_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
-}\r
-\r
-\r
-static uint8_t g_alipay_character_buf[256] = {0};\r
-static void alipay_add_chart_decr_recv_cmd1(uint8_t server_id,uint16_t srv_handle)\r
-{\r
- #ifdef AILPAY_SUPPORT\r
- errcode_t ret = 0;\r
- // uint16_t id = ALIPAYY_CHARACTERISTIC_ID;\r
- gatts_add_chara_info_t character;\r
- uint16_t value = 0;\r
- bt_uuid_t alipay_service_uuid = {0};\r
- bts_data_to_uuid_len2(ALIPAYY_CHARACTERISTIC_ID, &alipay_service_uuid);\r
- memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));\r
- // character.chara_uuid.uuid_len = sizeof(id);\r
- // memcpy_s(character.chara_uuid.uuid, sizeof (character.chara_uuid.uuid), (char *)&id, sizeof(id));\r
- character.chara_uuid = alipay_service_uuid;\r
- character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;\r
- character.properties =\r
- GATT_CHARACTER_PROPERTY_BIT_READ | GATT_CHARACTER_PROPERTY_BIT_WRITE | GATT_CHARACTER_PROPERTY_BIT_NOTIFY;\r
- character.value_len = 256;\r
- character.value = g_alipay_character_buf;\r
-\r
- ret = gatts_add_characteristic(server_id, srv_handle, &character);\r
- if (ret != ERRCODE_SUCC) {\r
- ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);\r
- }\r
-\r
- uint8_t bas_ccc_val[] = {\r
- 0x01,\r
- 0x00\r
- };\r
- bt_uuid_t ccc_uuid = { 0 };\r
- bts_data_to_uuid_len2(0x2902, &ccc_uuid);\r
- // bts_data_to_uuid_len2(0x2902, &ccc_uuid);\r
- gatts_add_desc_info_t descriptor;\r
- descriptor.desc_uuid = ccc_uuid;\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;\r
- descriptor.value_len = (uint16_t)sizeof(bas_ccc_val);\r
- descriptor.value = bas_ccc_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
- bd_addr_t addr_info;\r
- gatts_add_desc_info_t descriptor_ap;\r
- gap_ble_get_local_addr(&addr_info);\r
- bts_data_to_uuid_len2(0x4b02, &ccc_uuid);\r
- descriptor_ap.desc_uuid = ccc_uuid;\r
- descriptor_ap.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;\r
- descriptor_ap.value_len = BD_ADDR_LEN;\r
- uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};\r
- int k = BD_ADDR_LEN;\r
- for (int i = 0; i < BD_ADDR_LEN; i++) {\r
- ble_data_mac_switch[--k] = addr_info.addr[i];\r
- }\r
- descriptor_ap.value = ble_data_mac_switch;\r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor_ap);\r
- if (ret != ERRCODE_SUCC) {\r
- ALIPAY_PRINT_ERR(0, "gatts_add_descriptor second fail, ret:%u.\r\n", ret);\r
- }\r
- #endif\r
-}\r
-\r
-\r
-\r
-static uint16_t ble_server_handle = 0;\r
-\r
-void alipay_add_chart_decr_cb(uint8_t server_id,uint16_t srv_handle)\r
-{\r
- errcode_t ret = 0;\r
- static uint8_t ota_point_val[] = {0x00, 0x00};\r
- gatts_add_chara_info_t character;\r
- gatts_add_desc_info_t descriptor;\r
- bts_data_to_uuid_len2(0x4a02, &character.chara_uuid);\r
- character.permissions = GATT_ATTRIBUTE_PERMISSION_READ;\r
- character.properties = BLE_CHARACTERISTIC_SNED_OTA_ID_PROPERTIES;\r
- character.value_len = (uint16_t)sizeof(ota_point_val);\r
- character.value = ota_point_val;\r
-\r
- ret = gatts_add_characteristic(server_id, srv_handle, &character);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);\r
- }\r
- bts_data_to_uuid_len2(0x2902, &descriptor.desc_uuid);\r
- descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;\r
- descriptor.value_len = (uint16_t)sizeof(ota_point_val);\r
- descriptor.value = ota_point_val;\r
- \r
- ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);\r
- if (ret != ERRCODE_SUCC) {\r
- // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);\r
- }\r
- }\r
-\r
-//这个回调函数添加新的服务UUID\r
-static void svr_ble_bt_gatts_service_add_cb(uint8_t server_id, bt_uuid_t *uuid, uint16_t srv_handle,\r
- errcode_t status)\r
-{\r
- if (uuid->uuid_len != sizeof(uint16_t)) return ;\r
- uint16_t uuid_tmp = *((uint16_t*)uuid->uuid);\r
- uuid_tmp = SWAP_U16(uuid_tmp);\r
- if ( uuid_tmp == BLE_SERVICE_UUID \r
-\r
- // || uuid_tmp == BLE_UUID_HUMAN_INTERFACE_DEVICE \r
-#ifdef SUPPORT_FACTORY_SERVICE\r
- || uuid_tmp == BLE_UUID_ATE_FACTORYTEST_SERVICE \r
-#endif\r
-#ifdef SUPPORT_PPG_BLE_SERVICE\r
- || uuid_tmp == BLE_UUID_PPG_BLE_SERVICE \r
- //|| uuid_tmp == ALIPAYY_SERVICE_ID\r
-#endif\r
-#ifdef SUPPORT_CYWEE_BLE_SERVICE\r
- || uuid_tmp == BLE_UUID_CYWEE_REPORT_SERVICE\r
-#endif\r
- ) \r
- {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, " 0x%x\r\n",uuid_tmp);\r
- }else{\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_service_add_cb UUID not supported 0x%x\r\n",uuid_tmp);\r
- return ;\r
- }\r
- ble_server_handle = srv_handle;\r
- // ALIPAY_PRINT_DEBUG(0, "BtGattsServiceAddCallback 0x%x 0x%x 0x%x 0x%x", status, server_id, srv_handle,\r
- // *((uint16_t *)uuid->uuid));\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_service_add_cb srv_handle 0x%x\r\n",srv_handle);\r
- if (status != ERRCODE_BT_SUCCESS)\r
- {\r
- return;\r
- }\r
- bt_uuid_t ble_service_uuid = {0};\r
- bts_data_to_uuid_len2(BLE_SERVICE_UUID, &ble_service_uuid);\r
-#ifdef SUPPORT_HID_SERVICE\r
- bt_uuid_t hid_service_uuid = {0};\r
- bts_data_to_uuid_len2(BLE_UUID_HUMAN_INTERFACE_DEVICE, &hid_service_uuid);\r
-#endif\r
-#ifdef AILPAY_SUPPORT\r
- // // bt_uuid_t alipay_service_uuid = {0};\r
- // // bts_data_to_uuid_len2(ALIPAYY_SERVICE_ID, &alipay_service_uuid);//0x3802\r
-#endif\r
-\r
-#ifdef SUPPORT_FACTORY_SERVICE\r
- bt_uuid_t factory_service_uuid = {0};\r
- bts_data_to_uuid_len2(BLE_UUID_ATE_FACTORYTEST_SERVICE, &factory_service_uuid);\r
-#endif\r
-#ifdef SUPPORT_PPG_BLE_SERVICE\r
- bt_uuid_t ppg_service_uuid = {0};\r
- bts_data_to_uuid_len2(BLE_UUID_PPG_BLE_SERVICE, &ppg_service_uuid);\r
-#endif\r
-\r
-\r
-#ifdef SUPPORT_CYWEE_BLE_SERVICE\r
-\r
- bt_uuid_t cywee_ble_service_uuid = {0};\r
- bts_data_to_uuid_len2(BLE_UUID_CYWEE_REPORT_SERVICE, &cywee_ble_service_uuid);\r
-\r
-#endif\r
-\r
-\r
- errcode_t ret = 0;\r
- if (ble_gatts_cmp_uuid(uuid, &ble_service_uuid) == true) {//通过传入的uuid进行比较\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_service_add_cb ble_service_uuid\r\n");\r
-\r
- srv_ble_add_chart_decr_ota(server_id,srv_handle);//ota特征值\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_ota \r\n");\r
-\r
- srv_ble_add_chart_decr_andriod(server_id,srv_handle);//对18e0这个服务进行添加andiod特征值和描述符\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_andriod \r\n");\r
-\r
- srv_ble_add_chart_decr_battery(server_id,srv_handle);//电池电量特征值\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_battery \r\n");\r
- srv_ble_add_chart_decr_short_cmd(server_id,srv_handle);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_short_cmd \r\n");\r
- srv_ble_add_chart_decr_long_cmd(server_id,srv_handle);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_long_cmd \r\n");\r
- srv_ble_add_chart_decr_recv_cmd(server_id,srv_handle);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_recv_cmd \r\n");\r
- srv_ble_add_chart_decr_Zhihui_ota(server_id,srv_handle);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_Zhihui_ota \r\n");\r
- srv_ble_add_Zhihui_AI(server_id,srv_handle);\r
- // srv_ble_add_chart_decr_Zhihui_AI(server_id,srv_handle);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_Zhihui_AI \r\n");\r
- srv_ble_add_ZHIHUIOTA_REPLY_chart_decr_recv_cmd(server_id,srv_handle);\r
-\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_service_add_cb 1\r\n");\r
- gatts_start_service(server_id, srv_handle);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_service_add_cb 2\r\n");\r
- }\r
-#ifdef SUPPORT_HID_SERVICE\r
- if (ble_gatts_cmp_uuid(uuid, &hid_service_uuid) == true){\r
- ble_hid_add_characters_and_descriptors(server_id, srv_handle);\r
- ret = gatts_start_service(server_id, srv_handle);\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "hid service svr_ble_bt_gatts_service_add_cb ret:%d\r\n",ret);\r
- }\r
-#endif\r
-\r
-#ifdef SUPPORT_FACTORY_SERVICE\r
- if (ble_gatts_cmp_uuid(uuid, &factory_service_uuid) == true){\r
- ble_factorytest_add_characters_and_descriptors(server_id,srv_handle);\r
- ret = gatts_start_service(server_id, srv_handle);\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "factorytest service svr_ble_bt_gatts_service_add_cb ret:%d\r\n",ret);\r
- }\r
-#endif\r
-#ifdef SUPPORT_PPG_BLE_SERVICE\r
- if (ble_gatts_cmp_uuid(uuid, &ppg_service_uuid) == true){\r
- ble_ppgtest_add_characters_and_descriptors(server_id,srv_handle);\r
- ret = gatts_start_service(server_id, srv_handle);\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "ppg ble service svr_ble_bt_gatts_service_add_cb ret:%d\r\n",ret);\r
- }\r
-#endif\r
-#ifdef SUPPORT_CYWEE_BLE_SERVICE\r
- if (ble_gatts_cmp_uuid(uuid, &cywee_ble_service_uuid) == true){\r
- ble_cywee_add_characters_and_descriptors(server_id,srv_handle);\r
- ret = gatts_start_service(server_id, srv_handle);\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "cywee ble service svr_ble_bt_gatts_service_add_cb ret:%d\r\n",ret);\r
- } \r
-\r
-#endif\r
-#ifdef AILPAY_SUPPORT\r
- // if (ble_gatts_cmp_uuid(uuid, &alipay_service_uuid) == true){\r
- // alipay_add_chart_decr_recv_cmd1(server_id,srv_handle);\r
- // ret = gatts_start_service(server_id, srv_handle);\r
- // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "alipay_service_uuid service svr_ble_bt_gatts_service_add_cb ret:%d\r\n",ret);\r
- // }\r
-#endif\r
- \r
-}\r
-uint16_t alipay_handle = 0;\r
-uint16_t g_hid_server_handle = 0;\r
-static void svr_ble_bt_gatts_characteristic_add_cb(uint8_t server_id, bt_uuid_t *uuid, uint16_t srv_handle,\r
- gatts_add_character_result_t *result, errcode_t status)\r
-{\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "bt_gatts_characteristic_add_cb uuid:0x%02x%02x 0x%x %d %d , status %x\r\n",\r
- uuid->uuid[0],uuid->uuid[1],\r
- srv_handle,result->handle,\r
- result->value_handle,status);\r
- bt_uuid_t chara_uuid_data_2ae0 = {0};\r
- bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_OTA_ID, &chara_uuid_data_2ae0);\r
-\r
- bt_uuid_t chara_uuid_data_2ae1 = {0};\r
- bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_ANDRIOD_ID, &chara_uuid_data_2ae1);\r
-\r
- bt_uuid_t chara_uuid_data_2ae5 = {0};\r
- bts_data_to_uuid_len2(BLE_CHARACTERISTIC_RECV_ID, &chara_uuid_data_2ae5);\r
-\r
- bt_uuid_t chara_uuid_data_2ae3 = {0};\r
- bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_SHORT_ID, &chara_uuid_data_2ae3);\r
- bt_uuid_t chara_uuid_data_2ae4 = {0};\r
- bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_LONG_ID, &chara_uuid_data_2ae4);\r
- \r
- \r
- bt_uuid_t chara_uuid_data_2ae2 = {0};\r
- bts_data_to_uuid_len2(BLE_CHARACTERISTIC_READ_BATTERY_ID, &chara_uuid_data_2ae2);\r
-#ifdef SUPPORT_HID_SERVICE\r
- bt_uuid_t hid_report_uuid_2a4d = {0};\r
- bts_data_to_uuid_len2(BLE_UUID_REPORT, &hid_report_uuid_2a4d);\r
-#endif\r
- bt_uuid_t hid_report_uuid_2ae6 = {0};\r
- bts_data_to_uuid_len2(BLE_ZHIHUI_OTA_ID, &hid_report_uuid_2ae6);\r
-\r
- bt_uuid_t chara_uuid_data_2ae7 = {0};\r
- bts_data_to_uuid_len2(BLE_ZHIHUI_OTA_REPLY_ID, &chara_uuid_data_2ae7);\r
-\r
- bt_uuid_t chara_uuid_data_2ae8 = {0};\r
- bts_data_to_uuid_len2(BLE_ZHIHUI_AI_ID, &chara_uuid_data_2ae8);\r
-\r
- if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae8))\r
- {\r
- if(data2ae8Cmd==0)\r
- {\r
- data2ae8Cmd=result->value_handle;\r
- }\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
- }\r
-\r
- if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae7))\r
- {\r
- if(data2ae7Cmd==0)\r
- {\r
- data2ae7Cmd=result->value_handle;\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "data2ae7Cmd");\r
- }\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
- }\r
-\r
-\r
- if(ble_gatts_cmp_uuid(uuid, &hid_report_uuid_2ae6))\r
- {\r
- if(data2ae6Cmd==0)\r
- {\r
- data2ae6Cmd=result->value_handle;\r
- }\r
- Is_value_handle[handle_num]=data2ae6Cmd;\r
- handle_num++;\r
- }\r
- if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae5))\r
- {\r
- if(g_ble_server_handle == 0)\r
- {\r
- g_ble_server_handle = result->value_handle;\r
- }\r
- if(data2ae5Cmd == 0){\r
- data2ae5Cmd = result->value_handle;\r
- }\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
- \r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, " 2ae5 result->value_handle1 %d\r\n",result->value_handle);\r
- }\r
- \r
- if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae3 ))\r
- {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "2ae3 result->value_handle2 %d\r\n",result->value_handle);\r
- if(data2ae3Cmd == 0)\r
- {\r
- data2ae3Cmd = result->value_handle;\r
- }\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
- \r
- }\r
- \r
- if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae0))\r
- {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "2ae0 result->value_handle4 %d\r\n",result->value_handle);\r
- if(data2ae0Cmd == 0)\r
- {\r
- data2ae0Cmd = result->value_handle;\r
- }\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
- }\r
- if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae1))\r
- {\r
- if(data2ae1Cmd == 0)\r
- {\r
- data2ae1Cmd = result->value_handle;\r
- }\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
-\r
- // data2ae1Cmd = result->value_handle;\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "2ae1 result->value_handle5 %d\r\n",result->value_handle);\r
- // shortCmdChara = result->value_handle;\r
- }\r
- if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae2))\r
- {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "2ae2 result->value_handle6 %d\r\n",result->value_handle);\r
- // shortCmdChara = result->value_handle;\r
- if(data2ae2Cmd == 0){\r
- data2ae2Cmd = result->value_handle;\r
- }\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
- }\r
- if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae4))\r
- {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "2ae4 result->value_handle3 %d\r\n",result->value_handle);\r
- if(data2ae4Cmd == 0)\r
- {\r
- data2ae4Cmd = result->value_handle;\r
- }\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
- // = result->value_handle;\r
- }\r
-#ifdef SUPPORT_HID_SERVICE\r
- if (ble_gatts_cmp_uuid(uuid, &hid_report_uuid_2a4d) == true) {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "result->hid_report_uuid_2a4d %d\r\n",result->value_handle);\r
- if(g_hid_server_handle == 0){\r
- g_hid_server_handle = result->value_handle;\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "g_hid_server_handle %d\r\n",g_hid_server_handle);\r
- ble_hid_add_characters_input_report_cbk(g_hid_server_handle);\r
- }\r
- }\r
-#endif\r
-\r
-#ifdef SUPPORT_FACTORY_SERVICE\r
- bt_uuid_t factorytest_recv_uuid = {0};\r
- bts_data_to_uuid_len2(BLE_UUID_ATE_TX, &factorytest_recv_uuid);\r
-\r
- if (ble_gatts_cmp_uuid(uuid, &factorytest_recv_uuid) == true) {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "result->factorytest_recv_uuid %d\r\n",result->value_handle);\r
-\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
-\r
- ble_factorytest_store_recv_handle(result->value_handle) ;\r
- // }\r
- }\r
-\r
- bt_uuid_t factorytest_report_uuid = {0};\r
- bts_data_to_uuid_len2(BLE_UUID_ATE_RX, &factorytest_report_uuid);\r
-\r
- if (ble_gatts_cmp_uuid(uuid, &factorytest_report_uuid) == true) {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "result->factorytest_report_uuid %d\r\n",result->value_handle);\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
- ble_factorytest_store_report_handle(result->value_handle);\r
- // }\r
- }\r
-\r
- bt_uuid_t factorytest_ota_recv_uuid = {0};\r
- bts_data_to_uuid_len2(BLE_UUID_OTA_TX, &factorytest_ota_recv_uuid);\r
-\r
- if (ble_gatts_cmp_uuid(uuid, &factorytest_ota_recv_uuid) == true) {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "result->factorytest_ota_recv_uuid %d\r\n",result->value_handle);\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
- ble_factorytest_store_ota_recv_handle(result->value_handle) ;\r
- // }\r
- }\r
-\r
- bt_uuid_t factorytest_ota_report_uuid = {0};\r
- bts_data_to_uuid_len2(BLE_UUID_OTA_RX, &factorytest_ota_report_uuid);\r
-\r
- if (ble_gatts_cmp_uuid(uuid, &factorytest_ota_report_uuid) == true) {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "result->factorytest_ota_report_uuid %d\r\n",result->value_handle);\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
- ble_factorytest_store_ota_report_handle(result->value_handle);\r
- // }\r
- }\r
-#endif \r
-\r
-#ifdef SUPPORT_PPG_BLE_SERVICE\r
- bt_uuid_t ppgtest_report_uuid = {0};\r
- bts_data_to_uuid_len2(BLE_UUID_PPG_NOTIFY, &ppgtest_report_uuid);\r
- if (ble_gatts_cmp_uuid(uuid, &ppgtest_report_uuid) == true) {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "result->ble_ppgtest_store_report_handle %d\r\n",result->value_handle);\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
- ble_ppgtest_store_report_handle(result->value_handle);\r
- }\r
-#endif\r
-#ifdef SUPPORT_CYWEE_BLE_SERVICE\r
- bt_uuid_t cywee_report_uuid = {0};\r
- bts_data_to_uuid_len2(BLE_UUID_CYWEE_RX, &cywee_report_uuid);\r
-\r
- if (ble_gatts_cmp_uuid(uuid, &cywee_report_uuid) == true) {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "result->cywee_report_uuid %d\r\n",result->value_handle);\r
-\r
- Is_value_handle[handle_num]=result->value_handle;\r
- handle_num++;\r
-\r
- ble_cywee_store_report_handle(result->value_handle);\r
- // }\r
-\r
- ble_cywee_store_recv_handle(73);\r
- }\r
- else\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble_gatts_cmp_uuid(uuid, &cywee_report_uuid) != true\r\n");\r
-#endif\r
- return;\r
-}\r
-\r
-errcode_t svr_ble_bt_gatts_noyify(uint8_t *data, uint16_t data_len)//这里是设备数据上报给app手机端\r
-{\r
- gatts_ntf_ind_t data_info;\r
- data_info.attr_handle = g_ble_server_handle;\r
- data_info.value = data;\r
- data_info.value_len = data_len;\r
- if (g_ble_conn_id == 0)\r
- return 0;\r
- errcode_t ret = gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);\r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_WATCH_REPLY);\r
- if(ret!=ERRCODE_SUCC)\r
- {\r
- msleep(50);\r
- ret=gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);\r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_WATCH_REPLY);\r
- if(ret!=ERRCODE_SUCC)\r
- {\r
- msleep(100);\r
- ret=gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);\r
-\r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_WATCH_REPLY);\r
-\r
- if(ret!=ERRCODE_SUCC)\r
- {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.data_len:%d", ret, g_ble_server_id,\r
- g_ble_conn_id, g_ble_server_handle,data_len);\r
- ble_set_ai_Answer_str("BLE NOTIF ERROR",5);\r
- }\r
- \r
- }\r
- }\r
- return ret; \r
-}\r
-\r
-\r
-errcode_t svr_ble_bt_gatts_noyify_zhihui(uint8_t *data, uint16_t data_len)//这里是设备数据上报给app手机端\r
-{\r
- gatts_ntf_ind_t data_info;\r
- data_info.attr_handle = data2ae7Cmd;\r
- data_info.value = data;\r
- data_info.value_len = data_len;\r
- if (g_ble_conn_id == 0)\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "g_ble_conn_id");\r
- // return 0;\r
- }\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "g_ble_conn_id %d g_ble_conn_id %d",g_ble_server_id,g_ble_conn_id);\r
- errcode_t ret = gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);\r
- if(ret!=ERRCODE_SUCC)\r
- {\r
- msleep(50);\r
- ret=gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);\r
- if(ret!=ERRCODE_SUCC)\r
- {\r
- msleep(100);\r
- ret=gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);\r
-\r
- if(ret!=ERRCODE_SUCC)\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.data_len:%d", ret, g_ble_server_id,\r
- g_ble_conn_id, g_ble_server_handle,data_len);\r
- }\r
- }\r
- return ret; \r
-}\r
-\r
-errcode_t svr_ble_bt_gatts_noyify_AI(uint8_t *data, uint16_t data_len)//这里是设备数据上报给app手机端\r
-{\r
- gatts_ntf_ind_t data_info;\r
- data_info.attr_handle = data2ae8Cmd;\r
- data_info.value = data;\r
- data_info.value_len = data_len;\r
- if (g_ble_conn_id == 0)\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "g_ble_conn_id");\r
- // return 0;\r
- }\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "g_ble_conn_id %d g_ble_conn_id %d",g_ble_server_id,g_ble_conn_id);\r
- errcode_t ret = gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);\r
- if(ret!=ERRCODE_SUCC)\r
- {\r
- msleep(50);\r
- ret=gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);\r
- if(ret!=ERRCODE_SUCC)\r
- {\r
- msleep(100);\r
- ret=gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);\r
-\r
- if(ret!=ERRCODE_SUCC)\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.data_len:%d", ret, g_ble_server_id,\r
- g_ble_conn_id, g_ble_server_handle,data_len);\r
- }\r
- }\r
- return ret; \r
-}\r
-\r
-errcode_t svr_ble_read_data_value_updata_noyify(void)//2ae2\r
-{\r
- gatts_ntf_ind_t data_info;\r
- data_info.attr_handle = data2ae2Cmd;\r
- static uint8_t battery_point_val[20] = {0};\r
- // 获取电池电压值\r
- float voltage = 0.0F;\r
- uint8_t power = 0;\r
- power =battery_get_voltage(&voltage);\r
- battery_point_val[0] =power;//power ;//power;//电量90\r
- uint16_t dial = ble_get_dial_id();\r
- memcpy_s(&battery_point_val[1],2,&dial,2);\r
-\r
- uint8_t _major,_mid,_minor;\r
- uapi_get_fw_version(&_major,&_mid,&_minor);\r
-\r
- battery_point_val[3] = _major;//固件版本号\r
- battery_point_val[4] = _mid;\r
- battery_point_val[5] = _minor;\r
-\r
- bd_addr_t addr_info;\r
- errcode_t ret = gap_ble_get_local_addr(&addr_info);\r
- battery_point_val[6] = addr_info.addr[5];\r
- battery_point_val[7] = addr_info.addr[4];\r
- battery_point_val[8] = addr_info.addr[3];\r
- battery_point_val[9] = addr_info.addr[2];\r
- battery_point_val[10] = addr_info.addr[1];\r
- battery_point_val[11] = addr_info.addr[0];\r
-\r
- battery_point_val[12] = 0;//消息推送开关 默认是关闭 0\r
- battery_point_val[13] = 0;//多媒体开关\r
- \r
- #if defined(BOARD_W9) \r
- battery_point_val[14] = 6;//客户编号\r
- battery_point_val[15] = 6;//产品编号\r
- // #elif defined(BOARD_N9) \r
- // battery_point_val[14] = 7;//客户编号\r
- // battery_point_val[15] = 7;//产品编号\r
- #else\r
- battery_point_val[14] = 5;//客户编号\r
- battery_point_val[15] = 5;//产品编号\r
- #endif\r
-\r
- battery_point_val[16] = 0;//硬件版本号\r
- battery_point_val[17] = 1;\r
-\r
- battery_point_val[18] = 0;//ble版本号\r
- battery_point_val[19] = 1;\r
-\r
-\r
- data_info.value = battery_point_val;\r
- data_info.value_len = 20;\r
-\r
- // if (g_ble_conn_id == 0)\r
- // return 0;\r
- \r
- ret = gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.data_len:%d", ret, g_ble_server_id,\r
- g_ble_conn_id, g_ble_server_handle,20);\r
- \r
- return ret; \r
-}\r
-\r
-errcode_t svr_ble_read_data_value_updata_noyify_test(uint8_t test)//2ae2\r
-{\r
- gatts_ntf_ind_t data_info;\r
- data_info.attr_handle = data2ae2Cmd;\r
- static uint8_t battery_point_val[20] = {0};\r
-\r
- battery_point_val[0] =test;//power ;//power;//电量90\r
-\r
- uint16_t dial = ble_get_dial_id();\r
- memcpy_s(&battery_point_val[1],2,&dial,2);\r
-\r
- uint8_t _major,_mid,_minor;\r
- uapi_get_fw_version(&_major,&_mid,&_minor);\r
-\r
- battery_point_val[3] = _major;//固件版本号\r
- battery_point_val[4] = _mid;\r
- battery_point_val[5] = _minor;\r
-\r
- bd_addr_t addr_info;\r
- errcode_t ret = gap_ble_get_local_addr(&addr_info);\r
- battery_point_val[6] = addr_info.addr[5];\r
- battery_point_val[7] = addr_info.addr[4];\r
- battery_point_val[8] = addr_info.addr[3];\r
- battery_point_val[9] = addr_info.addr[2];\r
- battery_point_val[10] = addr_info.addr[1];\r
- battery_point_val[11] = addr_info.addr[0];\r
-\r
- battery_point_val[12] = 0;//消息推送开关 默认是关闭 0\r
- battery_point_val[13] = 0;//多媒体开关\r
-\r
- #if defined(BOARD_W9) \r
- battery_point_val[14] = 6;//客户编号\r
- battery_point_val[15] = 6;//产品编号\r
- // #elif defined(BOARD_N9) \r
- // battery_point_val[14] = 7;//客户编号\r
- // battery_point_val[15] = 7;//产品编号\r
- #else\r
- battery_point_val[14] = 5;//客户编号\r
- battery_point_val[15] = 5;//产品编号\r
- #endif\r
-\r
- battery_point_val[16] = 0;//硬件版本号\r
- battery_point_val[17] = 1;\r
-\r
- battery_point_val[18] = 0;//ble版本号\r
- battery_point_val[19] = 1;\r
-\r
-\r
- data_info.value = battery_point_val;\r
- data_info.value_len = 20;\r
- ret = gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.data_len:%d", ret, g_ble_server_id,\r
- g_ble_conn_id, g_ble_server_handle,20);\r
- \r
- return ret; \r
-}\r
-\r
-static uint8_t flag=1;\r
-static void svr_ble_bt_gatts_req_read_cb(uint8_t server_id, uint16_t conn_id, gatts_req_read_cb_t *read_cb_para,\r
- errcode_t status)\r
-{\r
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_req_read_cb ret:is_long:%d %d",read_cb_para->is_long,status);\r
-\r
- //WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_req_read_cb ret:is_long:%d 2ae2 %d read_cb_para->handle :%d",read_cb_para->is_long,data2ae2Cmd,read_cb_para->handle);\r
- if(read_cb_para->handle==data2ae2Cmd && get_ble_connect() && status==0 )\r
- {\r
- g_ble_conn_id=conn_id;\r
-\r
- static uint8_t battery_point_val[20] = {0};\r
- // 获取电池电压值\r
- float voltage = 0.0F;\r
- uint8_t power = 0;\r
- power =battery_get_voltage(&voltage);\r
- battery_point_val[0] =power;//power ;//power;//电量90\r
- uint16_t dial = ble_get_dial_id();\r
- memcpy_s(&battery_point_val[1],2,&dial,2);\r
-\r
- uint8_t _major,_mid,_minor;\r
- uapi_get_fw_version(&_major,&_mid,&_minor);\r
-\r
- battery_point_val[3] = _major;//固件版本号\r
- battery_point_val[4] = _mid;\r
- battery_point_val[5] = _minor;\r
-\r
- bd_addr_t addr_info;\r
- errcode_t ret = gap_ble_get_local_addr(&addr_info);\r
- battery_point_val[6] = addr_info.addr[5];\r
- battery_point_val[7] = addr_info.addr[4];\r
- battery_point_val[8] = addr_info.addr[3];\r
- battery_point_val[9] = addr_info.addr[2];\r
- battery_point_val[10] = addr_info.addr[1];\r
- battery_point_val[11] = addr_info.addr[0];\r
-\r
- battery_point_val[12] = 0;//消息推送开关 默认是关闭 0\r
- battery_point_val[13] = 0;//多媒体开关\r
-\r
- #if defined(BOARD_W9) \r
- battery_point_val[14] = 6;//客户编号\r
- battery_point_val[15] = 6;//产品编号\r
- // #elif defined(BOARD_N9) \r
- // battery_point_val[14] = 7;//客户编号\r
- // battery_point_val[15] = 7;//产品编号\r
- #else\r
- battery_point_val[14] = 5;//客户编号\r
- battery_point_val[15] = 5;//产品编号\r
- #endif\r
-\r
- battery_point_val[16] = 0;//硬件版本号\r
- battery_point_val[17] = 1;\r
-\r
- battery_point_val[18] = 0;//ble版本号\r
- battery_point_val[19] = 1;\r
-\r
- static gatts_ntf_ind_t gatts_ntf_ind;\r
- gatts_ntf_ind.attr_handle=read_cb_para->handle;\r
- gatts_ntf_ind.value=battery_point_val;\r
- gatts_ntf_ind.value_len=20;\r
- // read_cb_para->need_rsp=0;\r
- \r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_APP_READ);\r
- gatts_notify_indicate(server_id,conn_id,&gatts_ntf_ind);\r
-}\r
-}\r
-\r
-\r
-static uint8_t falg = 0;\r
-\r
-\r
-static bool Is_App_ble_handle(uint16_t handle)\r
-{\r
- for(int i=0;i<handle_max_len;i++)\r
- {\r
- if(Is_value_handle[i]==handle)\r
- return true;\r
- }\r
- return false;\r
-\r
-}\r
-\r
-static void svr_ble_bt_gatts_req_write_cb(uint8_t server_id, uint16_t conn_id, gatts_req_write_cb_t *write_cb_para,\r
- errcode_t status)\r
-{ \r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "g_ble_server_handle %d conn_id :%d write_cb_para->length:%d write_cb_para->handle %d write_cb_para->request_id:%d",g_ble_server_handle,conn_id,write_cb_para->length,\r
- write_cb_para->handle,write_cb_para->request_id);\r
- if(write_cb_para->handle==data2ae0Cmd)\r
- {\r
- if(status!=ERRCODE_SUCC)\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ota fial ");\r
- //如果存在此文件证明ota出现失败过\r
- FILE *fp= fopen("/user/updata/Ble_ota_file.txt","ab+");\r
- fwrite("x",1,1,fp);\r
- fclose(fp);\r
- }\r
- }\r
- if(Is_App_ble_handle(write_cb_para->handle))\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP," %d %d\r\n",conn_id,write_cb_para->handle);\r
- g_ble_conn_id=conn_id;\r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_APP_CMD);\r
- }\r
- #ifdef SUPPORT_ALIPAY_SEC\r
- if(is_alipay_handle(write_cb_para->handle))\r
- {\r
- g_ble_Alipay_conn_id=conn_id;\r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_ALIPAY_CMD);\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"g_ble_Alipay_conn_id\r\n");\r
- }\r
- #endif\r
- // else\r
- // {\r
- // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP," ?????\r\n");\r
- // }\r
- blesrv_service_recv_msg_handler(write_cb_para->handle,write_cb_para->value,write_cb_para->length);\r
-}\r
-\r
-void ble_test_ANCS(void)\r
-{\r
- ble_ancs_client_cmd_setup_and_subscribe(g_ble_conn_id);\r
-}\r
-\r
-\r
-void ble_test_ANCS_notify(uint8_t type)\r
-{\r
- ble_ancs_client_subscribe_notify(g_ble_conn_id,type);\r
-}\r
-\r
-static void svr_ble_mtu_exchange(uint8_t server_id, uint16_t conn_id, uint16_t mtu_size, errcode_t status)\r
-{\r
- ble_nus_max_data_len = mtu_size-3;\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_mtu_exchange %d %d %d\r\n",server_id,conn_id,mtu_size);\r
-}\r
-/******************* gap_ble ************************************/\r
-void svr_gap_ble_auth_complete_callback(uint16_t conn_id, const bd_addr_t *addr, errcode_t status,ble_auth_info_evt_t* evt)\r
-{\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "sendParieSuccess");\r
-\r
-\r
- sendParieSuccess(1,addr);\r
- uapi_set_br_address(addr);\r
-}\r
-\r
-static bool ble_adv_start=false;\r
-\r
-bool get_ble_adv_status(void)\r
-{\r
- return ble_adv_start;\r
-}\r
-\r
-static void svr_ble_adv_start_cb(uint8_t adv_id, adv_status_t status)\r
-{\r
- if (adv_id == BLE_ADV_ID) {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"BleAdvStartCallback adv_id: %d, status:%d\n", adv_id, status);\r
- ble_adv_start=1;\r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_BROADCAST_ON);\r
-\r
- }\r
-}\r
-\r
-static void svr_ble_adv_stop_cb(uint8_t adv_id, adv_status_t status)\r
-{\r
- if (adv_id == BLE_ADV_ID) {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"svr_ble_adv_stop_cb adv_id: %d, status:%d\n", adv_id, status);\r
- ble_adv_start=0;\r
- uapi_save_runtime_log(RUNTIME_LOG_BLE_BROADCAST_OFF);\r
- }\r
-}\r
-\r
-\r
-\r
-static void srv_BleAdvTerminateCallback(uint8_t advId, adv_status_t status)\r
-{\r
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "srv_BleAdvTerminateCallback advId: %d, status:%d\n", advId, status);\r
-\r
-}\r
-void srv_ble_server_register_gap_ble_callbacks(void)//ble基础通讯服务注册回调函数\r
-{\r
- g_ble_gapble_cbs.conn_state_change_cb = svr_ble_connstate_change_cb;\r
- g_ble_gapble_cbs.pair_result_cb = svr_pair_result_cbt_cb;\r
- g_ble_gapble_cbs.terminate_adv_cb = srv_BleAdvTerminateCallback;\r
- g_ble_gapble_cbs.auth_complete_cb = svr_gap_ble_auth_complete_callback;\r
- g_ble_gapble_cbs.start_adv_cb=svr_ble_adv_start_cb;\r
- g_ble_gapble_cbs.stop_adv_cb=svr_ble_adv_stop_cb;\r
- g_ble_gapble_cbs.conn_param_update_cb=srv_gap_ble_connect_param_update_callback;\r
-#ifndef SUPPORT_OHOSFWK\r
- gap_ble_register_callbacks(&g_ble_gapble_cbs);\r
-#else\r
- wrapper_gap_ble_register_callbacks(&g_ble_gapble_cbs);\r
-#endif\r
-}\r
-void srv_ble_server_register_gatt_callbacks(void)\r
-{\r
- errcode_t ret = ERRCODE_BT_SUCCESS;\r
- g_ble_gatts_cbs.add_service_cb = svr_ble_bt_gatts_service_add_cb;\r
- g_ble_gatts_cbs.add_characteristic_cb = svr_ble_bt_gatts_characteristic_add_cb;\r
-\r
- g_ble_gatts_cbs.read_request_cb = svr_ble_bt_gatts_req_read_cb;\r
- g_ble_gatts_cbs.write_request_cb = svr_ble_bt_gatts_req_write_cb;\r
- g_ble_gatts_cbs.mtu_changed_cb = svr_ble_mtu_exchange;\r
-\r
-#ifndef SUPPORT_OHOSFWK\r
- gatts_register_callbacks(&g_ble_gatts_cbs);\r
-#else\r
- wrapper_gatts_register_callbacks(&g_ble_gatts_cbs);\r
-#endif\r
- return;\r
-}\r
-static uint8_t g_server_id = 0;\r
-static void svr_ble_register_service(void)\r
-{\r
- uint16_t srevr_id = BLE_SERVICE_UUID;\r
- uint16_t ser_id = BLE_SERVICE_UUID;\r
- uint8_t serverId = 0;\r
- bt_uuid_t uuid;\r
- errcode_t ret = 0;\r
- uuid.uuid_len = (uint8_t)sizeof(ser_id);\r
- memcpy_s(uuid.uuid, sizeof(uuid.uuid), (char *)&ser_id, sizeof(ser_id));\r
-\r
-#ifndef SUPPORT_OHOSFWK\r
- ret = gatts_register_server(&uuid, &serverId); /* 注册gatt server */\r
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gatts_register_server ret: 0x%x serverId = 0x%x uuid.uuid_len:%d", ret, serverId,uuid.uuid_len);\r
-#else\r
- ret = wrapper_gatts_register_server(&uuid, &serverId); /* 注册gatt server */\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "wrapper_gatts_register_server ret: 0x%x serverId = 0x%x uuid.uuid_len:%d", ret, serverId,uuid.uuid_len);\r
-#endif\r
- g_ble_server_id = serverId;\r
-\r
- bt_uuid_t ble_service_uuid = {0};\r
- bts_data_to_uuid_len2(srevr_id, &ble_service_uuid);\r
-\r
-#ifndef SUPPORT_OHOSFWK\r
- ret = gatts_add_service(serverId, &ble_service_uuid, true);\r
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gatts_add_service ret: 0x%x", ret);\r
-#else\r
- ret = wrapper_gatts_add_service(serverId, &ble_service_uuid, true);\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "wrapper_gatts_add_service ret: 0x%x", ret);\r
-#endif\r
-\r
- \r
-\r
- return;\r
-}\r
-bool ble_gatts_cmp_uuid(const bt_uuid_t *tgt_uuid, const bt_uuid_t *src_uuid)//比较源uuid和给定的uuid是否匹配\r
-{\r
- uint8_t *tgt = (uint8_t *)bts_init_128bit_uuid(tgt_uuid);\r
- bool result = false;\r
- if (tgt == NULL) {\r
- return false;\r
- }\r
- uint8_t *src = (uint8_t *)bts_init_128bit_uuid(src_uuid);\r
- if (src == NULL) {\r
- bt_os_free(tgt);\r
- return false;\r
- }\r
- if (memcmp(tgt, src, BT_UUID_MAX_LEN) == 0) {\r
- result = true;\r
- }\r
- bt_os_free(src);\r
- bt_os_free(tgt);\r
- return result;\r
-}\r
-// extern void alipay_unregist_server(void);\r
-void ble_unregist_server(void)\r
-{\r
- svr_ble_adv_stop();\r
- gatts_delete_all_services(g_ble_server_id);\r
- gatts_unregister_server(g_ble_server_id);\r
- \r
-}\r
-\r
-\r
-void svr_ble_bluetooth_init(void)\r
-{\r
- // memset(&phone_addr,0,sizeof(bd_addr_t));\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bluetooth_init");\r
-\r
- ble_instruct_init();\r
-\r
- srv_ble_server_register_gap_ble_callbacks();\r
- srv_ble_server_register_gatt_callbacks();\r
-\r
- //add server and ble service\r
- svr_ble_register_service();\r
- \r
- #ifdef SUPPORT_HID_SERVICE\r
- // ble_hid_server_init();\r
- #endif\r
- #ifdef SUPPORT_ALIPAY_SEC\r
- svr_alipay_bluetooth_init(g_ble_server_id);\r
- #endif\r
- #ifdef SUPPORT_FACTORY_SERVICE\r
- ble_factory_server_init(g_ble_server_id);\r
- #endif\r
- #ifdef SUPPORT_PPG_BLE_SERVICE\r
- ble_ppgtest_server_init(g_ble_server_id);\r
- #endif\r
- #ifdef SUPPORT_CYWEE_BLE_SERVICE\r
- ble_cywee_server_init(g_ble_server_id);\r
- #endif\r
- gattc_reg_id();\r
-\r
- #ifdef SUPPORT_BLE_SERVICE\r
- uapi_Ai_send_service_init();\r
- #endif\r
-\r
- g_custom_ble_init_flag = true;\r
- return;\r
-}\r
-//关闭蓝牙\r
-void custom_ble_service_stop(void)\r
-{\r
- AdverFlag = false;\r
- errcode_t ret = 0;\r
- bd_addr_t addr={0};\r
- get_phone_addr(&addr,g_ble_conn_id);\r
-\r
- if(Bleconnect == GAP_BLE_STATE_CONNECTED){//设备连接需要断开\r
- ret = gap_ble_disconnect_remote_device((const bd_addr_t *)&addr);//与固定的mac设置地址进行断开连接\r
- }\r
-\r
- // 一键双连去使能\r
- ret = gap_ble_set_ctkd_enable(false);\r
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gap_ble_set_ctkd_disable ret = %u", ret);\r
- \r
- svr_ble_adv_stop();//停止广播 不发送广播数据 就是app搜索不到该设备了\r
- free_ble_data(); //删除所有协议缓存数据\r
-}\r
-\r
-void uapi_ble_disconnect_device()\r
-{\r
- errcode_t ret = 0;\r
- bd_addr_t addr={0};\r
- get_phone_addr(&addr,g_ble_conn_id);\r
-\r
- ret = gap_ble_disconnect_remote_device((const bd_addr_t *)&addr);//与固定的mac设置地址进行断开连接\r
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gap_ble_disconnect_remote_device ret = %X", ret);\r
-\r
-}\r
-//开启蓝牙\r
-void custom_ble_service_start(void)\r
-{\r
- AdverFlag = true;\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "custom_ble_service_start ret");\r
-\r
- svr_ble_adv_start_param();\r
-}\r
-\r
-void custom_ble_service_start_(uint8_t data)\r
-{\r
- AdverFlag = true;\r
- svr_ble_adv_start_param();\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "custom_ble_service_start_ ");\r
- gap_br_set_bt_scan_mode(GAP_SCAN_MODE_CONNECTABLE, data);\r
- \r
-}\r
-#define MODE_BLE_ADV_SRV (0)\r
-#define MODE_ALIPAY_ADV_SRV (1)\r
-void ble_avd_mode_change(uint8_t mode)\r
-{\r
- \r
- uint8_t adv_ok = 0;\r
- switch(mode)\r
- {\r
- case MODE_BLE_ADV_SRV:\r
- \r
- if(get_ble_connect() && g_ble_conn_id!=0)\r
- {\r
- svr_ble_adv_stop();\r
- }\r
- break;\r
- case MODE_ALIPAY_ADV_SRV:\r
-\r
- \r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"alipay_ble_advd_start!!!!!!!!! ble_adv_falg: %d ,AdverFlag: %d",ble_adv_falg,AdverFlag);\r
- svr_ble_adv_start(); \r
- \r
- break;\r
- default:\r
- break;\r
- }\r
-}\r
-/**=================protocol recv decode service (task)=============================================================================================*/\r
-typedef struct\r
-{\r
- uint16_t service_handle;\r
- uint32_t msg_len;\r
- uint8_t *msg_data;\r
-} blesrv_custom_cmd_t;\r
-\r
-#define MAX_BUF_LEN sizeof(blesrv_custom_cmd_t) //sizeof(blesrv_custom_cmd_t) /*MTU max 514 , sizeof(blesrv_custom_cmd_t)*/\r
-static unsigned long g_blesrv_queue = 0xFFFFFFFF;\r
-static uint8_t g_blesrv_queue_created = 0;\r
-\r
-void blesrv_service_recv_msg_handler(uint16_t srv_handle, uint8_t * msg_data, uint32_t msg_len)\r
-{\r
- int ret;\r
- blesrv_custom_cmd_t blesrv_mail={0};\r
- if( g_blesrv_queue_created == 0) return ;\r
- if (msg_data == NULL) return;\r
-\r
- \r
- // mail = (blesrv_custom_cmd_t*)malloc(sizeof(blesrv_custom_cmd_t));\r
- uint32_t sendlen = MAX_BUF_LEN;\r
-\r
- \r
- blesrv_mail.service_handle = srv_handle;\r
- blesrv_mail.msg_len = msg_len;\r
- blesrv_mail.msg_data = (uint8_t*)malloc(msg_len);\r
-\r
- if(blesrv_mail.msg_data==NULL)\r
- {\r
- return ;\r
- }\r
- memcpy_s((blesrv_mail.msg_data),msg_len,msg_data,msg_len);\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"g_blesrv_queue:%d ble_recv:mail.msg_data %X %02X %02X %02X msg_data:%02X %02X %02X\r\n",\r
- g_blesrv_queue,\r
- blesrv_mail.msg_data,\r
- blesrv_mail.msg_data[0],\r
- blesrv_mail.msg_data[1],\r
- blesrv_mail.msg_data[2],\r
- msg_data[0],\r
- msg_data[1],\r
- msg_data[2]\r
- );\r
- ret = osal_msg_queue_write_copy(g_blesrv_queue, (void *)&blesrv_mail, sendlen , 0);\r
-\r
- if (ret != OSAL_SUCCESS)\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"Error blesrv Check send failed! err=0x%X! \r\n", ret);\r
- }\r
-} \r
-\r
-static void blesrv_service_check_task(void const *arg)\r
-{\r
- unused(arg);\r
- int32_t ret;\r
- blesrv_custom_cmd_t mail={0};\r
- uint32_t msgsize = MAX_BUF_LEN;\r
-\r
- while (1)\r
- {\r
- ret = osal_msg_queue_read_copy(g_blesrv_queue, (void *)&mail, &msgsize,\r
- OSAL_MSGQ_WAIT_FOREVER);\r
- if (ret != OSAL_SUCCESS)\r
- {\r
- //WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"OSAL_SUCCESS");\r
- continue;\r
- }\r
- \r
- uint8_t *p_msgbuf = (mail.msg_data);\r
- uint16_t server_handle = mail.service_handle;\r
- uint32_t msg_len = mail.msg_len;\r
-\r
- // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"mail.msg_data:%X,g_blesrv_queue:%d ble_recv:%d %d %02X %02X %02X mail.msg_data: %02X %02X %02X\r\n",\r
- // mail.msg_data,\r
- // g_blesrv_queue,\r
- // msg_len,\r
- // server_handle,\r
- // p_msgbuf[0],\r
- // p_msgbuf[1],\r
- // p_msgbuf[2],\r
- // mail.msg_data[0],\r
- // mail.msg_data[1],\r
- // mail.msg_data[2]);\r
-\r
- #if 1\r
- // if(server_handle == 0)\r
- // {}\r
-#ifdef SUPPORT_FACTORY_SERVICE\r
- if (server_handle == get_factory_ate_write_handl()) \r
- {\r
- factory_recv_cmd_data(p_msgbuf,msg_len,server_handle);\r
- }\r
- else if (server_handle == get_factory_ota_write_handl())\r
- {\r
- factory_recv_ota_data(p_msgbuf,msg_len,server_handle);\r
- }\r
-#endif\r
-#ifdef SUPPORT_CYWEE_BLE_SERVICE\r
- else if (server_handle == get_cywee_ate_write_handl())\r
- {\r
- cywee_recv_cmd_data(p_msgbuf,msg_len,server_handle);\r
- }\r
-#endif\r
- // else if(server_handle == alipay_handle)\r
- // {\r
- // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"alipay wirte!!!!!");\r
- // // // svr_alipay_bt_gatts_noyify(buf,5);\r
- // // errcode_t ret = svr_alipay_msg_write(ALIPAY_MSG_BT, p_msgbuf, msg_len, false);\r
-\r
- // }\r
- // else\r
- {\r
- #ifdef BLE_INSTRUCT\r
- revBleOldData(p_msgbuf,msg_len,server_handle);\r
- #endif\r
- }\r
- #endif\r
- if(mail.msg_data)\r
- {\r
- free(mail.msg_data);\r
- mail.msg_data = NULL;\r
- }\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ble_recv:end\r\n");\r
- }\r
-}\r
-#define BLESRV_APP_BOARD_MSG_COUNT 50\r
-#define BLESRV_APP_BOARD_TASK_SIZE 0x2000\r
-#define BLESRV_BOARD_TASK_PRIO 7\r
-void create_blesrv_queue(void)\r
-{\r
- if (osal_msg_queue_create("blesrv_service_queue", BLESRV_APP_BOARD_MSG_COUNT, &g_blesrv_queue,\r
- 0, MAX_BUF_LEN) != ERRCODE_SUCC)\r
- {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"[blesrv][service] app create mail fail g_blesrv_queue:%d\n",g_blesrv_queue);\r
- g_blesrv_queue_created = 0;\r
- }else{\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"[blesrv][service] app create mail success g_blesrv_queue:%d\n",g_blesrv_queue);\r
- g_blesrv_queue_created = 1;\r
- }\r
-\r
-}\r
-errcode_t uapi_blesrv_service_init(void)\r
-{\r
-\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"uapi_blesrv_service_init !\r\n");\r
- app_task_definition_t taskcfg = {0};\r
- taskcfg.create_queue_handle = create_blesrv_queue;\r
- taskcfg.attr.name = "blesrv_recv_service";\r
- taskcfg.attr.priority = osPriorityNormal;\r
- taskcfg.attr.stack_size = BLESRV_APP_BOARD_TASK_SIZE;\r
- taskcfg.func = blesrv_service_check_task;\r
- taskcfg.use_mem = USE_EXTEND_MEM;\r
-\r
- errcode_t ret = uapi_create_osThread_custom(&taskcfg);\r
- if (ret != ERRCODE_SUCC)\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"create blesrv_service failed %d!\r\n", ret);\r
- return ERRCODE_FAIL;\r
- }\r
-\r
- return ERRCODE_SUCC;\r
-}\r
-\r
-\r
-void send_pair_succ(bd_addr_t *addr)\r
-{\r
- sendParieSuccess(1,addr);\r
-}\r
-\r
- static uint8_t get_ble_Check_adv_status_falg=0;\r
-\r
-void Check_ble_adv_status(void)\r
-{\r
-\r
- if(get_ble_connect())\r
- {\r
- return;\r
- }\r
- else\r
- {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"get_ble_adv_status %s \n", get_ble_adv_status()?"true":"fales");\r
- \r
- if(get_ble_adv_status()==0)\r
- {\r
- get_ble_Check_adv_status_falg++;\r
- if(AdverFlag && get_ble_Check_adv_status_falg>=3)\r
- {\r
- if(uapi_dev_runtime_get_factory_test_status_flag())\r
- svr_ble_adv_factory_test_start_param();\r
- else\r
- svr_ble_adv_start_param(); \r
- }\r
- }\r
- else\r
- {\r
- get_ble_Check_adv_status_falg=0;\r
- }\r
- }\r
- return;\r
-}\r
-\r
-static unsigned long g_ble_Ai_record_queue = 0xFFFFFFFF;\r
-static uint8_t g_ble_Ai_record_queue_created = 0;\r
-\r
-void create_Ai_record_queue(void)\r
-{\r
- if (osal_msg_queue_create("Ai_record_queue", BLESRV_APP_BOARD_MSG_COUNT, &g_ble_Ai_record_queue,\r
- 0, MAX_BUF_LEN) != ERRCODE_SUCC)\r
- {\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"[blesrv][service] app create mail fail g_blesrv_queue:%d\n",g_ble_Ai_record_queue);\r
- g_ble_Ai_record_queue_created = 0;\r
- }else{\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"[blesrv][service] app create mail success g_blesrv_queue:%d\n",g_ble_Ai_record_queue);\r
- g_ble_Ai_record_queue_created = 1;\r
- }\r
-\r
-}\r
-\r
-\r
-#define Ai_TEST 0\r
-static uint32_t AI_data_count=0;\r
-\r
-\r
-static uint8_t AI_interval=5;\r
-\r
-void set_AI_interval(uint8_t data)\r
-{\r
- AI_interval=data;\r
-}\r
-\r
-void send_Ai_record(uint16_t len,uint8_t *data,uint32_t count)\r
-{\r
- uint8_t ai_buf[SDK_BLE_MTU_MAX]={0};\r
- if(count)\r
- {\r
- \r
- memcpy_s(ai_buf,SDK_BLE_MTU_MAX,&count,4);\r
- memcpy_s(&ai_buf[4],SDK_BLE_MTU_MAX-4,data,len);\r
- len+=4;\r
- }\r
- else\r
- {\r
- memcpy_s(ai_buf,SDK_BLE_MTU_MAX,data,len);\r
- }\r
- \r
- svr_ble_bt_gatts_noyify_AI(ai_buf,len);\r
-\r
- LOS_Msleep(AI_interval+get_ble_interval());\r
-}\r
-\r
-\r
-static void blesrvAi_send_service_task(void const *arg)\r
-{\r
- unused(arg);\r
- int32_t ret;\r
- blesrv_custom_cmd_t mail={0};\r
- uint32_t msgsize = MAX_BUF_LEN;\r
-\r
- #if Ai_TEST\r
- FILE* fp= fopen("user/airecord.pcm","wb+");\r
- #endif\r
- while (1)\r
- {\r
- ret = osal_msg_queue_read_copy(g_ble_Ai_record_queue, (void *)&mail, &msgsize,\r
- OSAL_MSGQ_WAIT_FOREVER);\r
- if (ret != OSAL_SUCCESS)\r
- {\r
- continue;\r
- }\r
- \r
-\r
- uint8_t *p_msgbuf = (mail.msg_data);\r
- uint16_t server_handle = mail.service_handle;\r
- uint32_t msg_len = mail.msg_len;\r
-\r
- if(server_handle==1 || server_handle==2)\r
- {\r
- AI_data_count=0;\r
- }\r
- else\r
- {\r
- AI_data_count++;\r
- }\r
-\r
- #if Ai_TEST\r
- fwrite(fp,1,mail.msg_len,mail.msg_data);\r
- #endif\r
- // if(get_ble_connect())\r
- \r
-\r
- if(mail.msg_data && mail.msg_len!=0)\r
- send_Ai_record(mail.msg_len,mail.msg_data,AI_data_count);\r
- \r
-\r
- if(mail.msg_data)\r
- {\r
- free(mail.msg_data);\r
- mail.msg_data = NULL;\r
- }\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ble_recv:end\r\n");\r
- }\r
-}\r
-\r
-\r
-static blesrv_custom_cmd_t g_blesrv_mail={0};\r
-\r
-errcode_t uapi_Ai_send_service_init(void)\r
-{\r
-\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"uapi_blesrv_service_init !\r\n");\r
- app_task_definition_t taskcfg = {0};\r
- taskcfg.create_queue_handle = create_Ai_record_queue;\r
- taskcfg.attr.name = "Ai_record_queue_service";\r
- taskcfg.attr.priority = osPriorityNormal;\r
- // taskcfg.attr.stack_size = BLESRV_APP_BOARD_TASK_SIZE;\r
- taskcfg.attr.stack_size = 0x1500;\r
- taskcfg.func = blesrvAi_send_service_task;\r
- taskcfg.use_mem = USE_EXTEND_MEM;\r
-\r
- g_blesrv_mail.msg_len=0;\r
- g_blesrv_mail.msg_data=NULL;\r
-\r
-\r
- errcode_t ret = uapi_create_osThread_custom(&taskcfg);\r
- if (ret != ERRCODE_SUCC)\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"create blesrv_service failed %d!\r\n", ret);\r
- return ERRCODE_FAIL;\r
- }\r
-\r
- return ERRCODE_SUCC;\r
-}\r
-\r
-\r
-uint32_t send_msg_data_into_Ai_msg_queue_count=0;\r
-\r
-\r
-void AI_data_assembly(uint8_t type,uint8_t *buf,uint8_t aitype)\r
-{\r
- \r
- memset_s(buf,ble_nus_max_data_len,0,19);\r
- // 设置消息头部信息\r
- buf[0] = 0x72; // 消息头\r
- buf[1] = 0x08; // 类型\r
- if(type)\r
- buf[2] = 0x01; // 类型ID\r
- else\r
- buf[2] = 0x02; // 类型ID\r
- uint32_t temp_data=1;\r
- memcpy(buf + 3, &temp_data, 4); // 总包数\r
- memcpy(buf + 7, &temp_data, 4); // 总数据长度\r
- memcpy(buf + 11, &temp_data, 4); // 数据包ID\r
- memcpy(buf + 15, &temp_data, 2); // 包数据长度\r
- \r
- buf[17] = aitype;\r
- buf[18] = Calculate_CRC_AI(buf,18);; // 计算CRC\r
-}\r
-\r
-static uint8_t g_blesrv_mail_flag=0;\r
-\r
-\r
-\r
-int send_msg_data_into_Ai_msg_queue(void *buff,uint16_t len,uint8_t type)\r
-{\r
- blesrv_custom_cmd_t blesrv_mail={0};\r
- uint32_t ret ;\r
- if( g_blesrv_queue_created == 0) return ERRCODE_FAIL;\r
- if (buff == NULL) return ERRCODE_FAIL;\r
-\r
- uint32_t sendlen = sizeof(blesrv_custom_cmd_t);\r
- uint32_t singlebuflen= ble_nus_max_data_len-20;\r
- blesrv_mail.msg_data=0;\r
-\r
- if(len<=singlebuflen)\r
- {\r
- if(type==1)\r
- {\r
- blesrv_mail.service_handle = 1;\r
- blesrv_mail.msg_len = len;\r
- blesrv_mail.msg_data = (uint8_t*)malloc(len);\r
-\r
- if(blesrv_mail.msg_data==NULL)\r
- {\r
- return ERRCODE_FAIL;\r
- }\r
- memcpy_s((void *)(blesrv_mail.msg_data),len,buff,len);\r
-\r
- ret = osal_msg_queue_write_copy(g_ble_Ai_record_queue, (void *)&blesrv_mail, sendlen , 0);\r
- if (ret != OSAL_SUCCESS)\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"len<=singlebuflen Error blesrv Check send failed! err=0x%X %d! \r\n", ret,send_msg_data_into_Ai_msg_queue_count);\r
- }\r
-\r
- if(g_blesrv_mail.msg_data)\r
- {\r
- free(g_blesrv_mail.msg_data);\r
- g_blesrv_mail.msg_data=NULL;\r
- g_blesrv_mail.msg_len=0;\r
- }\r
- return OSAL_SUCCESS;\r
-\r
- }\r
- else if(type==2)\r
- {\r
-\r
- blesrv_custom_cmd_t blesrv_mail_end={0};\r
-\r
- if(g_blesrv_mail.msg_len!=0 && g_blesrv_mail.msg_data!=NULL)\r
- {\r
- blesrv_mail_end.msg_len=g_blesrv_mail.msg_len;\r
- blesrv_mail_end.msg_data=malloc(g_blesrv_mail.msg_len);\r
- if(blesrv_mail_end.msg_data==NULL)\r
- {\r
- return ERRCODE_FAIL;\r
- }\r
-\r
- memcpy_s( blesrv_mail_end.msg_data,singlebuflen,g_blesrv_mail.msg_data,g_blesrv_mail.msg_len);\r
- free(g_blesrv_mail.msg_data);\r
- g_blesrv_mail.msg_data=NULL;\r
- g_blesrv_mail.msg_len=0;\r
-\r
- ret = osal_msg_queue_write_copy(g_ble_Ai_record_queue, (void *)&blesrv_mail_end, sendlen , 0);\r
- if (ret != OSAL_SUCCESS)\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"len<=singlebuflen Error blesrv Check send failed! err=0x%X %d! \r\n", ret,send_msg_data_into_Ai_msg_queue_count);\r
- }\r
- }\r
- \r
-\r
- blesrv_mail.service_handle = 2;\r
- blesrv_mail.msg_len = len;\r
- blesrv_mail.msg_data = (uint8_t*)malloc(len);\r
-\r
- if(blesrv_mail.msg_data==NULL)\r
- {\r
- return ERRCODE_FAIL;\r
- }\r
- memcpy_s((void *)(blesrv_mail.msg_data),len,buff,len);\r
-\r
- ret = osal_msg_queue_write_copy(g_ble_Ai_record_queue, (void *)&blesrv_mail, sendlen , 0);\r
- if (ret != OSAL_SUCCESS)\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"len<=singlebuflen Error blesrv Check send failed! err=0x%X %d! \r\n", ret,send_msg_data_into_Ai_msg_queue_count);\r
- }\r
- return OSAL_SUCCESS;\r
- }\r
- //以下为文件数据处理\r
- if(g_blesrv_mail.msg_len+len<singlebuflen)\r
- {\r
- if (g_blesrv_mail.msg_len!=0 || g_blesrv_mail.msg_data!=NULL)\r
- {\r
- // g_blesrv_mail.msg_data=realloc( g_blesrv_mail.msg_data,g_blesrv_mail.msg_len+len);\r
- uint8_t* temp_g_blesrv_mail_msg_data=malloc(g_blesrv_mail.msg_len+len);\r
- if(temp_g_blesrv_mail_msg_data==NULL)\r
- {\r
- return ERRCODE_FAIL;\r
- }\r
- memcpy_s(temp_g_blesrv_mail_msg_data+ g_blesrv_mail.msg_len,singlebuflen,buff,len);\r
- memcpy_s(temp_g_blesrv_mail_msg_data,singlebuflen,g_blesrv_mail.msg_data,g_blesrv_mail.msg_len);\r
-\r
- free(g_blesrv_mail.msg_data);\r
- g_blesrv_mail.msg_data=temp_g_blesrv_mail_msg_data;\r
- g_blesrv_mail.msg_len+=len;\r
- }\r
- else\r
- {\r
- g_blesrv_mail.msg_data=malloc(len);\r
- if(g_blesrv_mail.msg_data==NULL)\r
- {\r
- return ERRCODE_FAIL;\r
- }\r
-\r
- memcpy_s(g_blesrv_mail.msg_data+ g_blesrv_mail.msg_len,singlebuflen,buff,len);\r
- g_blesrv_mail.msg_len=len;\r
- }\r
- \r
- \r
- return OSAL_SUCCESS;\r
- }\r
- else if(g_blesrv_mail.msg_len+len==singlebuflen)\r
- {\r
- // g_blesrv_mail.msg_data=realloc( g_blesrv_mail.msg_data,g_blesrv_mail.msg_len+len);\r
-\r
- blesrv_mail.msg_len = singlebuflen;\r
- blesrv_mail.msg_data = (uint8_t*)malloc(singlebuflen);\r
- if(blesrv_mail.msg_data==NULL)\r
- {\r
- return ERRCODE_FAIL;\r
- }\r
-\r
- memcpy_s( blesrv_mail.msg_data,singlebuflen,g_blesrv_mail.msg_data,g_blesrv_mail.msg_len);\r
- memcpy_s( blesrv_mail.msg_data+ g_blesrv_mail.msg_len,singlebuflen,buff,len);\r
-\r
- g_blesrv_mail.msg_len=0;\r
- free( g_blesrv_mail.msg_data);\r
- g_blesrv_mail.msg_data=NULL;\r
-\r
- ret = osal_msg_queue_write_copy(g_ble_Ai_record_queue, (void *)&blesrv_mail, sendlen , 0);\r
- if (ret != OSAL_SUCCESS)\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"len<=singlebuflen Error blesrv Check send failed! err=0x%X %d! \r\n", ret,send_msg_data_into_Ai_msg_queue_count);\r
- }\r
- return OSAL_SUCCESS; \r
-\r
- }\r
- else\r
- {\r
- if(g_blesrv_mail.msg_len!=0 && g_blesrv_mail.msg_data!=NULL)\r
- {\r
- blesrv_mail.msg_len=g_blesrv_mail.msg_len;\r
- blesrv_mail.msg_data=malloc(g_blesrv_mail.msg_len);\r
- if(blesrv_mail.msg_data==NULL)\r
- {\r
- return ERRCODE_FAIL;\r
- }\r
- \r
- memcpy_s( blesrv_mail.msg_data,singlebuflen,g_blesrv_mail.msg_data,g_blesrv_mail.msg_len);\r
- free(g_blesrv_mail.msg_data);\r
-\r
- ret = osal_msg_queue_write_copy(g_ble_Ai_record_queue, (void *)&blesrv_mail, sendlen , 0);\r
- if (ret != OSAL_SUCCESS)\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"len<=singlebuflen Error blesrv Check send failed! err=0x%X %d! \r\n", ret,send_msg_data_into_Ai_msg_queue_count);\r
- }\r
-\r
- }\r
- \r
- g_blesrv_mail.msg_len=len;\r
- g_blesrv_mail.msg_data=malloc(len);\r
- memcpy_s( g_blesrv_mail.msg_data,singlebuflen,buff,len);\r
- \r
- \r
- return OSAL_SUCCESS; \r
- }\r
-\r
- }\r
- else\r
- {\r
- uint8_t count=len/singlebuflen;\r
- if(len%singlebuflen)\r
- {\r
- count++;\r
- }\r
- uint16_t residue_len=len;\r
- for(int i=0;i<count;i++)\r
- {\r
- blesrv_mail.service_handle = 0;\r
- if(residue_len>=singlebuflen)\r
- {\r
- blesrv_mail.msg_len = singlebuflen;\r
- blesrv_mail.msg_data = (uint8_t*)malloc(singlebuflen);\r
- \r
- if(blesrv_mail.msg_data==NULL)\r
- {\r
- return ERRCODE_FAIL;\r
- }\r
- memcpy_s((void *)(blesrv_mail.msg_data),singlebuflen,buff+i*singlebuflen,singlebuflen);\r
- residue_len-=singlebuflen;\r
- }\r
- else if(len%singlebuflen)\r
- {\r
- blesrv_mail.msg_len = len%singlebuflen;\r
- blesrv_mail.msg_data = (uint8_t*)malloc( len%singlebuflen);\r
- \r
- if(blesrv_mail.msg_data==NULL)\r
- {\r
- return ERRCODE_FAIL;\r
- }\r
- memcpy_s((void *)(blesrv_mail.msg_data),len%singlebuflen,buff+i*singlebuflen,len%singlebuflen);\r
- }\r
- \r
-\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"g_blesrv_queue:%d ble_recv:mail.msg_data %X %02X %02X %02X msg_data:%02X %02X %02X\r\n",\r
- g_ble_Ai_record_queue,\r
- blesrv_mail.msg_data,\r
- blesrv_mail.msg_data[0],\r
- blesrv_mail.msg_data[1],\r
- blesrv_mail.msg_data[2],\r
- msg_data[0],\r
- msg_data[1],\r
- msg_data[2]\r
- );\r
- ret = osal_msg_queue_write_copy(g_ble_Ai_record_queue, (void *)&blesrv_mail, sendlen , 0);\r
- if (ret != OSAL_SUCCESS)\r
- {\r
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"else Error blesrv Check send failed! err=0x%X %d %d! \r\n", ret,send_msg_data_into_Ai_msg_queue_count,len);\r
- }\r
- }\r
- }\r
- \r
- \r
- return ret;\r
-}\r
-\r
-\r
-\r
-#ifdef __cplusplus\r
-}\r
+/**
+ * Copyright (c) CompanyNameMagicTag 2023-2023. All rights reserved.
+ * Description: alipay bluetooth module.
+ * Author:
+ * Create:
+ */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "common_def.h"
+#include "bts_def.h"
+#include "bts_gatt_stru.h"
+#include "bts_a2dp_source.h"
+#include "bts_gatt_server.h"
+#include "bts_le_gap.h"
+#include "osal_task.h"
+#include "osal_semaphore.h"
+#include "soc_osal.h"
+#include "securec.h"
+#include "wearable_log.h"
+#include <stdint.h>
+#include <stdio.h>
+#include "stdbool.h"
+
+#include "bts_le_gap.h"
+#include "bts_br_gap.h"
+
+#ifdef SUPPORT_BATTERY_SERVICE
+#include "battery_hal.h"
+#endif
+
+#include "bleService.h"
+#ifdef SUPPORT_ALIPAY_SEC
+#include "alipay_feature.h"
+#endif
+#ifdef AILPAY_SUPPORT
+// #include "alipay_bluetooth.h"
+#endif
+#include "bts_a2dp_sink.h"
+#include "osal_timer.h"
+#include "bleEvent.h"
+#ifdef SUPPORT_HID_SERVICE
+#include "hidService.h"
+#endif
+#ifdef SUPPORT_FACTORY_SERVICE
+#include "factorytestService.h"
+#endif
+#ifdef SUPPORT_PPG_BLE_SERVICE
+#include "ppgBleService.h"
+#endif
+
+#include "build_version.h"
+#include "custom_runtime.h"
+#include "custom_utils.h"
+#ifdef BLE_INSTRUCT
+#ifdef BLE_INSTRUCT
+#include "bleInstruct.h"
+#endif
+#endif
+
+#include "ConfigModelC.h"
+#ifdef SUPPORT_CYWEE_BLE_SERVICE
+#include "cywee_ble_service.h"
+#endif
+#ifdef SUPPORT_OHOSFWK
+#include "BluetoothWrapper.h"
+#endif
+#include "custom_save_runtime.h"
+
+
+// extern void bts_data_to_uuid_len2(uint16_t uuid_data, bt_uuid_t *out_uuid);
+// extern void bts_init_128bit_uuid(const bt_uuid_t *uuid);
+// #include "ble_hid_take_photo_server.h"
+/* Gatt service UUID */
+#define BLE_SERVICE_UUID 0x18e0
+/* Gatt Characteristic UUID */
+//自定义 ota 文件传输特征值
+#define BLE_ZHIHUI_OTA_ID 0x2ae6
+#define BLE_ZHIHUI_OTA_REPLY_ID 0x2ae7
+
+#define BLE_ZHIHUI_AI_ID 0x2ae8
+
+#define BLE_CHARACTERISTIC_RECV_ID 0x2ae5
+#define BLE_CHARACTERISTIC_SNED_SHORT_ID 0x2ae3
+
+#define BLE_CHARACTERISTIC_SNED_LONG_ID 0x2ae4
+#define BLE_CHARACTERISTIC_SNED_OTA_ID 0x2ae0
+#define BLE_CHARACTERISTIC_SNED_ANDRIOD_ID 0x2ae1
+#define BLE_CHARACTERISTIC_READ_BATTERY_ID 0x2ae2
+/* Client Characteristic Configuration UUID */
+#define BLE_UUID_CLIENT_CHARACTERISTIC_CONF 0x2902
+/*user Characteristic Configuration UUID*/
+#define BLE_UUID_USER_CHARACTERISTIC_CONF 0x2901
+/* Gatt Characteristic max length */
+#define BLE_CHARACTERISTIC_MAX_LENGTH 256
+#define BLE_ADV_ID 1
+#define BLE_ADV_DATA_MAX_LENGTH 31
+#define BLE_ADV_BLE_NAME_MAX_LENGTH 31 // 31-4-2-3-9 = 13
+#define BLE_NAME_LENGTH 32
+#define BLE_ADV_MAC_HEAD_LENTH 4
+#define BLE_ADV_MAC_LENTH 10
+#define BLE_SCAN_DATA_LENTH 31 //扫描数据
+#define BLE_ADV_TYPE_LENTH 3
+#define BLE_ADV_UUID_LENTH 4
+
+#define BLE_DEFAULT_NAME_LEN 32
+#define BLE_MAC_MAX_LEN 6 //蓝牙mac地址最大个数6个
+
+
+
+#define SWAP_U16(x) ((uint16_t)((((uint16_t)(x) & (uint16_t)0x00ffU) << 8) | \
+ (((uint16_t)(x) & (uint16_t)0xff00U) >> 8)))
+
+static uint8_t exit_alipay_gui = 0;
+// 蓝牙模块全局变量
+static gap_ble_callbacks_t g_ble_gapble_cbs;
+static gatts_callbacks_t g_ble_gatts_cbs;
+static gap_call_backs_t g_btGapCallBacks;
+
+
+static bool g_ble_adv_start_state = false;
+uint16_t g_ble_server_id = 1;
+
+static uint16_t g_ble_read_handle = 0;
+uint16_t g_ble_conn_id = 0;
+uint16_t g_changan_icce_sub_conn_id = 0;
+uint8_t g_changan_icce_sub_client_id = 0;
+uint16_t g_ble_Alipay_conn_id = 0;
+uint16_t g_ble_server_handle = 0;
+static uint8_t g_ble_character_buf[BLE_CHARACTERISTIC_MAX_LENGTH] = {0};
+static const uint8_t ble_adv_type[BLE_ADV_TYPE_LENTH] = {2, 1, 0xA};
+static const uint8_t ble_adv_uuid[BLE_ADV_UUID_LENTH] = {0x3, 0x3, 0xe0, 0x18};
+static const uint8_t ble_adv_tx[4] = {0x03,0x03,0xe0,0x18};
+static bool AdverFlag = false;
+
+static uint8_t scan_data[BLE_SCAN_DATA_LENTH] = {0};
+
+uint8_t phone_mac_data[6]={0};
+
+#define ble_add_max_num 10
+static bd_addr_t phone_addr[ble_add_max_num]={0};
+static uint16_t ble_conn_id[ble_add_max_num]={0};
+
+
+bd_addr_t disconect_addr;//断开连接地址不需要反序
+
+uint8_t Bleconnect = 0;//蓝牙默认是断开 0 1 为连接
+uint8_t devpair_state = 0;//设备配对状态 0 未配对 1已配对成功
+uint8_t bond_flag = 0;//绑定标识
+uint16_t ble_nus_max_data_len = SDK_BLE_MTU_MIN - 3;
+
+uint16_t data2ae3Cmd = 0;//2ae3短指令特征值
+uint16_t data2ae4Cmd = 0;
+uint16_t data2ae5Cmd = 0;
+uint16_t data2ae2Cmd = 0;//read
+uint16_t data2ae1Cmd = 0;//安卓消息来电
+uint16_t data2ae0Cmd = 0;//OTA
+uint16_t data2ae6Cmd = 0;//自定义OTA
+uint16_t data2ae7Cmd = 0;//自定义OTA
+uint16_t data2ae8Cmd = 0;//AI
+
+#define handle_max_len 40
+
+static uint16_t Is_value_handle[handle_max_len]={0};
+
+static uint32_t handle_num=0;
+
+static bd_addr_t g_scan_addr = {0};
+static bool ble_bd_addr_mac_forward_or_reverse_equal(const uint8_t *expect, const uint8_t *seen);
+
+
+void get_phone_addr(bd_addr_t *addr,uint16_t conn_id)
+{
+ if (addr==NULL)
+ return;
+
+ for(int i=0;i<ble_add_max_num;i++)
+ {
+ if(conn_id==ble_conn_id[i])
+ {
+ memcpy(addr,&phone_addr[i],sizeof(bd_addr_t));
+ }
+ }
+
+}
+static uint16_t add_num=0;
+
+static void set_phone_info(bd_addr_t *addr,uint16_t conn_id)//保存手机信息 包含手机mac地址
+{
+ memcpy(&phone_addr[add_num],addr,sizeof(bd_addr_t));
+ ble_conn_id[add_num]=conn_id;
+
+ add_num++;
+ if(add_num==ble_add_max_num)
+ {
+ add_num=0;
+ }
+}
+
+
+static void clean_phone_info(uint16_t conn_id)//保存手机信息 包含手机mac地址
+{
+ for(int i=0;i<ble_add_max_num;i++)
+ {
+ if(conn_id==ble_conn_id[i])
+ {
+ bd_addr_t addr={0};
+ memcpy(&phone_addr[i],&addr,sizeof(bd_addr_t));
+ ble_conn_id[i]=0;
+ return;
+ }
+ }
+}
+
+
+bool get_ble_connect(void)//保存手机信息 包含手机mac地址
+{
+ for(int i=0;i<ble_add_max_num;i++)
+ {
+ if(ble_conn_id[i]!=0)
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool get_Alipay_ble_connect(void)//保存手机信息 包含手机mac地址
+{
+ uint8_t connect=0;
+ for(int i=0;i<ble_add_max_num;i++)
+ {
+ if(ble_conn_id[i]!=0)
+ {
+ if(g_ble_Alipay_conn_id==ble_conn_id[i])
+ return true;
+ }
+ }
+
+ {
+ return false;
+ }
+
+}
+
+enum{
+ BLE_CHARACTERISTIC_RECV_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_NOTIFY|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP|GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_READ,
+ BLE_CHARACTERISTIC_SNED_SHORT_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,
+ BLE_CHARACTERISTIC_SNED_LONG_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,
+ BLE_CHARACTERISTIC_SNED_OTA_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,
+ BLE_CHARACTERISTIC_SNED_ANDRIOD_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,
+ BLE_CHARACTERISTIC_READ_BATTERY_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_READ|GATT_CHARACTER_PROPERTY_BIT_NOTIFY,
+ BLE_ZHIHUI_OTA_ID_ID_PROPERTIES=GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,
+ BLE_ZHIHUI_AI_ID_ID_PROPERTIES=GATT_CHARACTER_PROPERTY_BIT_NOTIFY|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP|GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_READ,
+ BLE_ZHIHUI_OTA_REPLY_ID_PROPERTIES=GATT_CHARACTER_PROPERTY_BIT_NOTIFY|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP|GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_READ,
+};
+static uint8_t ble_adv_falg = 0;
+static bool g_custom_ble_init_flag = false;
+
+errcode_t svr_ble_adv_stop(void)
+{
+ ble_adv_falg = 0;
+ return gap_ble_stop_adv(BLE_ADV_ID);
+}
+void svr_ble_adv_start(void)
+{
+ ble_adv_falg = 1;
+ if(AdverFlag==true)
+ gap_ble_start_adv(BLE_ADV_ID);
+}
+
+
+void br_adv_start(uint8_t sec)
+{
+ //ble广播开启
+ svr_ble_adv_start_param();
+
+ if(!get_br_is_pair())
+ {
+
+ }
+}
+
+void br_adv_stop(void)
+{
+ gap_br_set_bt_scan_mode(GAP_SCAN_MODE_NONE, 0);
+}
+//留档保存,方便后面查看此数据是否正确
+static uint8_t save_adv_data[BLE_ADV_DATA_MAX_LENGTH] = {0};
+
+void get_adv_data(char *data)
+{
+ uint32_t data_len=0;
+ for(int i=0;i<BLE_ADV_DATA_MAX_LENGTH;i++)
+ {
+ char UintBUF[3]={0};
+ sprintf(UintBUF,"%02X",save_adv_data[i]);
+ memcpy_s(data+data_len,2,UintBUF,2);
+ data_len+=2;
+ }
+
+}
+
+/* adapt ios adv data. *///设置广播和扫描数据
+static void svr_ble_adv_data_set(int adv_id)
+{
+ uint8_t ble_name[BLE_NAME_LENGTH] = {0};
+ uint8_t ble_name_len = BLE_NAME_LENGTH;
+ uint8_t adv_data[BLE_ADV_DATA_MAX_LENGTH] = {0};
+ uint8_t adv_data_len = 0;
+ uint8_t scan_data_len = 0;
+ uint8_t ble_data_name[BLE_ADV_BLE_NAME_MAX_LENGTH + 1 ] = {0}; // +TYPE LENGTH
+ uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};
+ uint8_t adv_mac_head[BLE_ADV_MAC_LENTH] = {0x9, 0x16, 0x02, 0x38};
+ gap_ble_config_adv_data_t adv_data_info;
+ memset_s(&adv_data_info, sizeof(gap_ble_config_adv_data_t), 0, sizeof(gap_ble_config_adv_data_t));
+ unsigned char addr[BLE_MAC_MAX_LEN] = {0};
+ unsigned int len = BLE_MAC_MAX_LEN;
+ errcode_t ret = 0;
+
+ memset(addr,0,6);
+ bluetooth_get_local_addr(&addr[0],len);
+ ret = bluetooth_get_local_name(ble_name, &ble_name_len);
+ if (ret != 0) {
+ memset_s(ble_name, BLE_NAME_LENGTH, 0, BLE_NAME_LENGTH);
+ (void)sprintf_s((char*)ble_name, BLE_NAME_LENGTH, "%s %02X%02X",BLE_DEFAULT_NAME,addr[1],addr[0]);
+ ble_name_len = strlen((char*)ble_name) + 1;
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_get_local_name fail,rename name:%s,len:%u,ret:%u.", ble_name, ble_name_len, ret);
+ }
+ int k = BD_ADDR_LEN;
+ for (int i = 0; i < BD_ADDR_LEN; i++) {
+ ble_data_mac_switch[--k] = addr[i];
+ }
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_get_local_name name:%s,len:%u,ret:%u.", ble_name, ble_name_len, ret);
+ memcpy_s(adv_data, sizeof(ble_adv_type), ble_adv_type, sizeof(ble_adv_type));//0x02 0x01 0x02
+ adv_data_len = sizeof(ble_adv_type);
+ // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"adv_data_len!!!!:%d\r\n",adv_data_len);
+
+ // 2. 添加心率服务UUID(0x180D)
+ if(uapi_dev_runtime_get_hrs_ble_status())
+ {
+ // 格式:[长度(0x03)][类型(0x03)][UUID低字节(0x0D)][UUID高字节(0x18)]
+ if (adv_data_len + 4 <= BLE_ADV_DATA_MAX_LENGTH) {
+ adv_data[adv_data_len++] = 0x03; // 长度:3字节(类型+UUID)
+ adv_data[adv_data_len++] = 0x03; // 类型:16位服务UUID列表
+ adv_data[adv_data_len++] = 0x0D; // 心率服务UUID低字节
+ adv_data[adv_data_len++] = 0x18; // 心率服务UUID高字节
+ } else {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "No space for heart rate UUID");
+ }
+ }
+
+ adv_data[adv_data_len++] = 0x0f;//长度
+ adv_data[adv_data_len++] = 0xff;//数据类型 manufactory data
+#if defined(BOARD_W9)
+ adv_data[adv_data_len++] = 'W';
+ adv_data[adv_data_len++] = '9';
+// #elif defined(BOARD_N9)
+// adv_data[adv_data_len++] = 'N';
+// adv_data[adv_data_len++] = '9';
+#else
+ adv_data[adv_data_len++] = 'J';
+ adv_data[adv_data_len++] = 'H';
+#endif
+ adv_data[adv_data_len++] = bond_flag;//是否绑定
+ adv_data[adv_data_len++] = ble_data_mac_switch[5];
+ adv_data[adv_data_len++] = ble_data_mac_switch[4];
+ adv_data[adv_data_len++] = ble_data_mac_switch[3];
+ adv_data[adv_data_len++] = ble_data_mac_switch[2];
+ adv_data[adv_data_len++] = ble_data_mac_switch[1];
+ adv_data[adv_data_len++] = ble_data_mac_switch[0];
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "adv_data_info.adv_length.adv_data_len:%d\r\n",adv_data_len);
+#if defined(BOARD_W9)
+ adv_data[adv_data_len++] = 0x06; //w9 app
+ adv_data[adv_data_len++] = 0x06;
+// #elif defined(BOARD_N9)
+// adv_data[adv_data_len++] = 0x07; //n9 app
+// adv_data[adv_data_len++] = 0x07;
+#else
+ adv_data[adv_data_len++] = 0x05;
+ adv_data[adv_data_len++] = 0x05;
+#endif
+
+ uint8_t _major,_mid,_minor;
+ uapi_get_fw_version(&_major,&_mid,&_minor);
+ adv_data[adv_data_len++] = _major;
+ adv_data[adv_data_len++] = _mid;
+ adv_data[adv_data_len++] = _minor;
+
+ if(adv_data_len > BLE_ADV_DATA_MAX_LENGTH)
+ {
+ adv_data_len = BLE_ADV_DATA_MAX_LENGTH;
+ }
+
+ //scan_data
+ if (ble_name_len > BLE_ADV_BLE_NAME_MAX_LENGTH) {
+ ble_name_len = BLE_ADV_BLE_NAME_MAX_LENGTH;
+ }
+ ble_data_name[0] = ble_name_len;
+ ble_data_name[1] = 0x9;
+ memcpy_s(&ble_data_name[2], ble_name_len - 1, ble_name, ble_name_len - 1);
+
+ memcpy_s(scan_data + scan_data_len, ble_name_len + 1, ble_data_name, ble_name_len + 1);
+
+ scan_data_len = scan_data_len + ble_name_len + 1;
+ // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"scan_data_len!!!22:%d ble_name_len:%d\r\n",scan_data_len,ble_name_len);
+ memcpy_s(scan_data + scan_data_len, sizeof(ble_adv_uuid), ble_adv_uuid, sizeof(ble_adv_uuid));//这是tx power
+ scan_data_len = scan_data_len + sizeof(ble_adv_uuid);
+ // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"scan_data_len!!!!3333:%d\r\n",scan_data_len);
+
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble_info:%02x:%02x:%02x:%02x:%02x:%02x", ble_data_mac_switch[0], ble_data_mac_switch[1],
+ ble_data_mac_switch[2], ble_data_mac_switch[3], ble_data_mac_switch[4], ble_data_mac_switch[5]);
+
+ memcpy_s(adv_mac_head + BLE_ADV_MAC_HEAD_LENTH, BD_ADDR_LEN, ble_data_mac_switch, BD_ADDR_LEN);
+
+ memcpy_s(scan_data + scan_data_len, sizeof(adv_mac_head), adv_mac_head, sizeof(adv_mac_head));
+ scan_data_len = scan_data_len + sizeof(adv_mac_head);
+ // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"adv_data_len!!!!4444:%d\r\n",scan_data_len);
+
+
+ if (scan_data_len > BLE_SCAN_DATA_LENTH){
+ scan_data_len = BLE_SCAN_DATA_LENTH;
+ }
+ //
+ memcpy_s(save_adv_data,BLE_ADV_DATA_MAX_LENGTH,adv_data,BLE_ADV_DATA_MAX_LENGTH);
+
+ adv_data_info.scan_rsp_data = scan_data;//扫描数据
+ adv_data_info.scan_rsp_length = scan_data_len;//扫描长度
+ adv_data_info.adv_data = adv_data;//广播数据
+ adv_data_info.adv_length = adv_data_len;//广播长度
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "adv_data_info.adv_length:%u. scan_data_len:%d\r\n", adv_data_len,scan_data_len);
+
+ gap_ble_set_adv_data(adv_id, &adv_data_info);
+
+ return;
+}
+
+
+void svr_ble_adv_factory_test_start_param(void)
+{
+ errcode_t ret = 0;
+ int adv_id = BLE_ADV_ID;
+ if (ble_adv_falg == 1) { //已经开始广播了,不需要重复开启广播
+ ret=gap_ble_stop_adv(adv_id);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble adv need restart , gap_ble_stop_adv ret %x\n",ret);
+ osDelay(50);
+ }
+
+ gap_ble_adv_params_t adv_para;
+ memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));
+
+ adv_para.min_interval = 0x64;//0x640;
+ adv_para.max_interval = 0x64;
+ adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;
+ //adv_para.tx_power=20;
+ adv_para.channel_map = 0x07;
+ adv_para.duration = 0;
+
+ gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数
+ gap_ble_set_local_appearance(GAP_BLE_APPEARANCE_TYPE_GENERIC_WATCH);//仅是手表
+ svr_ble_adv_data_set(adv_id);//开始广播和扫描数据
+ ble_adv_falg = 1;
+ ret = gap_ble_start_adv(adv_id);
+ if (ret) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_adv_start bt gap_ble_start_adv1 ret = 0x%x", ret);
+ }
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_adv_start bt gap_ble_start_adv2 ret = 0x%x", ret);
+}
+
+
+static int8_t ble_adv_init_falg=100;
+
+static osTimerId_t ble_adv_timer=NULL;
+
+static uint32_t last_package_id=0;
+
+static void ble_adv_Timer_CallBack(int data)
+{
+ ble_adv_init_falg--;
+
+ if(ble_adv_init_falg<=0)
+ {
+ int adv_id = BLE_ADV_ID;
+
+ errcode_t ret = 0;
+ if(get_ble_adv_status())
+ {
+ ret=gap_ble_stop_adv(adv_id);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble adv need restart , gap_ble_stop_adv ret %x\n",ret);
+ osDelay(50);
+
+ if(!uapi_dev_runtime_get_factory_test_status_flag())
+ {
+ gap_ble_adv_params_t adv_para;
+ memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));
+ adv_para.min_interval = 0x640;
+ adv_para.max_interval = 0x640;
+ adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;
+ adv_para.channel_map = 0x7;
+ adv_para.duration = 0;
+
+ // ret=gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble adv need restart , gap_ble_set_adv_param ret %x\n",ret);
+
+ }
+ if(get_ble_connect()==false)
+ {
+ ret=gap_ble_start_adv(adv_id);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble adv need restart , gap_ble_start_adv ret %x\n",ret);
+ }
+
+
+ }
+ else
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "no sdv\n");
+ if(!uapi_dev_runtime_get_factory_test_status_flag())
+ {
+
+ gap_ble_adv_params_t adv_para;
+ memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));
+ adv_para.min_interval = 0x640;
+ adv_para.max_interval = 0x640;
+ adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;
+ adv_para.channel_map = 0x7;
+ adv_para.duration = 0;
+ ret=gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble adv need restart , gap_ble_set_adv_param ret %x\n",ret);
+
+ }
+
+
+
+ }
+
+
+ osTimerStop(ble_adv_timer);
+ osTimerDelete(ble_adv_timer);
+ ble_adv_timer = NULL;
+
+ }
+}
+
+
+
+void svr_ble_adv_start_param(void)
+{
+ errcode_t ret = 0;
+ int adv_id = BLE_ADV_ID;
+ if (ble_adv_falg == 1) { //已经开始广播了,不需要重复开启广播
+ ret=gap_ble_stop_adv(adv_id);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble adv need restart , gap_ble_stop_adv ret %x\n",ret);
+ osDelay(50);
+ }
+
+ if(ble_adv_init_falg)
+ {
+ gap_ble_adv_params_t adv_para;
+ memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));
+ adv_para.min_interval = 0x64;
+ adv_para.max_interval = 0x64;
+ adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;
+ adv_para.channel_map = 0x7;
+ adv_para.duration = 0;
+ gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数
+
+ uint32_t tick;
+ osStatus_t retTimer;
+ if(ble_adv_timer!=NULL)
+ {
+ osTimerStop(ble_adv_timer);
+ osTimerDelete(ble_adv_timer);
+ ble_adv_timer = NULL;
+ }
+
+ ble_adv_timer = osTimerNew((osTimerFunc_t)ble_adv_Timer_CallBack, osTimerPeriodic, NULL, NULL);
+ tick =osMs2Tick(1000);
+ retTimer = osTimerStart(ble_adv_timer, tick);
+ if (retTimer != osOK && ble_adv_timer != NULL) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"StartCallTimer osTimerStart failed, ret = %lx!!", retTimer);
+ osTimerDelete(ble_adv_timer);
+ ble_adv_timer = NULL;
+ return;
+ }
+
+ }
+ else
+ {
+ if(!uapi_dev_runtime_get_factory_test_status_flag())
+ {
+ gap_ble_adv_params_t adv_para;
+ memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));
+ adv_para.min_interval = 0x640;
+ adv_para.max_interval = 0x640;
+ adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;
+ adv_para.channel_map = 0x7;
+ adv_para.duration = 0;
+ gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数
+ }
+ else
+ {
+ gap_ble_adv_params_t adv_para;
+ memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));
+ adv_para.min_interval = 0x64;
+ adv_para.max_interval = 0x64;
+ adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;
+ adv_para.channel_map = 0x7;
+ adv_para.duration = 0;
+ gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数
+ }
+
+ }
+
+ gap_ble_set_local_appearance(GAP_BLE_APPEARANCE_TYPE_GENERIC_WATCH);//仅是手表
+ svr_ble_adv_data_set(adv_id);//开始广播和扫描数据
+ ble_adv_falg = 1;
+ ret = gap_ble_start_adv(adv_id);
+ if (ret) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_adv_start bt gap_ble_start_adv1 ret = 0x%x", ret);
+ }
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_adv_start bt gap_ble_start_adv2 ret = 0x%x", ret);
+}
+uint8_t mtu_flag = 0;
+
+void svr_ble_connstate_change_cb(unsigned short conn_id, bd_addr_t *addr, gap_ble_conn_state_t conn_state,
+ gap_ble_pair_state_t pair_state, gap_ble_disc_reason_t disc_reason)
+{
+
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+ "svr_ble_connstate_change_cb gap_ble_conn_state_t conn_state:%d pair_state:%d disc_reason:%d\r\n",
+ conn_state,pair_state,disc_reason);
+ if(ble_bd_addr_mac_forward_or_reverse_equal(g_scan_addr.addr, addr->addr))
+ {
+ if(GAP_BLE_STATE_DISCONNECTED==conn_state)
+ {
+ ble_icce_clear_by_conn(g_changan_icce_sub_client_id,g_changan_icce_sub_conn_id);
+ g_changan_icce_sub_conn_id = 0;
+ g_changan_icce_sub_client_id = 0;
+ mtu_flag = 0;
+ }
+ else if(GAP_BLE_STATE_CONNECTED==conn_state)
+ {
+ mtu_flag = 1;
+ }
+
+ }
+ else
+ {
+
+
+ if (GAP_BLE_STATE_DISCONNECTED == conn_state)
+ { // restart ble adv when disconnected
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "GAP_BLE_STATE_DISCONNECTED!!! \r\n");
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_DISCONNECT);
+
+ clean_phone_info(conn_id);
+
+ //如果ble连接全部断连,则需要重新开启广播
+ //可能因ble连接不够稳定,快速断开ble连接,无法将连接判定为app连接导致断连的时候没有正确重新开启广播
+
+ if(conn_id==g_ble_conn_id || !get_ble_connect())
+ {
+ free_ble_data();
+
+ ble_disconnect_ok();
+
+ g_ble_conn_id=0;
+
+ //APP断连
+ Bleconnect = GAP_BLE_STATE_DISCONNECTED;//蓝牙已断开
+
+ if(get_ble_pair())
+ {
+ ble_ancs_client_clear(conn_id);
+ }
+
+ svr_ble_adv_start();
+ }
+ else if (ble_is_Alipay_bind()==true)
+ {
+ //如果当前页面处于支付宝界面,则重新开广播
+ svr_ble_adv_start();
+ }
+
+ if(g_ble_Alipay_conn_id==conn_id)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "支付宝断开连接 \r\n");
+ }
+
+ }
+ else
+ {
+ devpair_state = 0;//
+
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_CONNECT);
+
+
+ if( g_ble_conn_id !=0 && conn_id!=g_ble_conn_id)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"支付宝连接");
+ }
+
+
+ int ret =svr_ble_adv_stop();
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"%x",ret);
+
+ set_phone_info(addr,conn_id);
+
+ ble_connect_ok();
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "addr: ****%02x%02x%02x%02x \n",
+ addr->addr[3], addr->addr[2], addr->addr[1], addr->addr[0]); /* 3 2 1 0 idx */
+
+
+ Bleconnect = GAP_BLE_STATE_CONNECTED;//蓝牙已连接
+
+
+ }
+
+ uapi_dev_runtime_set_ble_connect_stat(Bleconnect);
+ }
+
+}
+
+static uint16_t need_update_connect_param=BLE_CONNECT_INTERVAL_HIGH;
+
+static osTimerId_t ble_connect_timer=NULL;
+
+static int8_t connect_updata_count=3;
+
+static void ble_connect_Timer_CallBack(int data)
+{
+ if(get_ble_connect() && connect_updata_count>0)
+ {
+ gap_conn_param_update_t conn_param = { 0 };
+ conn_param.conn_handle = g_ble_conn_id; /* param 0: conn_handle */
+ conn_param.interval_min =need_update_connect_param; /* param 1: interval_min 1.25ms */
+ conn_param.interval_max = need_update_connect_param; /* param 2: interval_max */
+ conn_param.slave_latency = 6; /* param 3: slave_latency */
+ conn_param.timeout_multiplier = 500; /* param 4: timeout_multiplier 10ms */
+ int ret = gap_ble_connect_param_update(&conn_param);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "触发 连接参数timer更新");
+ connect_updata_count--;
+
+ }
+ else
+ {
+ osTimerStop(ble_connect_timer);
+ osTimerDelete(ble_connect_timer);
+ ble_connect_timer = NULL;
+ }
+}
+
+static uint16_t ble_interval=50;
+
+uint16_t get_ble_interval(void)
+{
+ float temp_data =(float)ble_interval*1.25f;
+
+ return (uint16_t)temp_data;
+
+}
+
+void srv_gap_ble_connect_param_update_callback(uint16_t conn_id, errcode_t status,
+ const gap_ble_conn_param_update_t *param)
+{
+ if(param->interval==50)
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_CONNECT_UPDATE_50);
+ else if(param->interval==12)
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_CONNECT_UPDATE_12);
+ else
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_CONNECT_UPDATE|param->interval);
+
+ ble_interval=param->interval;
+
+ if(ble_connect_timer!=NULL)
+ {
+ osTimerStop(ble_connect_timer);
+ osTimerDelete(ble_connect_timer);
+ ble_connect_timer = NULL;
+ }
+
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+ "conn_id %d status %d gap_ble_conn_param_update_t interval %d latency%d timeout %d ",conn_id,status,param->interval,param->latency,param->timeout);
+}
+
+
+
+void uapi_ble_connect_param_update(uint16_t data)
+{
+ gap_conn_param_update_t conn_param = { 0 };
+ conn_param.conn_handle = g_ble_conn_id; /* param 0: conn_handle */
+ conn_param.interval_min =data; /* param 1: interval_min 1.25ms */
+ conn_param.interval_max = data; /* param 2: interval_max */
+ conn_param.slave_latency = 6; /* param 3: slave_latency */
+ conn_param.timeout_multiplier = 500; /* param 4: timeout_multiplier 10ms */
+ int ret = gap_ble_connect_param_update(&conn_param);
+
+ need_update_connect_param=data;
+
+
+
+ uint32_t tick;
+ osStatus_t retTimer;
+ if(ble_connect_timer!=NULL)
+ {
+ osTimerStop(ble_connect_timer);
+ osTimerDelete(ble_connect_timer);
+ ble_connect_timer = NULL;
+ }
+
+ ble_connect_timer = osTimerNew((osTimerFunc_t)ble_connect_Timer_CallBack, osTimerPeriodic, NULL, NULL);
+ tick =osMs2Tick(3000);
+ retTimer = osTimerStart(ble_connect_timer, tick);
+ if (retTimer != osOK && ble_connect_timer != NULL) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"StartCallTimer osTimerStart failed, ret = %lx!!", retTimer);
+ osTimerDelete(ble_connect_timer);
+ ble_connect_timer = NULL;
+ return;
+ }
+ connect_updata_count=3;
+
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"gap ble update connection parameters %d ret: %X\n",data,ret);
+}
+void svr_pair_result_cbt_cb(uint16_t conn_id, const bd_addr_t *addr, errcode_t status)
+{
+ devpair_state = 1;//代表配对成功了
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+ "svr_pair_result_cbt_cb!!! addr 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x status:0x%x\r\n",addr->addr[0],addr->addr[1],
+ addr->addr[2],addr->addr[3],addr->addr[4],addr->addr[5],status);
+ if(status==ERRCODE_SUCC)
+ {
+ if(get_ble_pair())
+ ble_ancs_client_cmd_setup_and_subscribe(conn_id);
+
+ if(get_ctkd_flag() && uapi_dev_runtime_get_bt_powerstat())
+ {
+
+ if(get_ble_pair()&&( cm_get_A2DP_switch() || cm_get_HFP_switch()))
+ {
+ if(cm_get_A2DP_switch() && cm_get_A2DP_switch())
+ {
+ int ret=gap_reconnect_media_device(addr);
+ }
+ else if(cm_get_A2DP_switch())
+ {
+ uapi_a2dp_snk_connect();
+ }
+ else if(cm_get_HFP_switch())
+ {
+ uapi_hfp_connect();
+ }
+
+
+ }
+ else
+ {
+ if(get_br_is_pair())
+ {
+ bd_addr_t bdaddr={0};
+ uapi_get_br_address(&bdaddr);
+ if(false==(bt_is_acl_connected(&bdaddr)))
+ {
+ if(cm_get_A2DP_switch() || cm_get_HFP_switch())
+ {
+ int ret=gap_reconnect_media_device(&bdaddr);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_reconnect_media_device!!! %X\r\n",ret);
+ }
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "gap_reconnect_media_device!!! \r\n");
+ }
+ else
+ {
+ if(cm_get_A2DP_switch() || cm_get_HFP_switch())
+ uapi_a2dp_snk_connect();
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "uapi_a2dp_snk_connect!!! \r\n");
+ }
+ }
+ }
+ }
+ hand_watch_first_time_Paired();
+
+ }
+}
+
+//添加ota特征值
+static void srv_ble_add_chart_decr_ota(uint8_t server_id,uint16_t srv_handle)
+{
+ errcode_t ret = 0;
+ static uint8_t ota_point_val[] = {0x00, 0x00};
+ gatts_add_chara_info_t character;
+ gatts_add_desc_info_t descriptor;
+ bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_OTA_ID, &character.chara_uuid);
+ character.permissions = GATT_ATTRIBUTE_PERMISSION_READ;
+ character.properties = BLE_CHARACTERISTIC_SNED_OTA_ID_PROPERTIES;
+ character.value_len = (uint16_t)sizeof(ota_point_val);
+ character.value = ota_point_val;
+
+ ret = gatts_add_characteristic(server_id, srv_handle, &character);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+ }
+ bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;
+ descriptor.value_len = (uint16_t)sizeof(ota_point_val);
+ descriptor.value = ota_point_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+}
+
+//自定义 ota 文件传输协议
+static void srv_ble_add_chart_decr_Zhihui_ota(uint8_t server_id,uint16_t srv_handle)
+{
+ errcode_t ret = 0;
+ static uint8_t ota_val[] = {0x00, 0x00};
+ gatts_add_chara_info_t character;
+ gatts_add_desc_info_t descriptor;
+ bts_data_to_uuid_len2(BLE_ZHIHUI_OTA_ID, &character.chara_uuid);
+ character.permissions = GATT_ATTRIBUTE_PERMISSION_READ;
+ character.properties = BLE_ZHIHUI_OTA_ID_ID_PROPERTIES;
+ character.value_len = (uint16_t)sizeof(ota_val);
+ character.value = ota_val;
+
+ ret = gatts_add_characteristic(server_id, srv_handle, &character);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+ }
+ bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;
+ descriptor.value_len = (uint16_t)sizeof(ota_val);
+ descriptor.value = ota_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+}
+
+static void srv_ble_add_Zhihui_AI(uint8_t server_id,uint16_t srv_handle)
+{
+ errcode_t ret = 0;
+ static uint8_t battery_point_val[] = {0x00, 0x00};
+ gatts_add_chara_info_t character;
+ gatts_add_desc_info_t descriptor;
+
+ bts_data_to_uuid_len2(BLE_ZHIHUI_AI_ID, &character.chara_uuid);
+ character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
+ character.properties = BLE_ZHIHUI_AI_ID_ID_PROPERTIES;
+ character.value_len = (uint16_t)sizeof(battery_point_val);
+ character.value = battery_point_val;
+
+ ret = gatts_add_characteristic(server_id, srv_handle, &character);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+ }
+ bts_data_to_uuid_len2(BLE_UUID_CLIENT_CHARACTERISTIC_CONF, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE;
+ descriptor.value_len = (uint16_t)sizeof(battery_point_val);
+ descriptor.value = battery_point_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+
+ bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE | GATT_ATTRIBUTE_PERMISSION_READ;;
+ descriptor.value_len = (uint16_t)sizeof(battery_point_val);
+ descriptor.value = battery_point_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+}
+
+
+//用于adnriod发送消息添加特征值和描述符
+static void srv_ble_add_chart_decr_andriod(uint8_t server_id,uint16_t srv_handle)
+{
+ errcode_t ret = 0;
+ static uint8_t andriod_point_val[] = {0x00, 0x00};
+ gatts_add_chara_info_t character;
+ gatts_add_desc_info_t descriptor;
+
+ bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_ANDRIOD_ID, &character.chara_uuid);
+ character.permissions = GATT_ATTRIBUTE_PERMISSION_READ;
+ character.properties = BLE_CHARACTERISTIC_SNED_ANDRIOD_ID_PROPERTIES;
+ character.value_len = (uint16_t)sizeof(andriod_point_val);
+ character.value = andriod_point_val;
+
+ ret = gatts_add_characteristic(server_id, srv_handle, &character);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+ }
+ bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;
+ descriptor.value_len = (uint16_t)sizeof(andriod_point_val);
+ descriptor.value = andriod_point_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+}
+//添加battery特征值和描述符
+static void srv_ble_add_chart_decr_battery(uint8_t server_id,uint16_t srv_handle)
+{
+ errcode_t ret = 0;
+ static uint8_t battery_point_val[20] = {0};
+ uint8_t battery_value[20];
+ memset(battery_value,0,20);
+ // 获取电池电压值
+ float voltage = 0.0F;
+ uint8_t power = 0;
+ power = battery_get_voltage(&voltage);
+ battery_point_val[0] = power;//电量90
+
+ uint16_t dial = ble_get_dial_id();
+ memcpy_s(&battery_point_val[1],2,&dial,2);
+
+ uint8_t _major,_mid,_minor;
+ uapi_get_fw_version(&_major,&_mid,&_minor);
+
+ battery_point_val[3] = _major;//固件版本号
+ battery_point_val[4] = _mid;
+ battery_point_val[5] = _minor;
+
+ bd_addr_t addr_info;
+ ret = gap_ble_get_local_addr(&addr_info);
+ battery_point_val[6] = addr_info.addr[5];
+ battery_point_val[7] = addr_info.addr[4];
+ battery_point_val[8] = addr_info.addr[3];
+ battery_point_val[9] = addr_info.addr[2];
+ battery_point_val[10] = addr_info.addr[1];
+ battery_point_val[11] = addr_info.addr[0];
+
+ battery_point_val[12] = 0;//消息推送开关 默认是关闭 0
+ battery_point_val[13] = 0;//多媒体开关
+ #if defined(BOARD_W9)
+ battery_point_val[14] = 6;//客户编号
+ battery_point_val[15] = 6;//产品编号
+ // #elif defined(BOARD_N9)
+ // battery_point_val[14] = 7;//客户编号
+ // battery_point_val[15] = 7;//产品编号
+ #else
+ battery_point_val[14] = 5;//客户编号
+ battery_point_val[15] = 5;//产品编号
+ #endif
+
+ battery_point_val[16] = 0;//硬件版本号
+ battery_point_val[17] = 1;
+
+ battery_point_val[18] = 0;//ble版本号
+ battery_point_val[19] = 1;
+ gatts_add_chara_info_t character;
+ gatts_add_desc_info_t descriptor;
+
+ bts_data_to_uuid_len2(BLE_CHARACTERISTIC_READ_BATTERY_ID, &character.chara_uuid);
+ character.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE;
+ character.properties = BLE_CHARACTERISTIC_READ_BATTERY_ID_PROPERTIES;
+ character.value_len = (uint16_t)sizeof(battery_point_val);
+ character.value = battery_point_val;
+
+ ret = gatts_add_characteristic(server_id, srv_handle, &character);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+ }
+ static uint8_t report_reference_val_output[] = {0x01, 0x00};
+ bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;
+ descriptor.value_len = (uint16_t)sizeof(battery_point_val);
+ descriptor.value = battery_point_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+
+}
+//添加短指令特征值和描述符 20个字节
+static void srv_ble_add_chart_decr_short_cmd(uint8_t server_id,uint16_t srv_handle)
+{
+ errcode_t ret = 0;
+ static uint8_t battery_point_val[] = {0x00, 0x00};
+ gatts_add_chara_info_t character;
+ gatts_add_desc_info_t descriptor;
+
+ bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_SHORT_ID, &character.chara_uuid);
+ character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
+ character.properties = BLE_CHARACTERISTIC_SNED_SHORT_ID_PROPERTIES;
+ character.value_len = (uint16_t)sizeof(battery_point_val);
+ character.value = battery_point_val;
+
+ ret = gatts_add_characteristic(server_id, srv_handle, &character);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+ }
+ bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;
+ descriptor.value_len = (uint16_t)sizeof(battery_point_val);
+ descriptor.value = battery_point_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+}
+//添加长指令特征值和描述符 大于20个字节
+static void srv_ble_add_chart_decr_long_cmd(uint8_t server_id,uint16_t srv_handle)
+{
+ errcode_t ret = 0;
+ static uint8_t battery_point_val[] = {0x00, 0x00};
+ gatts_add_chara_info_t character;
+ gatts_add_desc_info_t descriptor;
+
+ bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_LONG_ID, &character.chara_uuid);
+ character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
+ character.properties = BLE_CHARACTERISTIC_SNED_LONG_ID_PROPERTIES;
+ character.value_len = (uint16_t)sizeof(battery_point_val);
+ character.value = battery_point_val;
+
+ ret = gatts_add_characteristic(server_id, srv_handle, &character);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+ }
+ bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;
+ descriptor.value_len = (uint16_t)sizeof(battery_point_val);
+ descriptor.value = battery_point_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+}
+//添加客户端接收特征值和描述符
+static void srv_ble_add_chart_decr_recv_cmd(uint8_t server_id,uint16_t srv_handle)
+{
+ errcode_t ret = 0;
+ static uint8_t battery_point_val[] = {0x00, 0x00};
+ gatts_add_chara_info_t character;
+ gatts_add_desc_info_t descriptor;
+
+ bts_data_to_uuid_len2(BLE_CHARACTERISTIC_RECV_ID, &character.chara_uuid);
+ character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
+ character.properties = BLE_CHARACTERISTIC_RECV_ID_PROPERTIES;
+ character.value_len = (uint16_t)sizeof(battery_point_val);
+ character.value = battery_point_val;
+
+ ret = gatts_add_characteristic(server_id, srv_handle, &character);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+ }
+ bts_data_to_uuid_len2(BLE_UUID_CLIENT_CHARACTERISTIC_CONF, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE;
+ descriptor.value_len = (uint16_t)sizeof(battery_point_val);
+ descriptor.value = battery_point_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+
+ bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE | GATT_ATTRIBUTE_PERMISSION_READ;;
+ descriptor.value_len = (uint16_t)sizeof(battery_point_val);
+ descriptor.value = battery_point_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+}
+
+
+static void srv_ble_add_ZHIHUIOTA_REPLY_chart_decr_recv_cmd(uint8_t server_id,uint16_t srv_handle)
+{
+ errcode_t ret = 0;
+ static uint8_t battery_point_val[] = {0x00, 0x00};
+ gatts_add_chara_info_t character;
+ gatts_add_desc_info_t descriptor;
+
+ bts_data_to_uuid_len2(BLE_ZHIHUI_OTA_REPLY_ID, &character.chara_uuid);
+ character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
+ character.properties = BLE_ZHIHUI_OTA_REPLY_ID_PROPERTIES;
+ character.value_len = (uint16_t)sizeof(battery_point_val);
+ character.value = battery_point_val;
+
+ ret = gatts_add_characteristic(server_id, srv_handle, &character);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+ }
+ bts_data_to_uuid_len2(BLE_UUID_CLIENT_CHARACTERISTIC_CONF, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE;
+ descriptor.value_len = (uint16_t)sizeof(battery_point_val);
+ descriptor.value = battery_point_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+
+ bts_data_to_uuid_len2(BLE_UUID_USER_CHARACTERISTIC_CONF, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE | GATT_ATTRIBUTE_PERMISSION_READ;;
+ descriptor.value_len = (uint16_t)sizeof(battery_point_val);
+ descriptor.value = battery_point_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+}
+
+
+static uint8_t g_alipay_character_buf[256] = {0};
+static void alipay_add_chart_decr_recv_cmd1(uint8_t server_id,uint16_t srv_handle)
+{
+ #ifdef AILPAY_SUPPORT
+ errcode_t ret = 0;
+ // uint16_t id = ALIPAYY_CHARACTERISTIC_ID;
+ gatts_add_chara_info_t character;
+ uint16_t value = 0;
+ bt_uuid_t alipay_service_uuid = {0};
+ bts_data_to_uuid_len2(ALIPAYY_CHARACTERISTIC_ID, &alipay_service_uuid);
+ memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
+ // character.chara_uuid.uuid_len = sizeof(id);
+ // memcpy_s(character.chara_uuid.uuid, sizeof (character.chara_uuid.uuid), (char *)&id, sizeof(id));
+ character.chara_uuid = alipay_service_uuid;
+ character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
+ character.properties =
+ GATT_CHARACTER_PROPERTY_BIT_READ | GATT_CHARACTER_PROPERTY_BIT_WRITE | GATT_CHARACTER_PROPERTY_BIT_NOTIFY;
+ character.value_len = 256;
+ character.value = g_alipay_character_buf;
+
+ ret = gatts_add_characteristic(server_id, srv_handle, &character);
+ if (ret != ERRCODE_SUCC) {
+ ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+ }
+
+ uint8_t bas_ccc_val[] = {
+ 0x01,
+ 0x00
+ };
+ bt_uuid_t ccc_uuid = { 0 };
+ bts_data_to_uuid_len2(0x2902, &ccc_uuid);
+ // bts_data_to_uuid_len2(0x2902, &ccc_uuid);
+ gatts_add_desc_info_t descriptor;
+ descriptor.desc_uuid = ccc_uuid;
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
+ descriptor.value_len = (uint16_t)sizeof(bas_ccc_val);
+ descriptor.value = bas_ccc_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+ bd_addr_t addr_info;
+ gatts_add_desc_info_t descriptor_ap;
+ gap_ble_get_local_addr(&addr_info);
+ bts_data_to_uuid_len2(0x4b02, &ccc_uuid);
+ descriptor_ap.desc_uuid = ccc_uuid;
+ descriptor_ap.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
+ descriptor_ap.value_len = BD_ADDR_LEN;
+ uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};
+ int k = BD_ADDR_LEN;
+ for (int i = 0; i < BD_ADDR_LEN; i++) {
+ ble_data_mac_switch[--k] = addr_info.addr[i];
+ }
+ descriptor_ap.value = ble_data_mac_switch;
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor_ap);
+ if (ret != ERRCODE_SUCC) {
+ ALIPAY_PRINT_ERR(0, "gatts_add_descriptor second fail, ret:%u.\r\n", ret);
+ }
+ #endif
+}
+
+
+
+static uint16_t ble_server_handle = 0;
+
+void alipay_add_chart_decr_cb(uint8_t server_id,uint16_t srv_handle)
+{
+ errcode_t ret = 0;
+ static uint8_t ota_point_val[] = {0x00, 0x00};
+ gatts_add_chara_info_t character;
+ gatts_add_desc_info_t descriptor;
+ bts_data_to_uuid_len2(0x4a02, &character.chara_uuid);
+ character.permissions = GATT_ATTRIBUTE_PERMISSION_READ;
+ character.properties = BLE_CHARACTERISTIC_SNED_OTA_ID_PROPERTIES;
+ character.value_len = (uint16_t)sizeof(ota_point_val);
+ character.value = ota_point_val;
+
+ ret = gatts_add_characteristic(server_id, srv_handle, &character);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+ }
+ bts_data_to_uuid_len2(0x2902, &descriptor.desc_uuid);
+ descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE|GATT_ATTRIBUTE_PERMISSION_READ;
+ descriptor.value_len = (uint16_t)sizeof(ota_point_val);
+ descriptor.value = ota_point_val;
+
+ ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+ if (ret != ERRCODE_SUCC) {
+ // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+ }
+ }
+
+//这个回调函数添加新的服务UUID
+static void svr_ble_bt_gatts_service_add_cb(uint8_t server_id, bt_uuid_t *uuid, uint16_t srv_handle,
+ errcode_t status)
+{
+ if (uuid->uuid_len != sizeof(uint16_t)) return ;
+ uint16_t uuid_tmp = *((uint16_t*)uuid->uuid);
+ uuid_tmp = SWAP_U16(uuid_tmp);
+ if ( uuid_tmp == BLE_SERVICE_UUID
+
+ // || uuid_tmp == BLE_UUID_HUMAN_INTERFACE_DEVICE
+#ifdef SUPPORT_FACTORY_SERVICE
+ || uuid_tmp == BLE_UUID_ATE_FACTORYTEST_SERVICE
+#endif
+#ifdef SUPPORT_PPG_BLE_SERVICE
+ || uuid_tmp == BLE_UUID_PPG_BLE_SERVICE
+ //|| uuid_tmp == ALIPAYY_SERVICE_ID
+#endif
+#ifdef SUPPORT_CYWEE_BLE_SERVICE
+ || uuid_tmp == BLE_UUID_CYWEE_REPORT_SERVICE
+#endif
+ )
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, " 0x%x\r\n",uuid_tmp);
+ }else{
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_service_add_cb UUID not supported 0x%x\r\n",uuid_tmp);
+ return ;
+ }
+ ble_server_handle = srv_handle;
+ // ALIPAY_PRINT_DEBUG(0, "BtGattsServiceAddCallback 0x%x 0x%x 0x%x 0x%x", status, server_id, srv_handle,
+ // *((uint16_t *)uuid->uuid));
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_service_add_cb srv_handle 0x%x\r\n",srv_handle);
+ if (status != ERRCODE_BT_SUCCESS)
+ {
+ return;
+ }
+ bt_uuid_t ble_service_uuid = {0};
+ bts_data_to_uuid_len2(BLE_SERVICE_UUID, &ble_service_uuid);
+#ifdef SUPPORT_HID_SERVICE
+ bt_uuid_t hid_service_uuid = {0};
+ bts_data_to_uuid_len2(BLE_UUID_HUMAN_INTERFACE_DEVICE, &hid_service_uuid);
+#endif
+#ifdef AILPAY_SUPPORT
+ // // bt_uuid_t alipay_service_uuid = {0};
+ // // bts_data_to_uuid_len2(ALIPAYY_SERVICE_ID, &alipay_service_uuid);//0x3802
+#endif
+
+#ifdef SUPPORT_FACTORY_SERVICE
+ bt_uuid_t factory_service_uuid = {0};
+ bts_data_to_uuid_len2(BLE_UUID_ATE_FACTORYTEST_SERVICE, &factory_service_uuid);
+#endif
+#ifdef SUPPORT_PPG_BLE_SERVICE
+ bt_uuid_t ppg_service_uuid = {0};
+ bts_data_to_uuid_len2(BLE_UUID_PPG_BLE_SERVICE, &ppg_service_uuid);
+#endif
+
+
+#ifdef SUPPORT_CYWEE_BLE_SERVICE
+
+ bt_uuid_t cywee_ble_service_uuid = {0};
+ bts_data_to_uuid_len2(BLE_UUID_CYWEE_REPORT_SERVICE, &cywee_ble_service_uuid);
+
+#endif
+
+
+ errcode_t ret = 0;
+ if (ble_gatts_cmp_uuid(uuid, &ble_service_uuid) == true) {//通过传入的uuid进行比较
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_service_add_cb ble_service_uuid\r\n");
+
+ srv_ble_add_chart_decr_ota(server_id,srv_handle);//ota特征值
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_ota \r\n");
+
+ srv_ble_add_chart_decr_andriod(server_id,srv_handle);//对18e0这个服务进行添加andiod特征值和描述符
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_andriod \r\n");
+
+ srv_ble_add_chart_decr_battery(server_id,srv_handle);//电池电量特征值
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_battery \r\n");
+ srv_ble_add_chart_decr_short_cmd(server_id,srv_handle);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_short_cmd \r\n");
+ srv_ble_add_chart_decr_long_cmd(server_id,srv_handle);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_long_cmd \r\n");
+ srv_ble_add_chart_decr_recv_cmd(server_id,srv_handle);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_recv_cmd \r\n");
+ srv_ble_add_chart_decr_Zhihui_ota(server_id,srv_handle);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_chart_decr_Zhihui_ota \r\n");
+ srv_ble_add_Zhihui_AI(server_id,srv_handle);
+ // srv_ble_add_chart_decr_Zhihui_AI(server_id,srv_handle);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "srv_ble_add_Zhihui_AI \r\n");
+ srv_ble_add_ZHIHUIOTA_REPLY_chart_decr_recv_cmd(server_id,srv_handle);
+
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_service_add_cb 1\r\n");
+ gatts_start_service(server_id, srv_handle);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_service_add_cb 2\r\n");
+ }
+#ifdef SUPPORT_HID_SERVICE
+ if (ble_gatts_cmp_uuid(uuid, &hid_service_uuid) == true){
+ ble_hid_add_characters_and_descriptors(server_id, srv_handle);
+ ret = gatts_start_service(server_id, srv_handle);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "hid service svr_ble_bt_gatts_service_add_cb ret:%d\r\n",ret);
+ }
+#endif
+
+#ifdef SUPPORT_FACTORY_SERVICE
+ if (ble_gatts_cmp_uuid(uuid, &factory_service_uuid) == true){
+ ble_factorytest_add_characters_and_descriptors(server_id,srv_handle);
+ ret = gatts_start_service(server_id, srv_handle);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "factorytest service svr_ble_bt_gatts_service_add_cb ret:%d\r\n",ret);
+ }
+#endif
+#ifdef SUPPORT_PPG_BLE_SERVICE
+ if (ble_gatts_cmp_uuid(uuid, &ppg_service_uuid) == true){
+ ble_ppgtest_add_characters_and_descriptors(server_id,srv_handle);
+ ret = gatts_start_service(server_id, srv_handle);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "ppg ble service svr_ble_bt_gatts_service_add_cb ret:%d\r\n",ret);
+ }
+#endif
+#ifdef SUPPORT_CYWEE_BLE_SERVICE
+ if (ble_gatts_cmp_uuid(uuid, &cywee_ble_service_uuid) == true){
+ ble_cywee_add_characters_and_descriptors(server_id,srv_handle);
+ ret = gatts_start_service(server_id, srv_handle);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "cywee ble service svr_ble_bt_gatts_service_add_cb ret:%d\r\n",ret);
+ }
+
+#endif
+#ifdef AILPAY_SUPPORT
+ // if (ble_gatts_cmp_uuid(uuid, &alipay_service_uuid) == true){
+ // alipay_add_chart_decr_recv_cmd1(server_id,srv_handle);
+ // ret = gatts_start_service(server_id, srv_handle);
+ // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "alipay_service_uuid service svr_ble_bt_gatts_service_add_cb ret:%d\r\n",ret);
+ // }
+#endif
+
+}
+uint16_t alipay_handle = 0;
+uint16_t g_hid_server_handle = 0;
+static void svr_ble_bt_gatts_characteristic_add_cb(uint8_t server_id, bt_uuid_t *uuid, uint16_t srv_handle,
+ gatts_add_character_result_t *result, errcode_t status)
+{
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "bt_gatts_characteristic_add_cb uuid:0x%02x%02x 0x%x %d %d , status %x\r\n",
+ uuid->uuid[0],uuid->uuid[1],
+ srv_handle,result->handle,
+ result->value_handle,status);
+ bt_uuid_t chara_uuid_data_2ae0 = {0};
+ bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_OTA_ID, &chara_uuid_data_2ae0);
+
+ bt_uuid_t chara_uuid_data_2ae1 = {0};
+ bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_ANDRIOD_ID, &chara_uuid_data_2ae1);
+
+ bt_uuid_t chara_uuid_data_2ae5 = {0};
+ bts_data_to_uuid_len2(BLE_CHARACTERISTIC_RECV_ID, &chara_uuid_data_2ae5);
+
+ bt_uuid_t chara_uuid_data_2ae3 = {0};
+ bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_SHORT_ID, &chara_uuid_data_2ae3);
+ bt_uuid_t chara_uuid_data_2ae4 = {0};
+ bts_data_to_uuid_len2(BLE_CHARACTERISTIC_SNED_LONG_ID, &chara_uuid_data_2ae4);
+
+
+ bt_uuid_t chara_uuid_data_2ae2 = {0};
+ bts_data_to_uuid_len2(BLE_CHARACTERISTIC_READ_BATTERY_ID, &chara_uuid_data_2ae2);
+#ifdef SUPPORT_HID_SERVICE
+ bt_uuid_t hid_report_uuid_2a4d = {0};
+ bts_data_to_uuid_len2(BLE_UUID_REPORT, &hid_report_uuid_2a4d);
+#endif
+ bt_uuid_t hid_report_uuid_2ae6 = {0};
+ bts_data_to_uuid_len2(BLE_ZHIHUI_OTA_ID, &hid_report_uuid_2ae6);
+
+ bt_uuid_t chara_uuid_data_2ae7 = {0};
+ bts_data_to_uuid_len2(BLE_ZHIHUI_OTA_REPLY_ID, &chara_uuid_data_2ae7);
+
+ bt_uuid_t chara_uuid_data_2ae8 = {0};
+ bts_data_to_uuid_len2(BLE_ZHIHUI_AI_ID, &chara_uuid_data_2ae8);
+
+ if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae8))
+ {
+ if(data2ae8Cmd==0)
+ {
+ data2ae8Cmd=result->value_handle;
+ }
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+ }
+
+ if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae7))
+ {
+ if(data2ae7Cmd==0)
+ {
+ data2ae7Cmd=result->value_handle;
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "data2ae7Cmd");
+ }
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+ }
+
+
+ if(ble_gatts_cmp_uuid(uuid, &hid_report_uuid_2ae6))
+ {
+ if(data2ae6Cmd==0)
+ {
+ data2ae6Cmd=result->value_handle;
+ }
+ Is_value_handle[handle_num]=data2ae6Cmd;
+ handle_num++;
+ }
+ if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae5))
+ {
+ if(g_ble_server_handle == 0)
+ {
+ g_ble_server_handle = result->value_handle;
+ }
+ if(data2ae5Cmd == 0){
+ data2ae5Cmd = result->value_handle;
+ }
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, " 2ae5 result->value_handle1 %d\r\n",result->value_handle);
+ }
+
+ if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae3 ))
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "2ae3 result->value_handle2 %d\r\n",result->value_handle);
+ if(data2ae3Cmd == 0)
+ {
+ data2ae3Cmd = result->value_handle;
+ }
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+
+ }
+
+ if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae0))
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "2ae0 result->value_handle4 %d\r\n",result->value_handle);
+ if(data2ae0Cmd == 0)
+ {
+ data2ae0Cmd = result->value_handle;
+ }
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+ }
+ if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae1))
+ {
+ if(data2ae1Cmd == 0)
+ {
+ data2ae1Cmd = result->value_handle;
+ }
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+
+ // data2ae1Cmd = result->value_handle;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "2ae1 result->value_handle5 %d\r\n",result->value_handle);
+ // shortCmdChara = result->value_handle;
+ }
+ if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae2))
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "2ae2 result->value_handle6 %d\r\n",result->value_handle);
+ // shortCmdChara = result->value_handle;
+ if(data2ae2Cmd == 0){
+ data2ae2Cmd = result->value_handle;
+ }
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+ }
+ if(ble_gatts_cmp_uuid(uuid, &chara_uuid_data_2ae4))
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "2ae4 result->value_handle3 %d\r\n",result->value_handle);
+ if(data2ae4Cmd == 0)
+ {
+ data2ae4Cmd = result->value_handle;
+ }
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+ // = result->value_handle;
+ }
+#ifdef SUPPORT_HID_SERVICE
+ if (ble_gatts_cmp_uuid(uuid, &hid_report_uuid_2a4d) == true) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "result->hid_report_uuid_2a4d %d\r\n",result->value_handle);
+ if(g_hid_server_handle == 0){
+ g_hid_server_handle = result->value_handle;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "g_hid_server_handle %d\r\n",g_hid_server_handle);
+ ble_hid_add_characters_input_report_cbk(g_hid_server_handle);
+ }
+ }
+#endif
+
+#ifdef SUPPORT_FACTORY_SERVICE
+ bt_uuid_t factorytest_recv_uuid = {0};
+ bts_data_to_uuid_len2(BLE_UUID_ATE_TX, &factorytest_recv_uuid);
+
+ if (ble_gatts_cmp_uuid(uuid, &factorytest_recv_uuid) == true) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "result->factorytest_recv_uuid %d\r\n",result->value_handle);
+
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+
+ ble_factorytest_store_recv_handle(result->value_handle) ;
+ // }
+ }
+
+ bt_uuid_t factorytest_report_uuid = {0};
+ bts_data_to_uuid_len2(BLE_UUID_ATE_RX, &factorytest_report_uuid);
+
+ if (ble_gatts_cmp_uuid(uuid, &factorytest_report_uuid) == true) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "result->factorytest_report_uuid %d\r\n",result->value_handle);
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+ ble_factorytest_store_report_handle(result->value_handle);
+ // }
+ }
+
+ bt_uuid_t factorytest_ota_recv_uuid = {0};
+ bts_data_to_uuid_len2(BLE_UUID_OTA_TX, &factorytest_ota_recv_uuid);
+
+ if (ble_gatts_cmp_uuid(uuid, &factorytest_ota_recv_uuid) == true) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "result->factorytest_ota_recv_uuid %d\r\n",result->value_handle);
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+ ble_factorytest_store_ota_recv_handle(result->value_handle) ;
+ // }
+ }
+
+ bt_uuid_t factorytest_ota_report_uuid = {0};
+ bts_data_to_uuid_len2(BLE_UUID_OTA_RX, &factorytest_ota_report_uuid);
+
+ if (ble_gatts_cmp_uuid(uuid, &factorytest_ota_report_uuid) == true) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "result->factorytest_ota_report_uuid %d\r\n",result->value_handle);
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+ ble_factorytest_store_ota_report_handle(result->value_handle);
+ // }
+ }
+#endif
+
+#ifdef SUPPORT_PPG_BLE_SERVICE
+ bt_uuid_t ppgtest_report_uuid = {0};
+ bts_data_to_uuid_len2(BLE_UUID_PPG_NOTIFY, &ppgtest_report_uuid);
+ if (ble_gatts_cmp_uuid(uuid, &ppgtest_report_uuid) == true) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "result->ble_ppgtest_store_report_handle %d\r\n",result->value_handle);
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+ ble_ppgtest_store_report_handle(result->value_handle);
+ }
+#endif
+#ifdef SUPPORT_CYWEE_BLE_SERVICE
+ bt_uuid_t cywee_report_uuid = {0};
+ bts_data_to_uuid_len2(BLE_UUID_CYWEE_RX, &cywee_report_uuid);
+
+ if (ble_gatts_cmp_uuid(uuid, &cywee_report_uuid) == true) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "result->cywee_report_uuid %d\r\n",result->value_handle);
+
+ Is_value_handle[handle_num]=result->value_handle;
+ handle_num++;
+
+ ble_cywee_store_report_handle(result->value_handle);
+ // }
+
+ ble_cywee_store_recv_handle(73);
+ }
+ else
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble_gatts_cmp_uuid(uuid, &cywee_report_uuid) != true\r\n");
+#endif
+ return;
+}
+
+errcode_t svr_ble_bt_gatts_noyify(uint8_t *data, uint16_t data_len)//这里是设备数据上报给app手机端
+{
+ gatts_ntf_ind_t data_info;
+ data_info.attr_handle = g_ble_server_handle;
+ data_info.value = data;
+ data_info.value_len = data_len;
+ if (g_ble_conn_id == 0)
+ return 0;
+ errcode_t ret = gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_WATCH_REPLY);
+ if(ret!=ERRCODE_SUCC)
+ {
+ msleep(50);
+ ret=gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_WATCH_REPLY);
+ if(ret!=ERRCODE_SUCC)
+ {
+ msleep(100);
+ ret=gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);
+
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_WATCH_REPLY);
+
+ if(ret!=ERRCODE_SUCC)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.data_len:%d", ret, g_ble_server_id,
+ g_ble_conn_id, g_ble_server_handle,data_len);
+ ble_set_ai_Answer_str("BLE NOTIF ERROR",5);
+ }
+
+ }
+ }
+ return ret;
+}
+
+
+errcode_t svr_ble_bt_gatts_noyify_zhihui(uint8_t *data, uint16_t data_len)//这里是设备数据上报给app手机端
+{
+ gatts_ntf_ind_t data_info;
+ data_info.attr_handle = data2ae7Cmd;
+ data_info.value = data;
+ data_info.value_len = data_len;
+ if (g_ble_conn_id == 0)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "g_ble_conn_id");
+ // return 0;
+ }
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "g_ble_conn_id %d g_ble_conn_id %d",g_ble_server_id,g_ble_conn_id);
+ errcode_t ret = gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);
+ if(ret!=ERRCODE_SUCC)
+ {
+ msleep(50);
+ ret=gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);
+ if(ret!=ERRCODE_SUCC)
+ {
+ msleep(100);
+ ret=gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);
+
+ if(ret!=ERRCODE_SUCC)
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.data_len:%d", ret, g_ble_server_id,
+ g_ble_conn_id, g_ble_server_handle,data_len);
+ }
+ }
+ return ret;
+}
+
+errcode_t svr_ble_bt_gatts_noyify_AI(uint8_t *data, uint16_t data_len)//这里是设备数据上报给app手机端
+{
+ gatts_ntf_ind_t data_info;
+ data_info.attr_handle = data2ae8Cmd;
+ data_info.value = data;
+ data_info.value_len = data_len;
+ if (g_ble_conn_id == 0)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "g_ble_conn_id");
+ // return 0;
+ }
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "g_ble_conn_id %d g_ble_conn_id %d",g_ble_server_id,g_ble_conn_id);
+ errcode_t ret = gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);
+ if(ret!=ERRCODE_SUCC)
+ {
+ msleep(50);
+ ret=gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);
+ if(ret!=ERRCODE_SUCC)
+ {
+ msleep(100);
+ ret=gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);
+
+ if(ret!=ERRCODE_SUCC)
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.data_len:%d", ret, g_ble_server_id,
+ g_ble_conn_id, g_ble_server_handle,data_len);
+ }
+ }
+ return ret;
+}
+
+errcode_t svr_ble_read_data_value_updata_noyify(void)//2ae2
+{
+ gatts_ntf_ind_t data_info;
+ data_info.attr_handle = data2ae2Cmd;
+ static uint8_t battery_point_val[20] = {0};
+ // 获取电池电压值
+ float voltage = 0.0F;
+ uint8_t power = 0;
+ power =battery_get_voltage(&voltage);
+ battery_point_val[0] =power;//power ;//power;//电量90
+ uint16_t dial = ble_get_dial_id();
+ memcpy_s(&battery_point_val[1],2,&dial,2);
+
+ uint8_t _major,_mid,_minor;
+ uapi_get_fw_version(&_major,&_mid,&_minor);
+
+ battery_point_val[3] = _major;//固件版本号
+ battery_point_val[4] = _mid;
+ battery_point_val[5] = _minor;
+
+ bd_addr_t addr_info;
+ errcode_t ret = gap_ble_get_local_addr(&addr_info);
+ battery_point_val[6] = addr_info.addr[5];
+ battery_point_val[7] = addr_info.addr[4];
+ battery_point_val[8] = addr_info.addr[3];
+ battery_point_val[9] = addr_info.addr[2];
+ battery_point_val[10] = addr_info.addr[1];
+ battery_point_val[11] = addr_info.addr[0];
+
+ battery_point_val[12] = 0;//消息推送开关 默认是关闭 0
+ battery_point_val[13] = 0;//多媒体开关
+
+ #if defined(BOARD_W9)
+ battery_point_val[14] = 6;//客户编号
+ battery_point_val[15] = 6;//产品编号
+ // #elif defined(BOARD_N9)
+ // battery_point_val[14] = 7;//客户编号
+ // battery_point_val[15] = 7;//产品编号
+ #else
+ battery_point_val[14] = 5;//客户编号
+ battery_point_val[15] = 5;//产品编号
+ #endif
+
+ battery_point_val[16] = 0;//硬件版本号
+ battery_point_val[17] = 1;
+
+ battery_point_val[18] = 0;//ble版本号
+ battery_point_val[19] = 1;
+
+
+ data_info.value = battery_point_val;
+ data_info.value_len = 20;
+
+ // if (g_ble_conn_id == 0)
+ // return 0;
+
+ ret = gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.data_len:%d", ret, g_ble_server_id,
+ g_ble_conn_id, g_ble_server_handle,20);
+
+ return ret;
+}
+
+errcode_t svr_ble_read_data_value_updata_noyify_test(uint8_t test)//2ae2
+{
+ gatts_ntf_ind_t data_info;
+ data_info.attr_handle = data2ae2Cmd;
+ static uint8_t battery_point_val[20] = {0};
+
+ battery_point_val[0] =test;//power ;//power;//电量90
+
+ uint16_t dial = ble_get_dial_id();
+ memcpy_s(&battery_point_val[1],2,&dial,2);
+
+ uint8_t _major,_mid,_minor;
+ uapi_get_fw_version(&_major,&_mid,&_minor);
+
+ battery_point_val[3] = _major;//固件版本号
+ battery_point_val[4] = _mid;
+ battery_point_val[5] = _minor;
+
+ bd_addr_t addr_info;
+ errcode_t ret = gap_ble_get_local_addr(&addr_info);
+ battery_point_val[6] = addr_info.addr[5];
+ battery_point_val[7] = addr_info.addr[4];
+ battery_point_val[8] = addr_info.addr[3];
+ battery_point_val[9] = addr_info.addr[2];
+ battery_point_val[10] = addr_info.addr[1];
+ battery_point_val[11] = addr_info.addr[0];
+
+ battery_point_val[12] = 0;//消息推送开关 默认是关闭 0
+ battery_point_val[13] = 0;//多媒体开关
+
+ #if defined(BOARD_W9)
+ battery_point_val[14] = 6;//客户编号
+ battery_point_val[15] = 6;//产品编号
+ // #elif defined(BOARD_N9)
+ // battery_point_val[14] = 7;//客户编号
+ // battery_point_val[15] = 7;//产品编号
+ #else
+ battery_point_val[14] = 5;//客户编号
+ battery_point_val[15] = 5;//产品编号
+ #endif
+
+ battery_point_val[16] = 0;//硬件版本号
+ battery_point_val[17] = 1;
+
+ battery_point_val[18] = 0;//ble版本号
+ battery_point_val[19] = 1;
+
+
+ data_info.value = battery_point_val;
+ data_info.value_len = 20;
+ ret = gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.data_len:%d", ret, g_ble_server_id,
+ g_ble_conn_id, g_ble_server_handle,20);
+
+ return ret;
+}
+
+static uint8_t flag=1;
+static void svr_ble_bt_gatts_req_read_cb(uint8_t server_id, uint16_t conn_id, gatts_req_read_cb_t *read_cb_para,
+ errcode_t status)
+{
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_req_read_cb ret:is_long:%d %d",read_cb_para->is_long,status);
+
+ //WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_req_read_cb ret:is_long:%d 2ae2 %d read_cb_para->handle :%d",read_cb_para->is_long,data2ae2Cmd,read_cb_para->handle);
+ if(read_cb_para->handle==data2ae2Cmd && get_ble_connect() && status==0 )
+ {
+ g_ble_conn_id=conn_id;
+
+ static uint8_t battery_point_val[20] = {0};
+ // 获取电池电压值
+ float voltage = 0.0F;
+ uint8_t power = 0;
+ power =battery_get_voltage(&voltage);
+ battery_point_val[0] =power;//power ;//power;//电量90
+ uint16_t dial = ble_get_dial_id();
+ memcpy_s(&battery_point_val[1],2,&dial,2);
+
+ uint8_t _major,_mid,_minor;
+ uapi_get_fw_version(&_major,&_mid,&_minor);
+
+ battery_point_val[3] = _major;//固件版本号
+ battery_point_val[4] = _mid;
+ battery_point_val[5] = _minor;
+
+ bd_addr_t addr_info;
+ errcode_t ret = gap_ble_get_local_addr(&addr_info);
+ battery_point_val[6] = addr_info.addr[5];
+ battery_point_val[7] = addr_info.addr[4];
+ battery_point_val[8] = addr_info.addr[3];
+ battery_point_val[9] = addr_info.addr[2];
+ battery_point_val[10] = addr_info.addr[1];
+ battery_point_val[11] = addr_info.addr[0];
+
+ battery_point_val[12] = 0;//消息推送开关 默认是关闭 0
+ battery_point_val[13] = 0;//多媒体开关
+
+ #if defined(BOARD_W9)
+ battery_point_val[14] = 6;//客户编号
+ battery_point_val[15] = 6;//产品编号
+ // #elif defined(BOARD_N9)
+ // battery_point_val[14] = 7;//客户编号
+ // battery_point_val[15] = 7;//产品编号
+ #else
+ battery_point_val[14] = 5;//客户编号
+ battery_point_val[15] = 5;//产品编号
+ #endif
+
+ battery_point_val[16] = 0;//硬件版本号
+ battery_point_val[17] = 1;
+
+ battery_point_val[18] = 0;//ble版本号
+ battery_point_val[19] = 1;
+
+ static gatts_ntf_ind_t gatts_ntf_ind;
+ gatts_ntf_ind.attr_handle=read_cb_para->handle;
+ gatts_ntf_ind.value=battery_point_val;
+ gatts_ntf_ind.value_len=20;
+ // read_cb_para->need_rsp=0;
+
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_APP_READ);
+ gatts_notify_indicate(server_id,conn_id,&gatts_ntf_ind);
+}
+}
+
+
+static uint8_t falg = 0;
+
+
+static bool Is_App_ble_handle(uint16_t handle)
+{
+ for(int i=0;i<handle_max_len;i++)
+ {
+ if(Is_value_handle[i]==handle)
+ return true;
+ }
+ return false;
+
+}
+
+static void svr_ble_bt_gatts_req_write_cb(uint8_t server_id, uint16_t conn_id, gatts_req_write_cb_t *write_cb_para,
+ errcode_t status)
+{
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "g_ble_server_handle %d conn_id :%d write_cb_para->length:%d write_cb_para->handle %d write_cb_para->request_id:%d",g_ble_server_handle,conn_id,write_cb_para->length,
+ write_cb_para->handle,write_cb_para->request_id);
+ if(write_cb_para->handle==data2ae0Cmd)
+ {
+ if(status!=ERRCODE_SUCC)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ota fial ");
+ //如果存在此文件证明ota出现失败过
+ FILE *fp= fopen("/user/updata/Ble_ota_file.txt","ab+");
+ fwrite("x",1,1,fp);
+ fclose(fp);
+ }
+ }
+ if(Is_App_ble_handle(write_cb_para->handle))
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP," %d %d\r\n",conn_id,write_cb_para->handle);
+ g_ble_conn_id=conn_id;
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_APP_CMD);
+ }
+ #ifdef SUPPORT_ALIPAY_SEC
+ if(is_alipay_handle(write_cb_para->handle))
+ {
+ g_ble_Alipay_conn_id=conn_id;
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_ALIPAY_CMD);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"g_ble_Alipay_conn_id\r\n");
+ }
+ #endif
+ // else
+ // {
+ // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP," ?????\r\n");
+ // }
+ blesrv_service_recv_msg_handler(write_cb_para->handle,write_cb_para->value,write_cb_para->length);
+}
+
+void ble_test_ANCS(void)
+{
+ ble_ancs_client_cmd_setup_and_subscribe(g_ble_conn_id);
+}
+
+
+void ble_test_ANCS_notify(uint8_t type)
+{
+ ble_ancs_client_subscribe_notify(g_ble_conn_id,type);
+}
+
+
+static void svr_ble_mtu_exchange(uint8_t server_id, uint16_t conn_id, uint16_t mtu_size, errcode_t status)
+{
+ ble_nus_max_data_len = mtu_size - 3;
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_mtu_exchange server_id=%u conn_id=%u mtu=%u status=0x%x\r\n",
+ (unsigned)server_id, (unsigned)conn_id, (unsigned)mtu_size, (unsigned)status);
+ /* ICCE 订阅参数:仅记录到全局,由 AT^CHANGAN_ICCE_SUB 读取(不再在 MTU 里自动订阅) */
+ if (status == ERRCODE_SUCC) {
+ extern uint8_t g_client_id;
+ g_changan_icce_sub_conn_id = conn_id;
+ g_changan_icce_sub_client_id = g_client_id;
+
+ // ble_icce_setup_and_subscribe(g_changan_icce_sub_client_id,g_changan_icce_sub_conn_id);
+ }
+ if(mtu_flag == 1)
+ {
+ mtu_flag = 0;
+ gattc_exchange_mtu_req(g_changan_icce_sub_client_id, g_changan_icce_sub_conn_id, 247);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_mtu_exchange mtu_exchange success");
+ }
+}
+/******************* gap_ble ************************************/
+void svr_gap_ble_auth_complete_callback(uint16_t conn_id, const bd_addr_t *addr, errcode_t status,ble_auth_info_evt_t* evt)
+{
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "sendParieSuccess");
+
+
+ sendParieSuccess(1,addr);
+ uapi_set_br_address(addr);
+}
+
+static bool ble_adv_start=false;
+
+bool get_ble_adv_status(void)
+{
+ return ble_adv_start;
+}
+
+static void svr_ble_adv_start_cb(uint8_t adv_id, adv_status_t status)
+{
+ if (adv_id == BLE_ADV_ID) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"BleAdvStartCallback adv_id: %d, status:%d\n", adv_id, status);
+ ble_adv_start=1;
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_BROADCAST_ON);
+
+ }
+}
+
+static void svr_ble_adv_stop_cb(uint8_t adv_id, adv_status_t status)
+{
+ if (adv_id == BLE_ADV_ID) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"svr_ble_adv_stop_cb adv_id: %d, status:%d\n", adv_id, status);
+ ble_adv_start=0;
+ uapi_save_runtime_log(RUNTIME_LOG_BLE_BROADCAST_OFF);
+ }
+}
+
+
+
+static void srv_BleAdvTerminateCallback(uint8_t advId, adv_status_t status)
+{
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "srv_BleAdvTerminateCallback advId: %d, status:%d\n", advId, status);
+
+}
+
+static bool g_scan_result_flag = false;
+static volatile bool g_scan_wait_active = false;
+
+static osal_semaphore g_scan_result_sem;
+
+static bool ble_bd_addr_mac_forward_or_reverse_equal(const uint8_t *expect, const uint8_t *seen)
+{
+ if (memcmp(expect, seen, BD_ADDR_LEN) == 0) {
+ return true;
+ }
+ for (unsigned int i = 0; i < BD_ADDR_LEN; i++) {
+ if (expect[i] != seen[BD_ADDR_LEN - 1u - i]) {
+ return false;
+ }
+ }
+ return true;
+}
+
+static void svr_ble_scan_result_cb(gap_scan_result_data_t *scan_result_data)
+{
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data: %p\n", scan_result_data);
+ if(scan_result_data!=NULL)
+ {
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data: %p\n", scan_result_data);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->event_type: %d\n", scan_result_data->event_type);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->data_status: %d\n", scan_result_data->data_status);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->addr: %02X:%02X:%02X:%02X:%02X:%02X\n", scan_result_data->addr.addr[0], scan_result_data->addr.addr[1], scan_result_data->addr.addr[2], scan_result_data->addr.addr[3], scan_result_data->addr.addr[4], scan_result_data->addr.addr[5]);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->primary_phy: %d\n", scan_result_data->primary_phy);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->secondary_phy: %d\n", scan_result_data->secondary_phy);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->adv_sid: %d\n", scan_result_data->adv_sid);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->tx_power: %d\n", scan_result_data->tx_power);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->rssi: %d\n", scan_result_data->rssi);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->periodic_adv_interval: %d\n", scan_result_data->periodic_adv_interval);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->direct_addr: %02X:%02X:%02X:%02X:%02X:%02X\n", scan_result_data->direct_addr.addr[0], scan_result_data->direct_addr.addr[1], scan_result_data->direct_addr.addr[2], scan_result_data->direct_addr.addr[3], scan_result_data->direct_addr.addr[4], scan_result_data->direct_addr.addr[5]);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->adv_len: %d\n", scan_result_data->adv_len);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->adv_data: %s\n", scan_result_data->adv_data);
+
+ if(ble_bd_addr_mac_forward_or_reverse_equal(g_scan_addr.addr, scan_result_data->addr.addr) && g_scan_wait_active)
+ {
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_scan_result_cb scan_result_data->addr: %02X:%02X:%02X:%02X:%02X:%02X\n", scan_result_data->addr.addr[0], scan_result_data->addr.addr[1], scan_result_data->addr.addr[2], scan_result_data->addr.addr[3], scan_result_data->addr.addr[4], scan_result_data->addr.addr[5]);
+ errcode_t ret = gap_ble_stop_scan();
+ if(ret!=ERRCODE_BT_SUCCESS)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_stop_scan fail ret %d", ret);
+ }
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gap_ble_stop_scan success ret %d", ret);
+ g_scan_result_flag = true;
+ osal_sem_up(&g_scan_result_sem);
+ }
+ }
+ return;
+}
+
+#define BLE_SCAN_INTERVAL 48
+#define BLE_SCAN_WINDOW 48
+
+static bool svr_ble_start_scan(bd_addr_t *addr)
+{
+ if(addr==NULL)
+ {
+ return false;
+ }
+ gap_ble_scan_params_t scan_param = {0};
+ scan_param.scan_interval = BLE_SCAN_INTERVAL;
+ scan_param.scan_window = BLE_SCAN_WINDOW;
+ scan_param.scan_type = GAP_BLE_SCAN_TYPE_ACTIVE;
+ scan_param.scan_phy = GAP_BLE_PHY_1M;
+ scan_param.scan_filter_policy = GAP_BLE_SCAN_FILTER_POLICY_ACCEPT_ALL;
+ errcode_t ret = gap_ble_set_scan_parameters(&scan_param);
+ if(ret!=ERRCODE_BT_SUCCESS)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_set_scan_parameters fail ret %d", ret);
+ return false;
+ }
+ ret = gap_ble_start_scan();
+ if(ret!=ERRCODE_BT_SUCCESS)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_start_scan fail ret %d", ret);
+ return false;
+ }
+ memcpy_s(&g_scan_addr, sizeof(bd_addr_t), addr, sizeof(bd_addr_t));
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ble_start_scan g_scan_addr: %02X:%02X:%02X:%02X:%02X:%02X\n", g_scan_addr.addr[0], g_scan_addr.addr[1], g_scan_addr.addr[2], g_scan_addr.addr[3], g_scan_addr.addr[4], g_scan_addr.addr[5]);
+ return true;
+}
+
+bool ble_start_scan(bd_addr_t *addr, unsigned int timeout_ms)
+{
+ g_scan_result_flag = false;
+ if (osal_sem_binary_sem_init(&g_scan_result_sem, 0) != OSAL_SUCCESS) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "osal_sem_binary_sem_init fail");
+ return false;
+ }
+ g_scan_wait_active = true;
+ bool ret = svr_ble_start_scan(addr);
+ if (ret == false) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_start_scan fail");
+ g_scan_wait_active = false;
+ osal_sem_destroy(&g_scan_result_sem);
+ return false;
+ }
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_start_scan success");
+ int wait_ret = osal_sem_down_timeout(&g_scan_result_sem, timeout_ms);
+ g_scan_wait_active = false;
+ if (wait_ret != OSAL_SUCCESS) {
+ errcode_t stop_ret = gap_ble_stop_scan();
+ if (stop_ret != ERRCODE_BT_SUCCESS) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_stop_scan after timeout fail ret %d", stop_ret);
+ } else {
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gap_ble_stop_scan after timeout ok");
+ }
+ osal_sem_destroy(&g_scan_result_sem);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble_start_scan timeout wait_ret %d", wait_ret);
+ return false;
+ }
+ osal_sem_destroy(&g_scan_result_sem);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ble_start_scan success");
+ if(g_scan_result_flag)
+ {
+ return true;
+ }
+ return false;
+}
+
+bool ble_connect_to_device(bd_addr_t *addr)
+{
+ errcode_t ret = gap_ble_connect_remote_device(addr);
+ if(ret!=ERRCODE_BT_SUCCESS)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_connect_remote_device fail ret %d", ret);
+ return false;
+ }
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ble_connect_to_device success");
+ return true;
+}
+
+
+
+
+void srv_ble_server_register_gap_ble_callbacks(void)//ble基础通讯服务注册回调函数
+{
+ g_ble_gapble_cbs.conn_state_change_cb = svr_ble_connstate_change_cb;
+ g_ble_gapble_cbs.pair_result_cb = svr_pair_result_cbt_cb;
+ g_ble_gapble_cbs.terminate_adv_cb = srv_BleAdvTerminateCallback;
+ g_ble_gapble_cbs.auth_complete_cb = svr_gap_ble_auth_complete_callback;
+ g_ble_gapble_cbs.start_adv_cb=svr_ble_adv_start_cb;
+ g_ble_gapble_cbs.stop_adv_cb=svr_ble_adv_stop_cb;
+ g_ble_gapble_cbs.conn_param_update_cb=srv_gap_ble_connect_param_update_callback;
+ g_ble_gapble_cbs.scan_result_cb=svr_ble_scan_result_cb;
+#ifndef SUPPORT_OHOSFWK
+ gap_ble_register_callbacks(&g_ble_gapble_cbs);
+#else
+ wrapper_gap_ble_register_callbacks(&g_ble_gapble_cbs);
+#endif
+}
+void srv_ble_server_register_gatt_callbacks(void)
+{
+ errcode_t ret = ERRCODE_BT_SUCCESS;
+ g_ble_gatts_cbs.add_service_cb = svr_ble_bt_gatts_service_add_cb;
+ g_ble_gatts_cbs.add_characteristic_cb = svr_ble_bt_gatts_characteristic_add_cb;
+
+ g_ble_gatts_cbs.read_request_cb = svr_ble_bt_gatts_req_read_cb;
+ g_ble_gatts_cbs.write_request_cb = svr_ble_bt_gatts_req_write_cb;
+ g_ble_gatts_cbs.mtu_changed_cb = svr_ble_mtu_exchange;
+
+#ifndef SUPPORT_OHOSFWK
+ gatts_register_callbacks(&g_ble_gatts_cbs);
+#else
+ wrapper_gatts_register_callbacks(&g_ble_gatts_cbs);
+#endif
+ return;
+}
+static uint8_t g_server_id = 0;
+static void svr_ble_register_service(void)
+{
+ uint16_t srevr_id = BLE_SERVICE_UUID;
+ uint16_t ser_id = BLE_SERVICE_UUID;
+ uint8_t serverId = 0;
+ bt_uuid_t uuid;
+ errcode_t ret = 0;
+ uuid.uuid_len = (uint8_t)sizeof(ser_id);
+ memcpy_s(uuid.uuid, sizeof(uuid.uuid), (char *)&ser_id, sizeof(ser_id));
+
+#ifndef SUPPORT_OHOSFWK
+ ret = gatts_register_server(&uuid, &serverId); /* 注册gatt server */
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gatts_register_server ret: 0x%x serverId = 0x%x uuid.uuid_len:%d", ret, serverId,uuid.uuid_len);
+#else
+ ret = wrapper_gatts_register_server(&uuid, &serverId); /* 注册gatt server */
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "wrapper_gatts_register_server ret: 0x%x serverId = 0x%x uuid.uuid_len:%d", ret, serverId,uuid.uuid_len);
+#endif
+ g_ble_server_id = serverId;
+
+ bt_uuid_t ble_service_uuid = {0};
+ bts_data_to_uuid_len2(srevr_id, &ble_service_uuid);
+
+#ifndef SUPPORT_OHOSFWK
+ ret = gatts_add_service(serverId, &ble_service_uuid, true);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gatts_add_service ret: 0x%x", ret);
+#else
+ ret = wrapper_gatts_add_service(serverId, &ble_service_uuid, true);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "wrapper_gatts_add_service ret: 0x%x", ret);
+#endif
+
+
+
+ return;
+}
+bool ble_gatts_cmp_uuid(const bt_uuid_t *tgt_uuid, const bt_uuid_t *src_uuid)//比较源uuid和给定的uuid是否匹配
+{
+ uint8_t *tgt = (uint8_t *)bts_init_128bit_uuid(tgt_uuid);
+ bool result = false;
+ if (tgt == NULL) {
+ return false;
+ }
+ uint8_t *src = (uint8_t *)bts_init_128bit_uuid(src_uuid);
+ if (src == NULL) {
+ bt_os_free(tgt);
+ return false;
+ }
+ if (memcmp(tgt, src, BT_UUID_MAX_LEN) == 0) {
+ result = true;
+ }
+ bt_os_free(src);
+ bt_os_free(tgt);
+ return result;
+}
+// extern void alipay_unregist_server(void);
+void ble_unregist_server(void)
+{
+ svr_ble_adv_stop();
+ gatts_delete_all_services(g_ble_server_id);
+ gatts_unregister_server(g_ble_server_id);
+
+}
+
+
+void svr_ble_bluetooth_init(void)
+{
+ // memset(&phone_addr,0,sizeof(bd_addr_t));
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bluetooth_init");
+
+ ble_instruct_init();
+
+ srv_ble_server_register_gap_ble_callbacks();
+ srv_ble_server_register_gatt_callbacks();
+
+ //add server and ble service
+ svr_ble_register_service();
+
+ #ifdef SUPPORT_HID_SERVICE
+ // ble_hid_server_init();
+ #endif
+ #ifdef SUPPORT_ALIPAY_SEC
+ svr_alipay_bluetooth_init(g_ble_server_id);
+ #endif
+ #ifdef SUPPORT_FACTORY_SERVICE
+ ble_factory_server_init(g_ble_server_id);
+ #endif
+ #ifdef SUPPORT_PPG_BLE_SERVICE
+ ble_ppgtest_server_init(g_ble_server_id);
+ #endif
+ #ifdef SUPPORT_CYWEE_BLE_SERVICE
+ ble_cywee_server_init(g_ble_server_id);
+ #endif
+ gattc_reg_id();
+
+ #ifdef SUPPORT_BLE_SERVICE
+ uapi_Ai_send_service_init();
+ #endif
+
+ g_custom_ble_init_flag = true;
+ return;
+}
+//关闭蓝牙
+void custom_ble_service_stop(void)
+{
+ AdverFlag = false;
+ errcode_t ret = 0;
+ bd_addr_t addr={0};
+ get_phone_addr(&addr,g_ble_conn_id);
+
+ if(Bleconnect == GAP_BLE_STATE_CONNECTED){//设备连接需要断开
+ ret = gap_ble_disconnect_remote_device((const bd_addr_t *)&addr);//与固定的mac设置地址进行断开连接
+ }
+
+ // 一键双连去使能
+ ret = gap_ble_set_ctkd_enable(false);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gap_ble_set_ctkd_disable ret = %u", ret);
+
+ svr_ble_adv_stop();//停止广播 不发送广播数据 就是app搜索不到该设备了
+ free_ble_data(); //删除所有协议缓存数据
+}
+
+void uapi_ble_disconnect_device()
+{
+ errcode_t ret = 0;
+ bd_addr_t addr={0};
+ get_phone_addr(&addr,g_ble_conn_id);
+
+ ret = gap_ble_disconnect_remote_device((const bd_addr_t *)&addr);//与固定的mac设置地址进行断开连接
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gap_ble_disconnect_remote_device ret = %X", ret);
+
+}
+//开启蓝牙
+void custom_ble_service_start(void)
+{
+ AdverFlag = true;
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "custom_ble_service_start ret");
+
+ svr_ble_adv_start_param();
+}
+
+void custom_ble_service_start_(uint8_t data)
+{
+ AdverFlag = true;
+ svr_ble_adv_start_param();
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "custom_ble_service_start_ ");
+ gap_br_set_bt_scan_mode(GAP_SCAN_MODE_CONNECTABLE, data);
+
+}
+#define MODE_BLE_ADV_SRV (0)
+#define MODE_ALIPAY_ADV_SRV (1)
+void ble_avd_mode_change(uint8_t mode)
+{
+
+ uint8_t adv_ok = 0;
+ switch(mode)
+ {
+ case MODE_BLE_ADV_SRV:
+
+ if(get_ble_connect() && g_ble_conn_id!=0)
+ {
+ svr_ble_adv_stop();
+ }
+ break;
+ case MODE_ALIPAY_ADV_SRV:
+
+
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"alipay_ble_advd_start!!!!!!!!! ble_adv_falg: %d ,AdverFlag: %d",ble_adv_falg,AdverFlag);
+ svr_ble_adv_start();
+
+ break;
+ default:
+ break;
+ }
+}
+/**=================protocol recv decode service (task)=============================================================================================*/
+typedef struct
+{
+ uint16_t service_handle;
+ uint32_t msg_len;
+ uint8_t *msg_data;
+} blesrv_custom_cmd_t;
+
+#define MAX_BUF_LEN sizeof(blesrv_custom_cmd_t) //sizeof(blesrv_custom_cmd_t) /*MTU max 514 , sizeof(blesrv_custom_cmd_t)*/
+static unsigned long g_blesrv_queue = 0xFFFFFFFF;
+static uint8_t g_blesrv_queue_created = 0;
+
+void blesrv_service_recv_msg_handler(uint16_t srv_handle, uint8_t * msg_data, uint32_t msg_len)
+{
+ int ret;
+ blesrv_custom_cmd_t blesrv_mail={0};
+ if( g_blesrv_queue_created == 0) return ;
+ if (msg_data == NULL) return;
+
+
+ // mail = (blesrv_custom_cmd_t*)malloc(sizeof(blesrv_custom_cmd_t));
+ uint32_t sendlen = MAX_BUF_LEN;
+
+
+ blesrv_mail.service_handle = srv_handle;
+ blesrv_mail.msg_len = msg_len;
+ blesrv_mail.msg_data = (uint8_t*)malloc(msg_len);
+
+ if(blesrv_mail.msg_data==NULL)
+ {
+ return ;
+ }
+ memcpy_s((blesrv_mail.msg_data),msg_len,msg_data,msg_len);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"g_blesrv_queue:%d ble_recv:mail.msg_data %X %02X %02X %02X msg_data:%02X %02X %02X\r\n",
+ g_blesrv_queue,
+ blesrv_mail.msg_data,
+ blesrv_mail.msg_data[0],
+ blesrv_mail.msg_data[1],
+ blesrv_mail.msg_data[2],
+ msg_data[0],
+ msg_data[1],
+ msg_data[2]
+ );
+ ret = osal_msg_queue_write_copy(g_blesrv_queue, (void *)&blesrv_mail, sendlen , 0);
+
+ if (ret != OSAL_SUCCESS)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"Error blesrv Check send failed! err=0x%X! \r\n", ret);
+ }
+}
+
+static void blesrv_service_check_task(void const *arg)
+{
+ unused(arg);
+ int32_t ret;
+ blesrv_custom_cmd_t mail={0};
+ uint32_t msgsize = MAX_BUF_LEN;
+
+ while (1)
+ {
+ ret = osal_msg_queue_read_copy(g_blesrv_queue, (void *)&mail, &msgsize,
+ OSAL_MSGQ_WAIT_FOREVER);
+ if (ret != OSAL_SUCCESS)
+ {
+ //WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"OSAL_SUCCESS");
+ continue;
+ }
+
+ uint8_t *p_msgbuf = (mail.msg_data);
+ uint16_t server_handle = mail.service_handle;
+ uint32_t msg_len = mail.msg_len;
+
+ // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"mail.msg_data:%X,g_blesrv_queue:%d ble_recv:%d %d %02X %02X %02X mail.msg_data: %02X %02X %02X\r\n",
+ // mail.msg_data,
+ // g_blesrv_queue,
+ // msg_len,
+ // server_handle,
+ // p_msgbuf[0],
+ // p_msgbuf[1],
+ // p_msgbuf[2],
+ // mail.msg_data[0],
+ // mail.msg_data[1],
+ // mail.msg_data[2]);
+
+ #if 1
+ // if(server_handle == 0)
+ // {}
+#ifdef SUPPORT_FACTORY_SERVICE
+ if (server_handle == get_factory_ate_write_handl())
+ {
+ factory_recv_cmd_data(p_msgbuf,msg_len,server_handle);
+ }
+ else if (server_handle == get_factory_ota_write_handl())
+ {
+ factory_recv_ota_data(p_msgbuf,msg_len,server_handle);
+ }
+#endif
+#ifdef SUPPORT_CYWEE_BLE_SERVICE
+ else if (server_handle == get_cywee_ate_write_handl())
+ {
+ cywee_recv_cmd_data(p_msgbuf,msg_len,server_handle);
+ }
+#endif
+ // else if(server_handle == alipay_handle)
+ // {
+ // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"alipay wirte!!!!!");
+ // // // svr_alipay_bt_gatts_noyify(buf,5);
+ // // errcode_t ret = svr_alipay_msg_write(ALIPAY_MSG_BT, p_msgbuf, msg_len, false);
+
+ // }
+ // else
+ {
+ #ifdef BLE_INSTRUCT
+ revBleOldData(p_msgbuf,msg_len,server_handle);
+ #endif
+ }
+ #endif
+ if(mail.msg_data)
+ {
+ free(mail.msg_data);
+ mail.msg_data = NULL;
+ }
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ble_recv:end\r\n");
+ }
+}
+#define BLESRV_APP_BOARD_MSG_COUNT 50
+#define BLESRV_APP_BOARD_TASK_SIZE 0x2000
+#define BLESRV_BOARD_TASK_PRIO 7
+void create_blesrv_queue(void)
+{
+ if (osal_msg_queue_create("blesrv_service_queue", BLESRV_APP_BOARD_MSG_COUNT, &g_blesrv_queue,
+ 0, MAX_BUF_LEN) != ERRCODE_SUCC)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"[blesrv][service] app create mail fail g_blesrv_queue:%d\n",g_blesrv_queue);
+ g_blesrv_queue_created = 0;
+ }else{
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"[blesrv][service] app create mail success g_blesrv_queue:%d\n",g_blesrv_queue);
+ g_blesrv_queue_created = 1;
+ }
+
+}
+errcode_t uapi_blesrv_service_init(void)
+{
+
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"uapi_blesrv_service_init !\r\n");
+ app_task_definition_t taskcfg = {0};
+ taskcfg.create_queue_handle = create_blesrv_queue;
+ taskcfg.attr.name = "blesrv_recv_service";
+ taskcfg.attr.priority = osPriorityNormal;
+ taskcfg.attr.stack_size = BLESRV_APP_BOARD_TASK_SIZE;
+ taskcfg.func = blesrv_service_check_task;
+ taskcfg.use_mem = USE_EXTEND_MEM;
+
+ errcode_t ret = uapi_create_osThread_custom(&taskcfg);
+ if (ret != ERRCODE_SUCC)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"create blesrv_service failed %d!\r\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+
+void send_pair_succ(bd_addr_t *addr)
+{
+ sendParieSuccess(1,addr);
+}
+
+ static uint8_t get_ble_Check_adv_status_falg=0;
+
+void Check_ble_adv_status(void)
+{
+
+ if(get_ble_connect())
+ {
+ return;
+ }
+ else
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"get_ble_adv_status %s \n", get_ble_adv_status()?"true":"fales");
+
+ if(get_ble_adv_status()==0)
+ {
+ get_ble_Check_adv_status_falg++;
+ if(AdverFlag && get_ble_Check_adv_status_falg>=3)
+ {
+ if(uapi_dev_runtime_get_factory_test_status_flag())
+ svr_ble_adv_factory_test_start_param();
+ else
+ svr_ble_adv_start_param();
+ }
+ }
+ else
+ {
+ get_ble_Check_adv_status_falg=0;
+ }
+ }
+ return;
+}
+
+static unsigned long g_ble_Ai_record_queue = 0xFFFFFFFF;
+static uint8_t g_ble_Ai_record_queue_created = 0;
+
+void create_Ai_record_queue(void)
+{
+ if (osal_msg_queue_create("Ai_record_queue", BLESRV_APP_BOARD_MSG_COUNT, &g_ble_Ai_record_queue,
+ 0, MAX_BUF_LEN) != ERRCODE_SUCC)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"[blesrv][service] app create mail fail g_blesrv_queue:%d\n",g_ble_Ai_record_queue);
+ g_ble_Ai_record_queue_created = 0;
+ }else{
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"[blesrv][service] app create mail success g_blesrv_queue:%d\n",g_ble_Ai_record_queue);
+ g_ble_Ai_record_queue_created = 1;
+ }
+
+}
+
+
+#define Ai_TEST 0
+static uint32_t AI_data_count=0;
+
+
+static uint8_t AI_interval=5;
+
+void set_AI_interval(uint8_t data)
+{
+ AI_interval=data;
+}
+
+void send_Ai_record(uint16_t len,uint8_t *data,uint32_t count)
+{
+ uint8_t ai_buf[SDK_BLE_MTU_MAX]={0};
+ if(count)
+ {
+
+ memcpy_s(ai_buf,SDK_BLE_MTU_MAX,&count,4);
+ memcpy_s(&ai_buf[4],SDK_BLE_MTU_MAX-4,data,len);
+ len+=4;
+ }
+ else
+ {
+ memcpy_s(ai_buf,SDK_BLE_MTU_MAX,data,len);
+ }
+
+ svr_ble_bt_gatts_noyify_AI(ai_buf,len);
+
+ LOS_Msleep(AI_interval+get_ble_interval());
+}
+
+
+static void blesrvAi_send_service_task(void const *arg)
+{
+ unused(arg);
+ int32_t ret;
+ blesrv_custom_cmd_t mail={0};
+ uint32_t msgsize = MAX_BUF_LEN;
+
+ #if Ai_TEST
+ FILE* fp= fopen("user/airecord.pcm","wb+");
+ #endif
+ while (1)
+ {
+ ret = osal_msg_queue_read_copy(g_ble_Ai_record_queue, (void *)&mail, &msgsize,
+ OSAL_MSGQ_WAIT_FOREVER);
+ if (ret != OSAL_SUCCESS)
+ {
+ continue;
+ }
+
+
+ uint8_t *p_msgbuf = (mail.msg_data);
+ uint16_t server_handle = mail.service_handle;
+ uint32_t msg_len = mail.msg_len;
+
+ if(server_handle==1 || server_handle==2)
+ {
+ AI_data_count=0;
+ }
+ else
+ {
+ AI_data_count++;
+ }
+
+ #if Ai_TEST
+ fwrite(fp,1,mail.msg_len,mail.msg_data);
+ #endif
+ // if(get_ble_connect())
+
+
+ if(mail.msg_data && mail.msg_len!=0)
+ send_Ai_record(mail.msg_len,mail.msg_data,AI_data_count);
+
+
+ if(mail.msg_data)
+ {
+ free(mail.msg_data);
+ mail.msg_data = NULL;
+ }
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ble_recv:end\r\n");
+ }
+}
+
+
+static blesrv_custom_cmd_t g_blesrv_mail={0};
+
+errcode_t uapi_Ai_send_service_init(void)
+{
+
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"uapi_blesrv_service_init !\r\n");
+ app_task_definition_t taskcfg = {0};
+ taskcfg.create_queue_handle = create_Ai_record_queue;
+ taskcfg.attr.name = "Ai_record_queue_service";
+ taskcfg.attr.priority = osPriorityNormal;
+ // taskcfg.attr.stack_size = BLESRV_APP_BOARD_TASK_SIZE;
+ taskcfg.attr.stack_size = 0x1500;
+ taskcfg.func = blesrvAi_send_service_task;
+ taskcfg.use_mem = USE_EXTEND_MEM;
+
+ g_blesrv_mail.msg_len=0;
+ g_blesrv_mail.msg_data=NULL;
+
+
+ errcode_t ret = uapi_create_osThread_custom(&taskcfg);
+ if (ret != ERRCODE_SUCC)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"create blesrv_service failed %d!\r\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ return ERRCODE_SUCC;
+}
+
+
+uint32_t send_msg_data_into_Ai_msg_queue_count=0;
+
+
+void AI_data_assembly(uint8_t type,uint8_t *buf,uint8_t aitype)
+{
+
+ memset_s(buf,ble_nus_max_data_len,0,19);
+ // 设置消息头部信息
+ buf[0] = 0x72; // 消息头
+ buf[1] = 0x08; // 类型
+ if(type)
+ buf[2] = 0x01; // 类型ID
+ else
+ buf[2] = 0x02; // 类型ID
+ uint32_t temp_data=1;
+ memcpy(buf + 3, &temp_data, 4); // 总包数
+ memcpy(buf + 7, &temp_data, 4); // 总数据长度
+ memcpy(buf + 11, &temp_data, 4); // 数据包ID
+ memcpy(buf + 15, &temp_data, 2); // 包数据长度
+
+ buf[17] = aitype;
+ buf[18] = Calculate_CRC_AI(buf,18);; // 计算CRC
+}
+
+static uint8_t g_blesrv_mail_flag=0;
+
+
+
+int send_msg_data_into_Ai_msg_queue(void *buff,uint16_t len,uint8_t type)
+{
+ blesrv_custom_cmd_t blesrv_mail={0};
+ uint32_t ret ;
+ if( g_blesrv_queue_created == 0) return ERRCODE_FAIL;
+ if (buff == NULL) return ERRCODE_FAIL;
+
+ uint32_t sendlen = sizeof(blesrv_custom_cmd_t);
+ uint32_t singlebuflen= ble_nus_max_data_len-20;
+ blesrv_mail.msg_data=0;
+
+ if(len<=singlebuflen)
+ {
+ if(type==1)
+ {
+ blesrv_mail.service_handle = 1;
+ blesrv_mail.msg_len = len;
+ blesrv_mail.msg_data = (uint8_t*)malloc(len);
+
+ if(blesrv_mail.msg_data==NULL)
+ {
+ return ERRCODE_FAIL;
+ }
+ memcpy_s((void *)(blesrv_mail.msg_data),len,buff,len);
+
+ ret = osal_msg_queue_write_copy(g_ble_Ai_record_queue, (void *)&blesrv_mail, sendlen , 0);
+ if (ret != OSAL_SUCCESS)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"len<=singlebuflen Error blesrv Check send failed! err=0x%X %d! \r\n", ret,send_msg_data_into_Ai_msg_queue_count);
+ }
+
+ if(g_blesrv_mail.msg_data)
+ {
+ free(g_blesrv_mail.msg_data);
+ g_blesrv_mail.msg_data=NULL;
+ g_blesrv_mail.msg_len=0;
+ }
+ return OSAL_SUCCESS;
+
+ }
+ else if(type==2)
+ {
+
+ blesrv_custom_cmd_t blesrv_mail_end={0};
+
+ if(g_blesrv_mail.msg_len!=0 && g_blesrv_mail.msg_data!=NULL)
+ {
+ blesrv_mail_end.msg_len=g_blesrv_mail.msg_len;
+ blesrv_mail_end.msg_data=malloc(g_blesrv_mail.msg_len);
+ if(blesrv_mail_end.msg_data==NULL)
+ {
+ return ERRCODE_FAIL;
+ }
+
+ memcpy_s( blesrv_mail_end.msg_data,singlebuflen,g_blesrv_mail.msg_data,g_blesrv_mail.msg_len);
+ free(g_blesrv_mail.msg_data);
+ g_blesrv_mail.msg_data=NULL;
+ g_blesrv_mail.msg_len=0;
+
+ ret = osal_msg_queue_write_copy(g_ble_Ai_record_queue, (void *)&blesrv_mail_end, sendlen , 0);
+ if (ret != OSAL_SUCCESS)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"len<=singlebuflen Error blesrv Check send failed! err=0x%X %d! \r\n", ret,send_msg_data_into_Ai_msg_queue_count);
+ }
+ }
+
+
+ blesrv_mail.service_handle = 2;
+ blesrv_mail.msg_len = len;
+ blesrv_mail.msg_data = (uint8_t*)malloc(len);
+
+ if(blesrv_mail.msg_data==NULL)
+ {
+ return ERRCODE_FAIL;
+ }
+ memcpy_s((void *)(blesrv_mail.msg_data),len,buff,len);
+
+ ret = osal_msg_queue_write_copy(g_ble_Ai_record_queue, (void *)&blesrv_mail, sendlen , 0);
+ if (ret != OSAL_SUCCESS)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"len<=singlebuflen Error blesrv Check send failed! err=0x%X %d! \r\n", ret,send_msg_data_into_Ai_msg_queue_count);
+ }
+ return OSAL_SUCCESS;
+ }
+ //以下为文件数据处理
+ if(g_blesrv_mail.msg_len+len<singlebuflen)
+ {
+ if (g_blesrv_mail.msg_len!=0 || g_blesrv_mail.msg_data!=NULL)
+ {
+ // g_blesrv_mail.msg_data=realloc( g_blesrv_mail.msg_data,g_blesrv_mail.msg_len+len);
+ uint8_t* temp_g_blesrv_mail_msg_data=malloc(g_blesrv_mail.msg_len+len);
+ if(temp_g_blesrv_mail_msg_data==NULL)
+ {
+ return ERRCODE_FAIL;
+ }
+ memcpy_s(temp_g_blesrv_mail_msg_data+ g_blesrv_mail.msg_len,singlebuflen,buff,len);
+ memcpy_s(temp_g_blesrv_mail_msg_data,singlebuflen,g_blesrv_mail.msg_data,g_blesrv_mail.msg_len);
+
+ free(g_blesrv_mail.msg_data);
+ g_blesrv_mail.msg_data=temp_g_blesrv_mail_msg_data;
+ g_blesrv_mail.msg_len+=len;
+ }
+ else
+ {
+ g_blesrv_mail.msg_data=malloc(len);
+ if(g_blesrv_mail.msg_data==NULL)
+ {
+ return ERRCODE_FAIL;
+ }
+
+ memcpy_s(g_blesrv_mail.msg_data+ g_blesrv_mail.msg_len,singlebuflen,buff,len);
+ g_blesrv_mail.msg_len=len;
+ }
+
+
+ return OSAL_SUCCESS;
+ }
+ else if(g_blesrv_mail.msg_len+len==singlebuflen)
+ {
+ // g_blesrv_mail.msg_data=realloc( g_blesrv_mail.msg_data,g_blesrv_mail.msg_len+len);
+
+ blesrv_mail.msg_len = singlebuflen;
+ blesrv_mail.msg_data = (uint8_t*)malloc(singlebuflen);
+ if(blesrv_mail.msg_data==NULL)
+ {
+ return ERRCODE_FAIL;
+ }
+
+ memcpy_s( blesrv_mail.msg_data,singlebuflen,g_blesrv_mail.msg_data,g_blesrv_mail.msg_len);
+ memcpy_s( blesrv_mail.msg_data+ g_blesrv_mail.msg_len,singlebuflen,buff,len);
+
+ g_blesrv_mail.msg_len=0;
+ free( g_blesrv_mail.msg_data);
+ g_blesrv_mail.msg_data=NULL;
+
+ ret = osal_msg_queue_write_copy(g_ble_Ai_record_queue, (void *)&blesrv_mail, sendlen , 0);
+ if (ret != OSAL_SUCCESS)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"len<=singlebuflen Error blesrv Check send failed! err=0x%X %d! \r\n", ret,send_msg_data_into_Ai_msg_queue_count);
+ }
+ return OSAL_SUCCESS;
+
+ }
+ else
+ {
+ if(g_blesrv_mail.msg_len!=0 && g_blesrv_mail.msg_data!=NULL)
+ {
+ blesrv_mail.msg_len=g_blesrv_mail.msg_len;
+ blesrv_mail.msg_data=malloc(g_blesrv_mail.msg_len);
+ if(blesrv_mail.msg_data==NULL)
+ {
+ return ERRCODE_FAIL;
+ }
+
+ memcpy_s( blesrv_mail.msg_data,singlebuflen,g_blesrv_mail.msg_data,g_blesrv_mail.msg_len);
+ free(g_blesrv_mail.msg_data);
+
+ ret = osal_msg_queue_write_copy(g_ble_Ai_record_queue, (void *)&blesrv_mail, sendlen , 0);
+ if (ret != OSAL_SUCCESS)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"len<=singlebuflen Error blesrv Check send failed! err=0x%X %d! \r\n", ret,send_msg_data_into_Ai_msg_queue_count);
+ }
+
+ }
+
+ g_blesrv_mail.msg_len=len;
+ g_blesrv_mail.msg_data=malloc(len);
+ memcpy_s( g_blesrv_mail.msg_data,singlebuflen,buff,len);
+
+
+ return OSAL_SUCCESS;
+ }
+
+ }
+ else
+ {
+ uint8_t count=len/singlebuflen;
+ if(len%singlebuflen)
+ {
+ count++;
+ }
+ uint16_t residue_len=len;
+ for(int i=0;i<count;i++)
+ {
+ blesrv_mail.service_handle = 0;
+ if(residue_len>=singlebuflen)
+ {
+ blesrv_mail.msg_len = singlebuflen;
+ blesrv_mail.msg_data = (uint8_t*)malloc(singlebuflen);
+
+ if(blesrv_mail.msg_data==NULL)
+ {
+ return ERRCODE_FAIL;
+ }
+ memcpy_s((void *)(blesrv_mail.msg_data),singlebuflen,buff+i*singlebuflen,singlebuflen);
+ residue_len-=singlebuflen;
+ }
+ else if(len%singlebuflen)
+ {
+ blesrv_mail.msg_len = len%singlebuflen;
+ blesrv_mail.msg_data = (uint8_t*)malloc( len%singlebuflen);
+
+ if(blesrv_mail.msg_data==NULL)
+ {
+ return ERRCODE_FAIL;
+ }
+ memcpy_s((void *)(blesrv_mail.msg_data),len%singlebuflen,buff+i*singlebuflen,len%singlebuflen);
+ }
+
+
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"g_blesrv_queue:%d ble_recv:mail.msg_data %X %02X %02X %02X msg_data:%02X %02X %02X\r\n",
+ g_ble_Ai_record_queue,
+ blesrv_mail.msg_data,
+ blesrv_mail.msg_data[0],
+ blesrv_mail.msg_data[1],
+ blesrv_mail.msg_data[2],
+ msg_data[0],
+ msg_data[1],
+ msg_data[2]
+ );
+ ret = osal_msg_queue_write_copy(g_ble_Ai_record_queue, (void *)&blesrv_mail, sendlen , 0);
+ if (ret != OSAL_SUCCESS)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"else Error blesrv Check send failed! err=0x%X %d %d! \r\n", ret,send_msg_data_into_Ai_msg_queue_count,len);
+ }
+ }
+ }
+
+
+ return ret;
+}
+
+
+
+#ifdef __cplusplus
+}
#endif
\ No newline at end of file
extern uint16_t data2ae8Cmd;//AI
extern uint16_t ble_nus_max_data_len;
extern uint16_t alipay_handle;
-extern uint16_t g_ble_conn_id;
+/** AT^CHANGAN_ICCE_SUB 使用的参数:在 MTU 交换成功时由 bleService 写入,勿通过 AT 传参 */
+extern uint16_t g_changan_icce_sub_conn_id;
+extern uint8_t g_changan_icce_sub_client_id;
extern uint16_t g_ble_server_handle;
#ifdef CUSTOM_Z1
void set_AI_interval(uint8_t data);
errcode_t uapi_Ai_send_service_init(void);
+
+bool ble_start_scan(bd_addr_t *addr, unsigned int timeout_ms);
+bool ble_connect_to_device(bd_addr_t *addr);
+
#ifdef __cplusplus
}
#endif
--- /dev/null
+#!/usr/bin/env python3
+# Mirror bleICCE.c: icce_crc16_ccitt + icce_frame_parse (BE length field = Control..payload 末,不含 CRC)
+
+ICCE_FRAME_SOF = 0x5A
+ICCE_FRAME_MIN_LEN = 12
+
+
+def icce_crc16_ccitt(buf: bytes) -> int:
+ crc = 0xFFFF
+ for b in buf:
+ crc ^= b << 8
+ for _ in range(8):
+ if crc & 0x8000:
+ crc = (crc << 1) ^ 0x1021
+ else:
+ crc = crc << 1
+ crc &= 0xFFFF
+ return crc
+
+
+def icce_frame_parse(raw: bytes):
+ errs = {0: "OK", -1: "arg/min len", -2: "SOF!=0x5A", -3: "len mismatch/body_raw",
+ -4: "CRC fail"}
+ raw_len = len(raw)
+ if raw_len < ICCE_FRAME_MIN_LEN:
+ return -1, None, f"raw_len={raw_len} < {ICCE_FRAME_MIN_LEN}"
+
+ if raw[0] != ICCE_FRAME_SOF:
+ return -2, None, f"SOF=0x{raw[0]:02X} (expect 0x{ICCE_FRAME_SOF:02X})"
+
+ len_field = (raw[1] << 8) | raw[2]
+ if raw_len < 7 or raw_len != 3 + len_field + 2:
+ return -3, None, (
+ f"raw_len={raw_len} != 3+len_field+2={3+len_field+2} "
+ f"(len_field BE=0x{len_field:04X})"
+ )
+ body_len = len_field + 2 # Control..CRC 含
+
+ control = raw[3]
+ body_raw_len = body_len - 4
+ if body_raw_len < 2:
+ return -3, None, f"body_raw_len={body_raw_len} < 2"
+
+ body_raw = raw[5 : 5 + body_raw_len]
+ crc_len = raw_len - 2
+ crc_calc = icce_crc16_ccitt(raw[:crc_len])
+ crc_recv = (raw[crc_len] << 8) | raw[crc_len + 1]
+ chk_ok = crc_calc == crc_recv
+
+ hdr = {
+ "body_len": body_len,
+ "control": control,
+ "fsn": raw[4],
+ "checksum_ok": chk_ok,
+ "crc_calc": crc_calc,
+ "crc_recv": crc_recv,
+ "msg_id": body_raw[0] if len(body_raw) > 0 else None,
+ "cmd_id": body_raw[1] if len(body_raw) > 1 else None,
+ "payload_len": len(body_raw) - 2,
+ }
+ if not chk_ok:
+ return -4, hdr, f"CRC calc=0x{crc_calc:04X} recv=0x{crc_recv:04X}"
+ return 0, hdr, "OK"
+
+
+def main():
+ # User sample (65 B): previously started with 5A
+ h = (
+ "5A003C10000101013680CA0000319F1E1060001001250528330000"
+ "0069259514069F3708F018C99F2F8EDADA9F0C10600010012505"
+ "28330000006925951406FB1B"
+ )
+ raw = bytes.fromhex(h)
+ print("=== Original hex (user segment, 65 bytes) ===")
+ print(raw.hex())
+ ret, hdr, msg = icce_frame_parse(raw)
+ lf = (raw[1] << 8) | raw[2]
+ print(f"parse return: {ret} ({'OK' if ret==0 else 'fail'}) — {msg}")
+ print(f"len_field=0x{lf:04X}, expect total 3+len_field+2={3+lf+2}, actual len={len(raw)}\n")
+
+ # 原包若 CRC 正确且 len_field=0x003C,应一次通过(见上 ret)
+
+
+if __name__ == "__main__":
+ main()
} haisi_ws_log_level_t;
// 当前日志等级(可通过配置修改)
-static haisi_ws_log_level_t g_haisi_log_level = HAISI_WS_LOG_INFO;
+static haisi_ws_log_level_t g_haisi_log_level = HAISI_WS_LOG_DEBUG;
//
// 日志等级字符串数组
*/
/* 消息队列相关定义 */
-#define WS_MSG_QUEUE_COUNT 64
+#define WS_MSG_QUEUE_COUNT 256
#define WS_MSG_TYPE_SEND_TEXT 0x01
#define WS_MSG_TYPE_FORCE_RECONNECT 0x02
#define WS_MSG_TYPE_STOP 0x03
osStatus_t ret = osMessageQueuePut(g_ws_msg_queue, &msg, 0, 0);
if (ret == osOK) {
HAISI_WS_DEBUG("Raw message queued successfully, length: %d, timestamp: %u\n", msg->data_len, msg->timestamp);
+ int tick = osKernelGetTickCount();
+ HAISI_WS_DEBUG("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxRaw message queued successfully, tick: %d\n", tick);
} else {
HAISI_WS_ERROR("Failed to queue raw message: %d\n", ret);
// 队列失败时释放内存
int ret=0;
if(strlen(header_buf)==0)
{
+ HAISI_WS_DEBUG("WebSocketClientConnect: %s\n", url);
+ HAISI_WS_DEBUG("WebSocketClientConnect no header\n");
ret= WebSocketClientConnect(g_ws_client_fd, url, NULL);
}
else
{
+ HAISI_WS_DEBUG("WebSocketClientConnect: %s\n", url);
+ HAISI_WS_DEBUG("WebSocketClientConnect with header: %s\n", header_buf);
ret= WebSocketClientConnect(g_ws_client_fd, url, header_buf);
}
}
}
- // 心跳部分:由回调函数处理时间判断和心跳发送
+ uint32_t msg_queue_pending = 0U;
+ if (g_ws_msg_queue != NULL) {
+ msg_queue_pending = osMessageQueueGetCount(g_ws_msg_queue);
+ }
+
+ // 心跳部分:由回调函数处理时间判断和心跳发送;队列有待处理消息时不做心跳,优先消费队列
if (g_ws_connected == WS_STATE_CONNECTED && g_ws_client_fd >= 0) {
- // 使用心跳回调函数处理,包括时间判断
- if (g_ws_callbacks.heartbeat_callback != NULL) {
+ if (msg_queue_pending == 0U && g_ws_callbacks.heartbeat_callback != NULL) {
if (g_ws_callbacks.heartbeat_callback()) {
// 回调函数返回1表示需要发送心跳,这里可以添加额外的处理
HAISI_WS_DEBUG("Heartbeat callback triggered\n");
HAISI_WS_INFO("ws_state %s\n",uapi_ws_get_connection_state_string());
}
- /* 使用动态间隔时长 */
- {
+ /* 使用动态间隔时长:队列有待处理消息时不延时,尽快再次取队列/处理消息 */
+ if (msg_queue_pending == 0U) {
usleep(g_main_thread_interval_ms * 1000); // 转换为微秒
}
}
app_task_definition_ext_t main_task = {
.attr = {
.name = "uapi_ws_main",
- .stack_size = 0x2000,
+ .stack_size = 0x8000,
.priority = osPriorityNormal
},
.func = uapi_ws_main_thread,
return 0;
#else
// 直接发送模式(WS_SEND_DIRECT_ENABLE=1 或 WS_USE_SEND_QUEUE=0)
- int network_status = 1;//uapi_dev_runtime_get_cat1_networkstat();
- if (network_status != 1 || g_ws_connected != WS_STATE_CONNECTED || g_ws_client_fd < 0) {
- HAISI_WS_WARN("Cannot send text, connection state: %d , network_status: %d\n", g_ws_connected,network_status);
- return -1;
- }
+ // int network_status = 1;//uapi_dev_runtime_get_cat1_networkstat();
+ // if (network_status != 1 || g_ws_connected != WS_STATE_CONNECTED || g_ws_client_fd < 0) {
+ // HAISI_WS_WARN("Cannot send text, connection state: %d , network_status: %d\n", g_ws_connected,network_status);
+ // return -1;
+ // }
// 发送前检查并resume
// uapi_ws_resume();
#include <stdint.h>
#include <stddef.h>
+#include <stdbool.h>
/* WebSocket连接超时配置 */
#ifndef WS_CONNECT_TIMEOUT_SECONDS
--- /dev/null
+#!/usr/bin/env python3
+"""
+Delete all files with given extension(s) under a directory.
+
+Examples:
+ python delete_files_by_extension.py /path/to/dir .tmp .log
+ python delete_files_by_extension.py ./build .o --dry-run
+ python delete_files_by_extension.py . .pyc --no-recursive
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+
+def normalize_ext(ext: str) -> str:
+ ext = ext.strip()
+ if not ext.startswith("."):
+ ext = "." + ext
+ return ext.lower()
+
+
+def name_matches_ext(filename: str, ext: str) -> bool:
+ """
+ Match extension against the basename. Supports multi-dot suffixes such as
+ '.Zone.Identifier' (Path.suffix would only return '.Identifier').
+ """
+ name = filename.lower()
+ ext_l = ext.lower()
+ if len(name) < len(ext_l):
+ return False
+ if not name.endswith(ext_l):
+ return False
+ # Require a real '.' before the extension (avoid matching 'txt' inside 'notmytxt')
+ return name[len(name) - len(ext_l)] == "."
+
+
+def collect_files(root: Path, extensions: set[str], recursive: bool) -> list[Path]:
+ if recursive:
+ paths = root.rglob("*")
+ else:
+ paths = root.iterdir()
+
+ out: list[Path] = []
+ for p in paths:
+ if not p.is_file():
+ continue
+ if any(name_matches_ext(p.name, e) for e in extensions):
+ out.append(p)
+ return sorted(out)
+
+
+def main() -> int:
+ parser = argparse.ArgumentParser(
+ description="Delete files matching extension(s) under a directory (all subfolders by default)."
+ )
+ parser.add_argument(
+ "directory",
+ type=Path,
+ help="Root directory to search",
+ )
+ parser.add_argument(
+ "extensions",
+ nargs="+",
+ metavar="EXT",
+ help="File extensions, e.g. .tmp txt (leading dot optional)",
+ )
+ parser.add_argument(
+ "--no-recursive",
+ action="store_false",
+ dest="recursive",
+ default=True,
+ help="Only search the given directory, not subfolders (default: recurse all subfolders)",
+ )
+ parser.add_argument(
+ "-n",
+ "--dry-run",
+ action="store_true",
+ help="List files that would be deleted without deleting",
+ )
+ args = parser.parse_args()
+
+ root = args.directory.resolve()
+ if not root.is_dir():
+ print(f"Error: not a directory: {root}", file=sys.stderr)
+ return 1
+
+ exts = {normalize_ext(e) for e in args.extensions}
+ files = collect_files(root, exts, args.recursive)
+
+ if not files:
+ print("No matching files.")
+ return 0
+
+ for f in files:
+ if args.dry_run:
+ print(f"[dry-run] would delete: {f}")
+ else:
+ try:
+ f.unlink()
+ print(f"deleted: {f}")
+ except OSError as e:
+ print(f"Error deleting {f}: {e}", file=sys.stderr)
+
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())