https 下载重构 2798/1 2798/head optimize_lwip
author孙春阳 <snickersun@163.com>
Mon, 24 Nov 2025 08:10:31 +0000 (16:10 +0800)
committer孙春阳 <snickersun@163.com>
Mon, 24 Nov 2025 08:10:31 +0000 (16:10 +0800)
31 files changed:
code/sdk/files/leiniao/fs/user/system/cat1ota/Cat1pyVersion.txt
code/sdk/files/leiniao/fs/user/system/cat1ota/cat1Service.py [new file with mode: 0644]
code/sdk/files/leiniao/fs/user/system/cat1otaudp/cat1Service.py [deleted file]
code/sdk/files/leiniao/fs/user/system/cat1otaudp/china_mobile_dmp.py [deleted file]
code/sdk/files/leiniao/fs/user/system/cat1otaudp/is_need_updata.txt [deleted file]
code/sdk/files/leiniao/fs/user/system/cat1otaudp/main.py [deleted file]
code/sdk/files/leiniao/fs/user/system/cat1otaudp/tcpserver.py [deleted file]
code/sdk/files/leiniao/fs/user/system/cat1otaudp/telecom_dmp.py [deleted file]
code/sdk/open_source/openharmony/third_party/lwip/CMakeLists.txt
code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include/lwip/lwipopts_default.h
code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/altcp_tls/altcp_tls_mbedtls.c
code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/http/http_client.c
code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/include/lwip/apps/http_client.h
code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/netif/slipif.c
code/sdk/zhihui/4g/cat1Service/CMakeLists.txt
code/sdk/zhihui/4g/cat1Service/Service/cat1_server.c
code/sdk/zhihui/4g/cat1Service/include/custom_http_download.h
code/sdk/zhihui/4gTest/cat1_porting.c
code/sdk/zhihui/ai_stub/src/ppp_stub_functions.c
code/sdk/zhihui/leiniao/imsl_ln/CMakeLists.txt
code/sdk/zhihui/leiniao/imsl_ln/ZHIHUI_HTTP_CLIENT_README.md [new file with mode: 0644]
code/sdk/zhihui/leiniao/imsl_ln/ln_api.c
code/sdk/zhihui/leiniao/imsl_ln/ln_api.h
code/sdk/zhihui/leiniao/imsl_ln/ln_api_emoji.c
code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.c
code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.h
code/sdk/zhihui/leiniao/imsl_ln/zhihui_http_client.c [new file with mode: 0644]
code/sdk/zhihui/leiniao/imsl_ln/zhihui_http_client.h [new file with mode: 0644]
code/sdk/zhihui/utils/custom_utils.c
tools/convert_cert_to_c.py [new file with mode: 0644]
tools/get_server_cert.sh [new file with mode: 0644]

diff --git a/code/sdk/files/leiniao/fs/user/system/cat1ota/cat1Service.py b/code/sdk/files/leiniao/fs/user/system/cat1ota/cat1Service.py
new file mode 100644 (file)
index 0000000..81c5a36
--- /dev/null
@@ -0,0 +1,1131 @@
+# Copyright (c) Quectel Wireless Solution, Co., Ltd.All Rights Reserved.
+#  
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#  
+#     http://www.apache.org/licenses/LICENSE-2.0
+#  
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+# net.getNetMode()
+# (0, '460', '11', 7)
+
+# net.getSignal(1)
+# ([99, 99, 255, 255], [-84, -117, -15, 255, -3])
+
+# net.nitzTime()
+# ('24/02/26 11:17:42 8 0', 1708946262, 0)
+
+
+import usocket
+import log
+import utime
+import slip
+# import audio
+from machine import UART
+import _thread
+from queue import Queue
+from machine import Pin
+from machine import ExtInt
+import dataCall
+# import voiceCall
+import net
+import uping
+import example
+import osTimer
+import sim
+import modem
+import utime
+import checkNet
+import atcmd
+import fota
+import request
+import ql_fs
+import pm
+import sms
+import ujson
+
+from usr.EventMesh import eventMesh
+
+from usr.httpota import httpota
+from usr.telecom_dmp import telecomDmpCb
+from usr.china_mobile_dmp import chinamobileCb
+from usr.tcpserver import TcpServiceInit
+
+from usr.china_mobile_ai_regulation import aiRegulation
+# 设置日志输出级别
+log.basicConfig(level=log.INFO)
+clog = log.getLogger("cat1")
+
+def msg_cb(args):
+    index = args[1]
+    storage = args[2]
+    sms_data = sms.getSaveLoc()
+    if sms_data == -1:
+        return
+    sms_max = sms_data[0][2]
+    if index != -1:
+        eventMesh.publish("send_singal_data_toBle",index)
+        
+    if index >= sms_max-1:#删除短信
+        eventMesh.publish("delete_sms_event")#删除短信
+
+sms.setCallback(msg_cb)#sms注册回调
+
+CAT1_SERVICE_HEAD = 'FE' #固定head 
+
+PROJECT_NAME = "Cat1SlipUDPService"
+PROJECT_VERSION = "PY_SRV_V26"
+CONFIG_JSON="/usr/system_config.json"
+CURRENT_APP_TYPE="pysrv"
+
+
+
+
+
+
+#设置通话音量
+# voiceCall.setVolume(10)
+# clog.info("voice call volume {}".format(voiceCall.getVolume()))
+lpm_fd = pm.create_wakelock("system_lock", len("system_lock"))
+pm.autosleep(1)
+pm.wakelock_lock(lpm_fd)
+clog.info("create_wakelock {}".format(pm.get_wakelock_num()))
+telecomTimerCount = 0
+def get_versionkeyname_by_py(app_type):
+    return str("{}version".format(app_type))
+
+def get_default_versionvalue_by_py(app_type):
+    if (app_type == "pymain"):
+        return "PY_MAIN_V2"
+    elif (app_type == "pyota"):
+        return  "PY_OTA_V14"
+    elif (app_type == "pysrv"):
+        return  "PY_SRV_V16"
+
+#如果没有configfile则创建它
+if not ql_fs.path_exists(CONFIG_JSON):
+    data = {str(get_versionkeyname_by_py(CURRENT_APP_TYPE)):get_default_versionvalue_by_py(CURRENT_APP_TYPE)}
+    ql_fs.touch(CONFIG_JSON,data)
+
+def set_version_to_json_config(app_type,keyvalue):
+    try :
+        config_data = ql_fs.read_json(CONFIG_JSON)
+        config_data.update( {str(get_versionkeyname_by_py(app_type)):keyvalue})
+        ql_fs.touch(CONFIG_JSON, config_data)
+        clog.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
+        clog.info("{}".format(config_data))
+    except Exception as e:
+        clog.error("set_version_to_json_config")
+
+def get_version_from_json_config(app_type):
+    config_data = ql_fs.read_json(CONFIG_JSON)
+    keyvalue = config_data.get( get_versionkeyname_by_py(app_type),get_default_versionvalue_by_py(app_type))
+    clog.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
+    return keyvalue
+
+set_version_to_json_config(CURRENT_APP_TYPE,PROJECT_VERSION)
+    
+
+# audio.set_qdai_cfg(1,0,0,1,0,0,1,1)
+
+#GPIO[53]      PD MAIN_RTS  WAKEUP CAT1  被主控唤醒
+#GPIO[31]      PD MAIN_RI  RINGING  唤醒主控
+
+# GPIOn - GPIO号,int类型,点此查看GPIO引脚编号与物理引脚的映射关系。
+
+# direction - 输入输出模式,int类型,IN - 输入模式,OUT - 输出模式。
+
+# pullMode - 上下拉模式,int类型,说明如下:
+# PULL_DISABLE - 浮空模式
+# PULL_PU - 上拉模式
+# PULL_PD - 下拉模式
+
+# level - 引脚电平,int类型,0 - 设置引脚为低电平, 1- 设置引脚为高电平。
+# recvDataPin = Pin(Pin.GPIO53, Pin.IN, Pin.PULL_PU, 0)
+def ExtIntfun(args):
+        # clog.info('### interrupt  {} ###'.format(args)) # args[0]:gpio号 args[1]:上升沿或下降沿
+        if args[1] == 0:
+            clog.info("disable autosleep")
+            # pm.autosleep(0)
+            pm.wakelock_lock(lpm_fd)
+        elif args[1] == 1:
+            clog.info("enable autosleep")
+            pm.wakelock_unlock(lpm_fd)
+            # pm.autosleep(1)
+        # clog.info("recvDataPin={}".format(recvDataPin.read()))
+extint = ExtInt(ExtInt.GPIO30, ExtInt.IRQ_RISING_FALLING, ExtInt.PULL_DISABLE, ExtIntfun)
+extint.enable()
+
+
+# 创建gpio对象
+gpioWakeBT = Pin(Pin.GPIO31, Pin.OUT, Pin.PULL_DISABLE, 1)
+# 设置输入输出模式
+gpioWakeBT.set_dir(Pin.OUT)
+
+# 设置引脚电平
+gpioWakeBT.write(1)
+
+UDP_CMD_GET_CAT1VER = '0'  #获取 Cat1 版本号
+UDP_CMD_DIAL_NUMB = '1'              #拨打电话
+UDP_CMD_HUNGUP = '2'               #挂断电话
+UDP_CMD_ANSWER = '3'            #接听电话
+UDP_CMD_CAT1_OTA_UPDATE = '4'       #触发Cat1 OTA升级,mcu提供url
+UDP_CMD_SEND_SMS = '5'         #发送SMS短信,mcu提供电话号及短信内容
+UDP_CMD_GET_TIME = '6'               #获取Cat1 时间 ,YYYYMMDD HHmmss zone
+UDP_CMD_GET_RECV_NETWORKSTAT = '7'      #获取Cat1 信号信息,VOLTE信息,信号强度,SIM卡状态  // 内容同UDP_CMD_GET_NETWORKSTAT,CAT主动发给MCU
+UDP_MSG_SMS = '8'           #  CAT1接收到的SMS信息给MCU,包含电话号及短信内容
+UDP_CMD_ATCMD = '9'           # 执行AT指令
+UDP_MSG_CALL_CONNECTED = 'A'       #  CAT1 电话接听消息
+UDP_MSG_CALL_DISCONNECTED = 'B'        #  CAT1 电话挂断消息
+UDP_MSG_COMMING_CALL = 'C'       #  CAT1 来电消息,包含电话号
+UDP_MSG_REPLY = 'F'         # 返回值 
+UDP_MSG_OTA = 'D'         # 返回值 
+
+class Cat1Service:
+    AP = 0  # SLIP_INNER
+    STA = 1 # SLIP_OUTER
+
+    def __init__(self, uart=UART.UART2, mode=AP):
+        
+        self.__uart = uart
+        self.__mode = mode
+        self.__message = ''
+        self.__err = 0
+        self.__net_connected = 0
+        # self.__value = None
+        self.__wait_resp = 0
+        self.__waiting_netstat = 0
+        slip.destroy()
+        clog.info('slip uart={0}'.format (self.__uart))
+
+        ret = slip.construct(self.__uart, self.__mode, 0)
+        if ret != 0:
+            clog.error('slip netif construct fail')
+            return None
+        clog.info('slip network card create success')
+        # self.__queue = Queue(1)
+        self.__sock = self.__socket_init()
+        self.__threadid = _thread.start_new_thread(self.__Socket_Thread, ())
+        self.telecom_init_flag = 0
+        self.telecomTimer = osTimer()
+        eventMesh.subscribe("cat1_reply_iccid_to_ble",self.cat1_reply_iccid_to_ble)
+        eventMesh.subscribe("cat1_reply_timesec_to_ble",self.cat1_reply_timesec_to_ble)
+        
+        self.iccid_data = ""
+        self.software_version = ""
+        self.deletSmsTimer = osTimer()
+        self.china_mobile_ai_init = 0
+        self.volte_switch = 1 #默认是开启VOLTE通话功能
+        eventMesh.subscribe("set_dmp_change_mode",self.set_dmp_change_mode)
+        eventMesh.subscribe("get_dmp_change_mode",self.get_dmp_change_mode)
+        eventMesh.subscribe("delete_sms_event",self.delete_sms_event)
+        eventMesh.subscribe("remove_all_sms_cb", self.remove_all_sms_cb)#
+        eventMesh.subscribe("send_sms_max_to_Ble",self.send_sms_max_to_Ble)
+        eventMesh.subscribe("get_all_sms_data",self.get_all_sms_data) #获取所有的短信内容
+        eventMesh.subscribe("send_singal_data_toBle",self.send_singal_data_toBle)
+        eventMesh.subscribe("delete_sms_single_data",self.delete_sms_single_data)
+
+        eventMesh.subscribe("get_factory_status",self.get_factory_status)
+        eventMesh.subscribe("set_factory_status",self.set_factory_status)
+        eventMesh.subscribe("send_dmp_cm_address_toBLE",self.send_dmp_cm_address_toBLE)
+        eventMesh.subscribe("set_volte_switch",self.set_volte_switch)
+        eventMesh.subscribe("get_volte_switch",self.get_volte_switch)
+        eventMesh.publish("delete_sms_event")
+
+       
+        self.telecom_dmp_switch = 0
+
+        self.send_data = []
+        self.code_old = 0
+        self.code_old_num = 1
+        self.tmp_data = []
+        self.total_num = 0
+        #
+        self.msg_nums = 0
+        self.msg_nums_old = 0
+        self.china_mobile_init = 0
+        self.factory_status = 0
+        self.send_data_q = Queue(100)
+        self.ack_sem=0
+        _thread.start_new_thread(self.Socket_SEND_Thread,())
+        # 发数据线程
+        return None
+
+    def __socket_init(self):
+        # 创建一个socket实例
+        sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.TCP_CUSTOMIZE_PORT)
+        sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
+        # 绑定IP
+        bind_addr = ('172.16.1.2', 5000)
+        sock.bind(bind_addr)
+        sock.settimeout(None)
+        return sock
+
+    def __socket_reinit(self):
+        return self.__socket_init()
+    
+    def bootup_msg_to_bt(self):
+        modem_ver = modem.getDevFwVersion() 
+        self.reply_cmd('0F',"BOOTUP@pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
+        # self.reply_cmd('0F',"VOLUME:{}".format(voiceCall.getVolume()))
+        self.reply_cmd('0F',"PRODUCT:LEINIAO")
+
+    def btmcu_cmd_handler(self,cmd,parm):
+        
+        # cmd = ""
+        # cmd_tmp= int(cmd_data)#将十进制数转换成int 再转换成十六进制
+        # cell_data = hex(cmd_tmp)
+        # decimal_number = int(cell_data, 16)
+        # cmd = "%02x"%(decimal_number)  # 使用两位表示,不足前面补0
+        clog.info(cmd)  # 输出: 07
+        clog.info("btmcu_cmd_handler cmd {0} , args {1}".format(cmd,parm))
+        if cmd == "00":
+            clog.info(cmd)
+            # UDP_CMD_GET_CAT1VER
+            modem_ver = modem.getDevFwVersion() 
+            self.reply_cmd('00',"pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
+        elif cmd == "01":
+            # UDP_CMD_DIAL_NUMB
+            if eventMesh.publish("get_volte_switch") == 1: #只有BLE开了VOLTE才允许打电话
+                # ret = voiceCall.callStart(str(parm))
+                # if ret != 0:
+                #     ret = voiceCall.callStart(str(parm))
+                ret = 0
+                clog.info("ret={} {} {}".format(ret,cmd,parm))
+                if ret != 0:
+                    self.reply_cmd('0F',"callcmd_fail")
+                else:
+                    self.reply_cmd('0F',"callcmd_success")
+            else:
+                print("get_volte_switch NO")
+                self.reply_cmd('0F',"callcmd_fail")
+        elif cmd == "02":
+            clog.info(cmd)
+            # UDP_CMD_HUNGUP
+            # ret = voiceCall.callEnd()
+            ret = 0
+            # if ret != 0:
+                # ret = voiceCall.callEnd()
+            if ret != 0:
+                self.reply_cmd('0F',"callend_fail")
+            else:
+                self.reply_cmd('0F',"callend_success")
+        elif cmd == "03":
+            clog.info(cmd)
+            # UDP_CMD_ANSWER
+            # ret = voiceCall.callAnswer()
+            ret = 0
+            # if ret != 0:
+                # ret = voiceCall.callAnswer()
+            if ret != 0:
+                self.reply_cmd('0F',"callanswer_fail")
+            else:
+                self.reply_cmd('0F',"callanswer_success")
+        elif cmd == "04":
+            clog.info(cmd)
+        elif cmd == "05":
+            clog.info(cmd)
+            # UDP_CMD_SEND_SMS
+        elif cmd == "06":
+            clog.info(cmd)
+            # UDP_CMD_GET_TIME
+            time=utime.localtime()
+            zone=utime.getTimeZone()
+            #(2024, 3, 2, 18, 31, 32, 5, 62),8
+            # 返回当前时间戳,参数为元组
+            # timestamp = utime.mktime(time)
+            # clog.info(timestamp)
+            self.reply_cmd('06',"{0}@{1}".format(time,zone))
+        elif cmd == "07":
+            clog.info("cmd ==== 07!")
+            # UDP_CMD_GET_RECV_NETWORKSTAT
+            simstat = sim.getStatus()
+            iccid = sim.getIccid()
+            imei = modem.getDevImei()
+            netstat = "0,10,0,10"
+            netstat_ = net.getState()
+            if netstat_ != -1 :
+                netstat = "{},{},{},{}".format(netstat_[0][0],netstat_[0][3],netstat_[1][0],netstat_[1][3])
+            # ([voice_state, voice_lac, voice_cid, voice_rat, voice_reject_cause, voice_psc], [data_state, data_lac, data_cid, data_rat, data_reject_cause, data_psc])
+            operator =  net.operatorName()
+            signal = net.csqQueryPoll()
+            clog.info("imei:{0}@sim:{1}@iccid:{2}@oper:{3}@signal:{4}@net:{5}".format(imei,simstat,iccid,operator,signal,netstat))
+            self.reply_cmd('07',"imei:{0}@sim:{1}@iccid:{2}@oper:{3}@signal:{4}@net:{5}".format(imei,simstat,iccid,operator,signal,netstat))
+        elif cmd == "09":
+            clog.info("{},{}".format(cmd,parm))
+            # UDP_CMD_ATCMD
+            # net.setModemFun(0)
+            # net.setModemFun(1)
+            resp=bytearray(50)
+            ret=atcmd.sendSync("{}\r\n".format(parm),resp,'',10)
+            if ret == 0:
+                clog.info("reply:{},ret:{}".format(resp.decode(),ret))
+                self.reply_cmd('09',"{}".format(resp.decode()))
+            else:
+                clog.info("cmd error ret:{}".format(ret))
+                self.reply_cmd('09',"{}".format("at error"))
+        
+        elif cmd == "10" or cmd == "12" or cmd == "14": #获取固件版本号或者获取BT保存的SIM卡的ICCID BLE那边是否开启电信入库功能
+            if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1 :
+                if eventMesh.publish("get_dmp_change_mode") == 1:
+                    self.telecom_recv_cmd(cmd,parm)
+            else:
+                pass
+
+            if 1:#CHINA_MOBILE_DM_FUN_ENABLE == 1:
+                if eventMesh.publish("get_dmp_change_mode") > 1:
+                    self.china_mobile_recv_cmd(cmd,parm)
+            else:
+                pass
+            pass
+        elif cmd == "13":
+            on = int(parm)
+            clog.info("set_dmp_change_mode on:{}".format(on))
+            eventMesh.publish("set_dmp_change_mode",on)
+
+        elif cmd == "16":
+            if 1: #CHINA_MOBILE_DM_FUN_ENABLE == 1:
+                if eventMesh.publish("get_dmp_change_mode") > 1:
+                    self.china_mobile_recv_cmd(cmd,parm)
+            else:
+                pass
+        elif cmd == "17": #用于CAT1恢复出厂需要清空数据的标识通用
+            eventMesh.publish("set_factory_status",int(parm))
+        elif cmd == "18":
+            eventMesh.publish("set_dmp_cm_address",str(parm))
+        elif cmd == "19": #DTMF功能
+            # voiceCall.startDtmf(str(parm),100)  #100ms 持续时间 100-1000
+            pass
+        elif cmd == "1A":
+            eventMesh.publish("set_volte_switch",int(parm))
+        elif cmd == "1B":
+            print("fota  {}".format(str(parm).split("and")[0]))
+            print("fota  {}".format(str(parm).split("and")[-1]))
+            # httpota = httpota()
+            httpota.run( str(parm).split("and")[0], str(parm).split("and")[-1])
+            # eventMesh.publish("set_volte_switch",int(parm))
+            # UDP_MSG_OTA
+        elif cmd == "1C":# 
+            self.read_dev_ai_id()
+        elif cmd== "1D":
+            TcpService = TcpServiceInit()
+            TcpService.start_socket_thread()
+        elif cmd == "AC":#
+            if self.ack_sem==1:
+                self.ack_sem=0
+      
+               
+
+    def telecom_recv_cmd(self,cmd,parm): 
+        if cmd == "10":
+            self.software_version = str(parm)
+            eventMesh.publish("set_dev_version",self.software_version)
+            clog.info("software_version:{},{}".format(self.software_version,parm))
+        elif cmd == "12":
+            pass
+        elif cmd == "14":#
+            pass
+        pass
+
+    def set_volte_switch(self,event,msg): #设置VOLTE开关
+        self.volte_switch = int(msg)
+        
+
+    def get_volte_switch(self,event,msg): #获取VOLTE开关
+
+        return self.volte_switch
+        
+
+    def china_mobile_recv_cmd(self,cmd,parm): #移动入库相关指令
+        if cmd == "10":
+            self.software_version = str(parm)
+            eventMesh.publish("set_dev_version",self.software_version)
+            clog.info("software_version:{},{}".format(self.software_version,parm))
+        elif cmd == "16": #获取BLE mac地址
+            eventMesh.publish("set_dev_mac",str(parm))
+            clog.info("parm:{}\r\n".format(parm))
+                
+        pass
+    def get_factory_status(self,event,msg):
+        return self.factory_status
+    def set_factory_status(self,event,msg):
+        self.factory_status = int(msg)
+        if self.factory_status == 0: #只有为的时候才设置进去 1不再设置
+            self.reply_cmd('17',"{}".format(1))
+
+    def send_dmp_cm_address_toBLE(self,event,msg):
+        buf_tmp = "address:"+str(msg)
+        self.reply_cmd('18',"{}".format(buf_tmp))
+        
+    def set_dmp_change_mode(self,event,msg):
+        self.telecom_dmp_switch = msg
+    def delete_sms_single_data(self,event,msg): #删除单条信息
+        sms.deleteMsg(int(msg))
+
+    def get_dmp_change_mode(self,event,msg):
+        return self.telecom_dmp_switch
+    def delete_sms_event(self,event,msg):
+        self.deletSmsTimer.start(2*1000,0,self.delete_sms_cb)
+    def delete_sms_cb(self,*argc):
+        eventMesh.publish_async("remove_all_sms_cb","",1*1024)
+    def remove_all_sms_cb(self, event, msg):
+        clog.info("remove_all_sms_cb\r\n")
+        msg_nums = sms.getMsgNums() #短信数量
+        if msg_nums == -1:
+            msg_nums = 0
+        sms_data = sms.getSaveLoc()
+        clog.info("{}\r\n".format(sms_data))
+        if sms_data == -1:
+            return
+        sms_max = sms_data[0][2] #最大存储短信数量
+        if sms_max >= msg_nums and sms_max > 0:
+            sms.deleteMsg(1,4) #删除所有的sms信息
+
+    def send_singal_data_toBle(self,event,msg):
+        msg_nums = sms.getMsgNums() #短信数量
+        if msg_nums == -1:
+            msg_nums = 0
+        sms_data = sms.getSaveLoc()
+        if sms_data == -1:
+            return
+        sms_max = sms_data[0][2] #最大存储短信数量
+        clog.info("recv:{}".format(int(msg)))
+        message=self.sms_get_message_info(int(msg))
+        if message == -1: #说明没有这条短信
+            return
+        message_pdu = sms.decodePdu(message[5],20)
+        
+        if message_pdu != -1: #解码出来的内容
+
+            message_ref = message[0] #编码
+            message_total_num = message[1] #总共条数
+            message_seq = message[2] #当前第几条
+            data = message[5] #内容
+            data_len = len(data) #内容长度
+            # ref        :短信参考标识,同一个标识表明为同一条短信 
+            # total_num  :此条长短信总条数 大于1属于长短信
+            # seq        :此条短信在长短信中的序号
+            # print("message:{} {}\r\n".format(message,message_pdu))
+            msg_total = "ref:"+str(message_ref)+"@total_num:"+str(message_total_num)+"@seq:"+str(message_seq)+"@data:"+str(message[5])
+            self.reply_cmd('15',msg_total)
+        
+        eventMesh.publish("delete_sms_single_data",int(msg))
+
+    def sms_deal_phone_number(self,args):
+        data=enumerate(args)
+        data_str1=""
+        data_str2=""
+        data_str3=""
+        for index,value in data:
+            if index % 2 == 0:
+                data_str1=data_str1+value
+            else:
+                data_str2=data_str2+value
+        for i in range(0,len(data_str1)):
+            data_str3=data_str3+data_str2[i]
+            data_str3=data_str3+data_str1[i]
+        return data_str3
+    def sms_get_message_info(self,index):
+        """
+        :param index    :短信索引值
+        :tyoe  index    :整形
+        
+        :return         :元组类型
+        元组内容:
+        (message_ref,message_total_num,message_seq,sub_message_data,pdu_tye,sub_message_len)
+        
+        :message_ref        :短信参考标识,同一个标识表明为同一条短信
+        :message_total_num  :此条长短信总条数
+        :message_seq        :此条短信在长短信中的序号
+        :sub_message_data   :词条短信的内容
+        :pdu_tye            :PDU类型,bit 6标记是否包含用户报文头,长短信需要
+        :sub_message_len    :此条短信内容长度
+        
+        """
+
+        message0=sms.searchPduMsg(index)  
+        #print("sms_get_message_info:message0:{}".format(message0))
+        if message0 == -1:
+            return -1
+        
+        sca_num  = int(message0[0:2],16) - 1
+        data_len = 2
+        addr_type= message0[data_len:data_len+1*2]
+        data_len = data_len+1*2
+        
+        sca      = message0[data_len:data_len+sca_num*2]
+        # 电话号码高低位需要转换
+        sca = self.sms_deal_phone_number(sca)
+
+        # if sca_num % 2 == 1:
+        #      print("Get SCA phone {}".format(sca[:-1]))
+        # else:
+        #      print("Get SCA phone {}".format(sca))
+
+        data_len = data_len+sca_num*2
+
+        pdu_tye   = int(message0[data_len:data_len+1*2],16)
+        data_len = data_len+1*2
+
+        oa_num   = int(message0[data_len:data_len+1*2],16)
+        data_len = data_len+1*2
+        oa_addr_type   = message0[data_len:data_len+1*2]
+        data_len = data_len+1*2
+
+        if oa_num % 2 == 1:
+             oa_num_t   = int((oa_num + 1)/2)
+        else:
+             oa_num_t   = int((oa_num )/2)
+
+        oa       = message0[data_len:data_len+oa_num_t*2]
+        # 电话号码高低位需要转换
+        oa       = self.sms_deal_phone_number(oa)
+
+        # if oa_num % 2 == 1:
+        #      print("Get OA phone {}".format(oa[:-1]))
+        # else:
+        #      print("get OA phone {}".format(oa))
+
+        data_len = data_len+oa_num_t*2
+        pid      = message0[data_len:data_len+1*2]
+        
+        data_len = data_len+1*2
+        dcs      = message0[data_len:data_len+1*2]
+        data_len = data_len+1*2
+        scts     = message0[data_len:data_len+7*2] 
+        data_len = data_len+7*2
+        sub_message_len = int(message0[data_len:data_len+1*2],16)
+        data_len = data_len+1*2
+        sub_message_head = message0[data_len:data_len+6*2]
+        data_len = data_len+6*2
+
+        # 或短信用户数据
+        sub_message_data = message0[data_len:data_len+sub_message_len*2]
+
+        #长短信
+        if ((pdu_tye & 0x40 ) >> 6) == 1:
+            #长短信,处理长短信用户报文头
+            message_ref = int(sub_message_head[6:8],16)
+            message_total_num = int(sub_message_head[8:10],16)
+            message_seq = int(sub_message_head[10:12],16)
+            return [message_ref,message_total_num,message_seq,pdu_tye,sub_message_len,message0]
+        else:
+             # 短短信
+            return [0,1,1,pdu_tye,sub_message_len,message0]
+
+
+
+    def send_sms_max_to_Ble(self,event,msg):
+        msg_nums = sms.getMsgNums()#短信数量
+        if msg_nums == -1:
+            msg_nums = 0
+        sms_data = sms.getSaveLoc()
+        if sms_data != -1:
+            sms_max = sms_data[0][2]#最大存储短信数量
+            self.reply_cmd('15',"@sms_max:"+str(sms_max)+"@current_num:"+str(msg_nums))
+        pass
+    
+    def get_all_sms_data(self,event,msg):
+        msg_total = ""
+        SMS_lis={}
+        SMS_lis_count = 0
+        sms_data = sms.getSaveLoc()
+        clog.info(sms_data)
+        if sms_data == -1:
+            return
+        sms_max = sms_data[0][2]#最大存储短信数量
+        clog.info(sms_max)
+        self.msg_nums = sms.getMsgNums() 
+        if self.msg_nums_old != self.msg_nums:
+            self.send_data = []
+        self.msg_nums_old = self.msg_nums
+        if self.send_data == [] :
+            for i in range(self.msg_nums):
+                phonenum = ""
+                data =""
+                time = ""
+                data_len = 0
+                message=self.sms_get_message_info(self.msg_nums-i-1)
+                if message == -1:
+                    break
+                data = message[5]
+                sms_data = []
+                code = message[0]#编码
+                num = message[1]#总共条数
+                curren_num = message[2]#当前第几条
+                data_len = message[4]
+                sms_data.append(code)#编码 编码相同是同一条短信的内容
+                sms_data.append(num)
+                sms_data.append(curren_num)
+                sms_data.append(data)
+                sms_data.append(data_len)
+                self.send_data.append(sms_data)
+        count = len(self.send_data)
+        for i in range(count):
+            text = self.send_data[i]
+            clog.info("text:{} {} {}\r\n".format(text[0],text[1],text[2]))
+
+            msg_total = "@code:"+str(text[0])+"@totalcodenum:"+str(text[1])+"@currcodeid:"+str(text[2])+"@data:"+str(text[3])
+            self.reply_cmd('17',msg_total)
+
+    # 来电提醒
+    def notifyIncomingcall(self, incomming_numb):
+        self.clear_remain()
+        __head = '0C'
+        __message = str(incomming_numb)
+        self.__Socket_UDP(__head, __message)
+        # if self.__err == 1 or self.__value[2] != 'OK':
+        #     return -1
+        return 0
+
+    # 电话接听消息
+    def notifyConnecteCall(self, phone_numb):
+        self.clear_remain()
+        __head = '0A'
+        __message = str(phone_numb)       
+        self.__Socket_UDP(__head, __message)
+        # if self.__err == 1 or self.__value[2] != 'OK':
+        #     return -1
+        return 0
+
+    # 电话拒接消息
+    def notifyDisconnectCall(self, phone_numb):
+        self.clear_remain()
+        __head = '0B'
+        __message = str(phone_numb)            
+        self.__Socket_UDP(__head, __message)
+        # if self.__err == 1 or self.__value[2] != 'OK':
+        #     return -1
+        return 0
+    
+    def wait_network_ready(self):
+        if(self.__waiting_netstat == 1):
+            return 0
+        self.__waiting_netstat = 1
+        stage, state = checkNet.waitNetworkReady(30)
+        pm.wakelock_unlock(lpm_fd)
+        if stage == 3 and state == 1:
+            clog.info('Network connection successful.')
+            self.set_network_config()
+            self.__net_connected = 1
+            eventMesh.publish("set_network_state",self.__net_connected)
+            self.__waiting_netstat = 0
+            return 0
+        else:
+            clog.info('Network connection failed, stage={}, state={}'.format(stage, state))
+            self.reset_network_config()
+            self.__net_connected = 0
+            eventMesh.publish("set_network_state",self.__net_connected)
+
+            self.__waiting_netstat = 0
+            return -1
+
+    # 查询网卡状态
+    def timesync(self,_timesync):
+        self.clear_remain()
+        message = str(_timesync)
+        self.__Socket_UDP('0D', message)
+        return 0
+    
+    def reply_timesync(self,_timesync):
+        self.clear_remain()
+        message = str(_timesync)
+        self.__Socket_UDP_noreply('0D', message)
+        return 0
+
+    def reply_cmd(self,cmd,_timesync):
+        try :
+            clog.info('reply_cmd 1')
+            self.clear_remain()
+            message = str(_timesync)
+            clog.info('reply_cmd 2')
+            self.__Socket_UDP_noreply(cmd, message)
+        except:
+            clog.info('reply_cmd')
+        return 0
+    
+    def clear_remain(self):
+        # if self.__queue.empty() == False:
+        #     self.__queue.get()
+        self.__err = 0
+        # self.__value = None
+    #添加路由信息
+    def router_add(self, ip='192.168.4.1', mask='255.255.255.0'):
+        self.ip = ip
+        self.mask = mask
+        
+        return slip.router_add(self.ip, self.mask)
+
+    # 获取slip的网络配置
+    def ipconfig(self):
+        return slip.ipconfig()
+
+       # 设置dns服务器
+    def set_dns(self, pri_dns='8.8.8.8', sec_dns='114.114.114.114'):
+        self.pri_dns = pri_dns
+        self.sec_dns = sec_dns
+        return slip.set_dns(self.pri_dns,self.sec_dns)
+    
+       # 设置默认网卡
+    def set_default_NIC(self, ip_str):
+        self.ip_str = ip_str
+        return slip.set_default_netif(self.ip_str)
+    
+    def reset_network_config(self):
+        if (self.__net_connected == 0):
+            clog.info("skip reset_network_config")
+            return 0
+        Info = dataCall.getInfo(1,0)
+        clog.info("Info{}".format(Info))
+        default_NIC_ip = Info[2][2]    # 假设默认网卡ip地址为10.10.1.1,请根据实际情况更改
+        segment_ip = '172.16.4.0'      # 假设ap模式网段范围是[192.168.4.0 ~ 192.168.4.255],请根据实际情况更改
+        mask = '255.255.255.0'          # 假设子网掩码为255.255.255.0,请根据实际情况更改
+        # 配置默认网卡,通过默认网卡进行网络转发
+        cat1service.set_default_NIC(default_NIC_ip)
+        clog.info("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip))
+        #添加路由规则,只有该网段IP才进行转发
+        cat1service.router_add(segment_ip, mask)
+
+        pri_dns = '8.8.8.8'             # 假设DNS首选地址为8.8.8.8,请根据实际情况更改
+        sec_dns = '114.114.114.114'     # 假设DNS备选地址为114.114.114.114,请根据实际情况更改
+        # 配置网卡DNS服务器
+        cat1service.set_dns(pri_dns, sec_dns)
+        # 网卡IP信息查询
+        cat1service.ipconfig()
+
+    def set_network_config(self):
+        
+
+        if (self.__net_connected == 1) :
+            clog.info("skip set_network_config")
+            return 0
+        Info = dataCall.getInfo(1,0)
+        clog.info("Info{}".format(Info))
+        default_NIC_ip = Info[2][2]    # 假设默认网卡ip地址为10.10.1.1,请根据实际情况更改
+        segment_ip = '172.16.1.0'      # 假设ap模式网段范围是[192.168.4.0 ~ 192.168.4.255],请根据实际情况更改
+        mask = '255.255.255.0'          # 假设子网掩码为255.255.255.0,请根据实际情况更改
+        # 配置默认网卡,通过默认网卡进行网络转发
+        cat1service.set_default_NIC(default_NIC_ip)
+        clog.info("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip))
+        #添加路由规则,只有该网段IP才进行转发
+        cat1service.router_add(segment_ip, mask)
+
+        pri_dns = '8.8.8.8'             # 假设DNS首选地址为8.8.8.8,请根据实际情况更改
+        sec_dns = '114.114.114.114'     # 假设DNS备选地址为114.114.114.114,请根据实际情况更改
+        # 配置网卡DNS服务器
+        cat1service.set_dns(pri_dns, sec_dns)
+        # 网卡IP信息查询
+        cat1service.ipconfig()
+        if eventMesh.publish("get_dmp_change_mode") == 0:#入库功能关闭
+            return
+        if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1:#电信入库功能 不使用设置 0 防止两边不同步修改
+            if eventMesh.publish("get_dmp_change_mode") == 1:
+                eventMesh.publish("set_network_state",1)
+                telecomDmpCb.telecom_dmp_power_on_init()
+        if 1: #CHINA_MOBILE_DM_FUN_ENABLE == 1:
+            if eventMesh.publish("get_dmp_change_mode") == 2:
+                eventMesh.publish("set_network_state",1)
+                if self.china_mobile_init == 1:
+                    return
+                self.china_mobile_init = 1
+                #移动入库的初始化
+                chinamobileCb.china_mobile_init()
+        if eventMesh.publish("get_dmp_change_mode") == 3:
+            if self.china_mobile_ai_init == 1:
+                return
+            self.china_mobile_ai_init = 1
+            eventMesh.publish("set_network_state",1)
+            aiRegulation.AIRegulation_init()
+
+    def cat1_reply_iccid_to_ble(self,event,msg):
+        ICCID_DATA = str("ICCID:")+str(msg)
+        self.reply_cmd('11',"{}".format(ICCID_DATA))
+        pass
+    def cat1_reply_timesec_to_ble(self,event,msg):
+       
+        self.reply_cmd('14',"REGIST_TIME:{}".format(msg))
+        pass
+    # 释放slip网卡
+    def stop(self):
+        slip.destroy()
+        return 0
+    
+    def read_dev_ai_id(self):
+        
+        IFEXIST = ql_fs.path_exists("/usr/cm_ai_regulation.json")   #
+        if IFEXIST == True: #文件存在
+            fileSize = ql_fs.path_getsize('usr/cm_ai_regulation.json')
+            if fileSize == 0:
+    
+                print("设备信息配置文件不存在\r\n")
+            else:
+                try:
+                    with open("/usr/cm_ai_regulation.json","r",encoding='utf-8') as fd:
+                        try:
+                            config_data = ujson.load(fd) #转换成json格式
+                            if len(config_data) != 0:
+                                if "deviceId" in config_data:# 
+                                    deviceId = str(config_data["deviceId"]) #设备ID
+                                    self.reply_cmd('1C',"{}".format(deviceId))
+                        except Exception as error:
+                            print("配置文件的内容不是json格式 保存数据的时候格式不对\r\n")
+                except Exception as error:
+                    print("打开配置文件失败\r\n")
+
+    
+
+
+    # 封装tlv数据包
+    def __pack_tlv_format(self, head, content):
+        # self.head = head
+        # self.content = content
+        if len(content) == 0 or len(content) > 9999 or len(head) != 2:
+            clog.error('illegal pack tlv content')
+            return -1
+        len_str ='%04d' % len(content)
+        tlv_pack = CAT1_SERVICE_HEAD+head+len_str+content
+        return tlv_pack
+    # 解码tlv数据包
+    def __unpack_tlv_format(self, msg):
+        clog.info('__unpack_tlv_format  {}\r\n'.format(msg))
+        self.msg = str(msg)[2:]#这是去除head FE
+        tag = self.msg[0:2]
+        length = self.msg[2:6]
+        value = self.msg[6:]
+        len_str ='%04d' % len(value)
+        if len(value) == 0 or len(value) > 9999 or len(tag) != 2 or len_str != self.msg[2:6]:
+            clog.error('__unpack_tlv_format err')
+            return -1
+        clog.info('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value))
+        unpack = (tag,length,value)
+        return unpack
+    # socket通信(UDP)模块
+    def __Socket_UDP(self, head, content):
+         # 0 则  __Socket_UDP_write
+        self.send_data_q.put([head,content])
+    def Socket_SEND_Thread(self):
+        while True:
+            try:
+                clog.info("send====")
+                data=self.send_data_q.get()
+                self.ack_sem=1
+                # # if data[2]:
+                #     self.__Socket_UDP_noreply_write( data[0], data[1])
+                # else :
+                self.__Socket_UDP_write( data[0], data[1])
+                
+                
+                clog.info("Socket_SEND_Thread data:{} {}".format(data[0],data[1]))
+                count=20
+                
+                while count & self.ack_sem :
+                    utime.sleep_ms(1)
+                    count=count-1
+                    # if data[2]:
+                    #     self.__Socket_UDP_noreply_write( data[0], data[1])
+                    # else :
+                    self.__Socket_UDP_write( data[0], data[1])
+                        
+                    clog.info("Socket_SEND_Thread  while data:{} {}".format(data[0],data[1]))
+                
+                if data:
+                        clog.info("data ok!!")
+                else:
+                        clog.error("data error!!")
+            except Exception :
+                clog.error("sned Socket >>>")
+   
+    def __Socket_UDP_write(self, head, content):
+        try:
+            ##self.head = head
+            # self.content = content
+            gpioWakeBT.write(0)
+            utime.sleep_ms(2)
+            gpioWakeBT.write(1)
+            utime.sleep_ms(20)
+            # 消息处理
+            msg = self.__pack_tlv_format(head, content)
+
+            # 向服务端发送消息
+            server_addr = ('172.16.1.5',1000)
+            clog.info("__Socket_UDP send msg {}".format(msg))
+            self.__err = 0
+            self.__sock.sendto(msg,server_addr)
+            clog.info("__Socket_UDP send 2")
+            self.__wait_resp = 1
+            # data = self.__queue.get()
+            self.__wait_resp = 0
+            # return data
+            return 1
+        except Exception as error:
+            clog.error(error)
+        return 0
+   
+    def __Socket_UDP_noreply(self, head, content):
+         # 1 则  __Socket_UDP_noreply_write
+         self.send_data_q.put([head,content])
+         
+    def __Socket_UDP_noreply_write(self, head, content):    
+        # self.head = head
+        # self.content = content
+        gpioWakeBT.write(0)
+        utime.sleep_ms(2)
+        gpioWakeBT.write(1)
+        utime.sleep_ms(20)
+        # 消息处理
+        msg = self.__pack_tlv_format(head, content)
+
+        # 向服务端发送消息
+        server_addr = ('172.16.1.5',1000)
+        
+        clog.info("__Socket_UDP_noreply send msg {}".format(msg))
+        self.__err = 0
+        data_size = self.__sock.sendto(msg,server_addr)
+        clog.info("self.__sock data_size {}".format(data_size))
+        self.__wait_resp = 0
+        return 0
+
+    # socket通信(UDP)模块
+    def __Socket_Thread(self):
+        while True:
+            try:
+                clog.info("recv====")
+                data=self.__sock.recv(1024)
+                clog.info("data:{}".format(data))
+                if data:
+                    value = self.__unpack_tlv_format(data.decode())
+                    if value != -1:
+                        clog.info('mode: {0}, recv {1} bytes, Data: {2}'.format (value[0],len(data), value[2]))
+                        if value[1] == 'FF':
+                            self.btmcu_cmd_handler(value[0],value[2])
+                        else:
+                            # self.__value = value
+                            # self.__queue.put('1')
+                            self.btmcu_cmd_handler(value[0],value[2])
+                        clog.info("End else Thread")
+                    else:
+                        clog.error("data error!!")
+            except Exception as recverr:
+                clog.error("recverr:{}\r\n".format(recverr))
+                if "110" in str(recverr):
+                    self.__err = 1
+                    # if self.__wait_resp == 1:
+                    #     self.__queue.put('0')
+                else:
+                    utime.sleep(1)
+                    self.__sock = self.__socket_reinit()
+                
+            
+
+        clog.info("End Socket Thread")
+
+
+
+
+# UDP_CMD_GET_CAT1VER = '0',  // 获取 Cat1 版本号
+# UDP_CMD_DIAL_NUMB = '1',               //  拨打电话
+# UDP_CMD_HUNGUP = '2',                 //  挂断电话
+# UDP_CMD_ANSWER = '3',            //  接听电话
+# UDP_CMD_CAT1_OTA_UPDATE = '4',       // 触发Cat1 OTA升级,mcu提供url
+# UDP_CMD_SEND_SMS = '5',               // 发送SMS短信,mcu提供电话号及短信内容
+# UDP_CMD_GET_TIME = '6',               // 获取Cat1 时间 ,YYYYMMDD HHmmss zone
+# UDP_CMD_GET_NETWORKSTAT = '7',               //获取Cat1 信号信息,VOLTE信息,信号强度,SIM卡状态
+# 下文进行系统配置
+clog.info("Cat1Service start")
+
+cat1service = Cat1Service()
+
+#send_data_q = Queue(100)
+
+#voice call callback function
+def voice_callback(args):
+    if args[0] == 10:
+        if eventMesh.publish("get_volte_switch") == 0: #关闭VOLTE功能
+            clog.info('voicecall auto end:')
+            # voiceCall.callEnd()
+        else:     
+            # gpioWakeBT.write(1)
+            cat1service.notifyIncomingcall(args[6])
+    elif args[0] == 11:
+        if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能
+            clog.info('voicecall connected, PhoneNO: \n'.format(args[6]))
+            cat1service.notifyConnecteCall(args[6])
+    elif args[0] == 12:
+        clog.info('voicecall disconnect')
+        if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能
+            clog.info('voicecall disconnected, PhoneNO: \n'.format(args[6]))
+            cat1service.notifyDisconnectCall(args[6])
+    elif args[0] == 13:
+        clog.info('voicecall is waiting, PhoneNO: \n'.format(args[6]))
+    elif args[0] == 14:
+        clog.info('voicecall dialing, PhoneNO: \n'.format(args[6]))
+    elif args[0] == 15:
+        clog.info('voicecall alerting, PhoneNO: \n'.format(args[6]))
+    elif args[0] == 16:
+        clog.info('voicecall holding, PhoneNO: \n'.format(args[6]))
+    else:
+        clog.info('voice_callback , args[0]: \n'.format(args[6]))
+
+#电话消息反馈
+# voiceCall.setCallback(voice_callback)
+
+
+def checknet_cb(arg):
+    clog.info("start checktime!!")
+    # if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1:#这是手表每30s检查一次
+        # if eventMesh.publish("get_dmp_change_mode") == 1:
+            # telecomDmpCb.telecom_dmp_power_on_count()
+
+    _thread.start_new_thread(cat1service.wait_network_ready, ())
+    # time=utime.localtime()
+    # zone=utime.getTimeZone()
+    #(2024, 3, 2, 18, 31, 32, 5, 62),8
+    # cat1service.timesync("{0},{1}".format(time,zone))
+# _thread.start_new_thread(cat1service.wait_network_ready, ())
+timer = osTimer()
+# checknet_cb(())
+timer.start(30000,1,checknet_cb)  
+
+def bootupmsg_cb(arg):
+    cat1service.bootup_msg_to_bt()
+    
+
+delaybootupmsg_timer = osTimer()
+delaybootupmsg_timer.start(1000,0,bootupmsg_cb)
+
+# def checkpin_cb(arg):
+#     clog.info("recvDataPin={}".format(recvDataPin.read()))
+
+# timerCheckRevPin = osTimer()
+# timerCheckRevPin.start(1000,1,checkpin_cb)  
+
+
+
+    
+
+
+# while True:
+#     utime.sleep(5)
+
+
+# uping.ping("172.16.1.5")
+   # 获取网卡当前工作状态
+
+# gpioWakeBT.write(1)
+# utime.sleep(1)
+
+# timesync = net.nitzTime()
+# cat1service.timesync(timesync)
+
+
+#url = "http://zzhc.vnet.cn:9998/"
+
+
diff --git a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/cat1Service.py b/code/sdk/files/leiniao/fs/user/system/cat1otaudp/cat1Service.py
deleted file mode 100644 (file)
index f0d46dc..0000000
+++ /dev/null
@@ -1,682 +0,0 @@
-import usocket
-import log
-import utime
-import slip
-import audio
-from machine import UART
-import _thread
-from queue import Queue
-from machine import Pin
-from machine import ExtInt
-import dataCall
-import voiceCall
-import net
-import osTimer
-import sim
-import modem
-import utime
-import checkNet
-import atcmd
-import ql_fs
-import pm
-import sms
-
-from usr.EventMesh import eventMesh
-
-log.basicConfig(level=log.INFO)
-clog = log.getLogger("cat1")
-
-CAT1_SERVICE_HEAD = 'FE' 
-PROJECT_NAME = "Cat1SlipUDPService"
-PROJECT_VERSION = "PY_SRV_V17"
-CONFIG_JSON="/usr/system_config.json"
-CURRENT_APP_TYPE="pysrv"
-
-voiceCall.setVolume(10)
-lpm_fd = pm.create_wakelock("system_lock", len("system_lock"))
-pm.wakelock_lock(lpm_fd)
-telecomTimerCount = 0
-def get_versionkeyname_by_py(app_type):
-    return str("{}version".format(app_type))
-
-def get_default_versionvalue_by_py(app_type):
-    if (app_type == "pymain"):
-        return "PY_MAIN_V2"
-    elif (app_type == "pyota"):
-        return  "PY_OTA_V14"
-    elif (app_type == "pysrv"):
-        return  "PY_SRV_V16"
-    
-if not ql_fs.path_exists(CONFIG_JSON):
-    data = {str(get_versionkeyname_by_py(CURRENT_APP_TYPE)):get_default_versionvalue_by_py(CURRENT_APP_TYPE)}
-    ql_fs.touch(CONFIG_JSON,data)
-
-def set_version_to_json_config(app_type,keyvalue):
-    try :
-        config_data = ql_fs.read_json(CONFIG_JSON)
-        config_data.update( {str(get_versionkeyname_by_py(app_type)):keyvalue})
-        ql_fs.touch(CONFIG_JSON, config_data)
-    except Exception as e:
-        clog.error("set_version_to_json_config")
-
-def get_version_from_json_config(app_type):
-    config_data = ql_fs.read_json(CONFIG_JSON)
-    keyvalue = config_data.get( get_versionkeyname_by_py(app_type),get_default_versionvalue_by_py(app_type))
-    return keyvalue
-
-set_version_to_json_config(CURRENT_APP_TYPE,PROJECT_VERSION)
-    
-
-audio.set_qdai_cfg(1,0,0,1,0,0,1,1)
-def ExtIntfun(args):
-        if args[1] == 0:
-            pm.wakelock_lock(lpm_fd)
-        elif args[1] == 1:
-            pm.wakelock_unlock(lpm_fd)
-extint = ExtInt(ExtInt.GPIO22, ExtInt.IRQ_RISING_FALLING, ExtInt.PULL_DISABLE, ExtIntfun)
-extint.enable()
-
-gpioWakeBT = Pin(Pin.GPIO21, Pin.OUT, Pin.PULL_DISABLE, 1)
-gpioWakeBT.set_dir(Pin.OUT)
-gpioWakeBT.write(0)
-
-UDP_CMD_GET_CAT1VER = '0'
-UDP_CMD_DIAL_NUMB = '1'
-UDP_CMD_HUNGUP = '2'
-UDP_CMD_ANSWER = '3'
-UDP_CMD_CAT1_OTA_UPDATE = '4'
-UDP_CMD_SEND_SMS = '5'
-UDP_CMD_GET_TIME = '6'      
-UDP_CMD_GET_RECV_NETWORKSTAT = '7'
-UDP_MSG_SMS = '8'
-UDP_CMD_ATCMD = '9'   
-UDP_MSG_CALL_CONNECTED = 'A'       
-UDP_MSG_CALL_DISCONNECTED = 'B'    
-UDP_MSG_COMMING_CALL = 'C'     
-UDP_MSG_REPLY = 'F'
-
-class Cat1Service:
-    AP = 0
-    STA = 1
-    def __init__(self, uart=UART.UART4, mode=AP):
-        self.__uart = uart
-        self.__mode = mode
-        self.__message = ''
-        self.__err = 0
-        self.__net_connected = 0
-        self.__wait_resp = 0
-        self.__waiting_netstat = 0
-        slip.destroy()
-        ret = slip.construct(self.__uart, self.__mode, 0)
-        if ret != 0:
-            return None
-        self.__sock = self.__socket_init()
-        self.__threadid = _thread.start_new_thread(self.__Socket_Thread, ())
-        self.telecom_init_flag = 0
-        self.telecomTimer = osTimer()
-        eventMesh.subscribe("cat1_reply_iccid_to_ble",self.cat1_reply_iccid_to_ble)
-        eventMesh.subscribe("cat1_reply_timesec_to_ble",self.cat1_reply_timesec_to_ble)
-        self.iccid_data = ""
-        self.software_version = ""
-        self.deletSmsTimer = osTimer()
-        self.volte_switch = 1
-        eventMesh.subscribe("set_dmp_change_mode",self.set_dmp_change_mode)
-        eventMesh.subscribe("get_dmp_change_mode",self.get_dmp_change_mode)
-        eventMesh.subscribe("delete_sms_event",self.delete_sms_event)
-        eventMesh.subscribe("remove_all_sms_cb", self.remove_all_sms_cb)
-        eventMesh.subscribe("send_sms_max_to_Ble",self.send_sms_max_to_Ble)
-        eventMesh.subscribe("get_all_sms_data",self.get_all_sms_data)
-        eventMesh.subscribe("send_singal_data_toBle",self.send_singal_data_toBle)
-        eventMesh.subscribe("delete_sms_single_data",self.delete_sms_single_data)
-        eventMesh.subscribe("get_factory_status",self.get_factory_status)
-        eventMesh.subscribe("set_factory_status",self.set_factory_status)
-        eventMesh.subscribe("send_dmp_cm_address_toBLE",self.send_dmp_cm_address_toBLE)
-        eventMesh.subscribe("set_volte_switch",self.set_volte_switch)
-        eventMesh.subscribe("get_volte_switch",self.get_volte_switch)
-        eventMesh.publish("delete_sms_event")
-        self.telecom_dmp_switch = 0
-        self.send_data = []
-        self.code_old = 0
-        self.code_old_num = 1
-        self.tmp_data = []
-        self.total_num = 0
-        self.msg_nums = 0
-        self.msg_nums_old = 0
-        self.china_mobile_init = 0
-        self.factory_status = 0
-        self.send_data_q = Queue(100)
-        self.ack_sem=0
-        _thread.start_new_thread(self.Socket_SEND_Thread,())
-        return None
-
-    def __socket_init(self):
-        sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.TCP_CUSTOMIZE_PORT)
-        sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
-        bind_addr = ('172.16.1.2', 5000)
-        sock.bind(bind_addr)
-        sock.settimeout(None)
-        return sock
-
-    def __socket_reinit(self):
-        return self.__socket_init()
-    
-    def bootup_msg_to_bt(self):
-        modem_ver = modem.getDevFwVersion() 
-        self.reply_cmd('0F',"BOOTUP@pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
-        self.reply_cmd('0F',"VOLUME:{}".format(voiceCall.getVolume()))
-
-    def btmcu_cmd_handler(self,cmd,parm):
-        if cmd == "00":
-            modem_ver = modem.getDevFwVersion() 
-            self.reply_cmd('00',"pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
-        elif cmd == "01":
-            if eventMesh.publish("get_volte_switch") == 1:
-                ret = voiceCall.callStart(str(parm))
-                if ret != 0:
-                    self.reply_cmd('0F',"callcmd_fail")
-                else:
-                    self.reply_cmd('0F',"callcmd_success")
-            else:
-                self.reply_cmd('0F',"callcmd_fail")
-        elif cmd == "02":
-            ret = voiceCall.callEnd()
-            if ret != 0:
-                ret = voiceCall.callEnd()
-            if ret != 0:
-                self.reply_cmd('0F',"callend_fail")
-            else:
-                self.reply_cmd('0F',"callend_success")
-        elif cmd == "03":
-            ret = voiceCall.callAnswer()
-            if ret != 0:
-                ret = voiceCall.callAnswer()
-            if ret != 0:
-                self.reply_cmd('0F',"callanswer_fail")
-            else:
-                self.reply_cmd('0F',"callanswer_success")
-        elif cmd == "06":
-            time=utime.localtime()
-            zone=utime.getTimeZone()
-            self.reply_cmd('06',"{0}@{1}".format(time,zone))
-        elif cmd == "07":
-            simstat = sim.getStatus()
-            imei = modem.getDevImei()
-            netstat = "0,10,0,10"
-            netstat_ = net.getState()
-            if netstat_ != -1 :
-                netstat = "{},{},{},{}".format(netstat_[0][0],netstat_[0][3],netstat_[1][0],netstat_[1][3])
-            operator =  net.operatorName()
-            signal = net.csqQueryPoll()
-            self.reply_cmd('07',"imei:{0}@sim:{1}@oper:{2}@signal:{3}@net:{4}".format(imei,simstat,operator,signal,netstat))
-        elif cmd == "09":
-            resp=bytearray(50)
-            ret=atcmd.sendSync("{}\r\n".format(parm),resp,'',10)
-            if ret == 0:
-                self.reply_cmd('09',"{}".format(resp.decode()))
-            else:
-                self.reply_cmd('09',"{}".format("at error"))
-        
-        elif cmd == "10" or cmd == "12" or cmd == "14":
-            if 1:
-                if eventMesh.publish("get_dmp_change_mode") == 1:
-                    self.telecom_recv_cmd(cmd,parm)
-            else:
-                pass
-
-            if 1:
-                if eventMesh.publish("get_dmp_change_mode") > 1:
-                    self.china_mobile_recv_cmd(cmd,parm)
-            else:
-                pass
-            pass
-        elif cmd == "13":
-            on = int(parm)
-            eventMesh.publish("set_dmp_change_mode",on)
-        elif cmd == "16":
-            if 1:
-                if eventMesh.publish("get_dmp_change_mode") > 1:
-                    self.china_mobile_recv_cmd(cmd,parm)
-            else:
-                pass
-        elif cmd == "17":
-            eventMesh.publish("set_factory_status",int(parm))
-        elif cmd == "18":
-            eventMesh.publish("set_dmp_cm_address",str(parm))
-        elif cmd == "19":
-            voiceCall.startDtmf(str(parm),100)
-        elif cmd == "1A":
-            eventMesh.publish("set_volte_switch",int(parm))
-        elif cmd == "AC":
-            if self.ack_sem==1:
-                self.ack_sem=0
-
-    def telecom_recv_cmd(self,cmd,parm): 
-        if cmd == "10":
-            self.software_version = str(parm)
-            eventMesh.publish("set_dev_version",self.software_version)
-        elif cmd == "12":
-            pass
-        elif cmd == "14":#
-            pass    
-        pass
-
-    def set_volte_switch(self,event,msg):
-        self.volte_switch = int(msg)
-        
-    def get_volte_switch(self,event,msg):
-        return self.volte_switch
-
-    def china_mobile_recv_cmd(self,cmd,parm):
-        if cmd == "10":
-            self.software_version = str(parm)
-            eventMesh.publish("set_dev_version",self.software_version)
-        elif cmd == "16":
-            eventMesh.publish("set_dev_mac",str(parm))        
-        pass
-    def get_factory_status(self,event,msg):
-        return self.factory_status
-    def set_factory_status(self,event,msg):
-        self.factory_status = int(msg)
-        if self.factory_status == 0: #只有为的时候才设置进去 1不再设置
-            self.reply_cmd('17',"{}".format(1))
-
-    def send_dmp_cm_address_toBLE(self,event,msg):
-        buf_tmp = "address:"+str(msg)
-        self.reply_cmd('18',"{}".format(buf_tmp))
-        
-    def set_dmp_change_mode(self,event,msg):
-        self.telecom_dmp_switch = msg
-    def delete_sms_single_data(self,event,msg): #删除单条信息
-        sms.deleteMsg(int(msg))
-
-    def get_dmp_change_mode(self,event,msg):
-        return self.telecom_dmp_switch
-    def delete_sms_event(self,event,msg):
-        self.deletSmsTimer.start(2*1000,0,self.delete_sms_cb)
-    def delete_sms_cb(self,*argc):
-        eventMesh.publish_async("remove_all_sms_cb","",1*1024)
-    def remove_all_sms_cb(self, event, msg):
-        msg_nums = sms.getMsgNums()
-        if msg_nums == -1:
-            msg_nums = 0
-        sms_data = sms.getSaveLoc()
-        if sms_data == -1:
-            return
-        sms_max = sms_data[0][2] 
-        if sms_max >= msg_nums and sms_max > 0:
-            sms.deleteMsg(1,4)
-
-    def send_singal_data_toBle(self,event,msg):
-        msg_nums = sms.getMsgNums()
-        if msg_nums == -1:
-            msg_nums = 0
-        sms_data = sms.getSaveLoc()
-        if sms_data == -1:
-            return
-        sms_max = sms_data[0][2]
-        message=self.sms_get_message_info(int(msg))
-        if message == -1:
-            return
-        message_pdu = sms.decodePdu(message[5],20)
-        if message_pdu != -1:
-            message_ref = message[0]
-            message_total_num = message[1]
-            message_seq = message[2]
-            data = message[5]
-            data_len = len(data)
-            msg_total = "ref:"+str(message_ref)+"@total_num:"+str(message_total_num)+"@seq:"+str(message_seq)+"@data:"+str(message[5])
-            self.reply_cmd('15',msg_total)
-        
-        eventMesh.publish("delete_sms_single_data",int(msg))
-
-    def sms_deal_phone_number(self,args):
-        data=enumerate(args)
-        data_str1=""
-        data_str2=""
-        data_str3=""
-        for index,value in data:
-            if index % 2 == 0:
-                data_str1=data_str1+value
-            else:
-                data_str2=data_str2+value
-        for i in range(0,len(data_str1)):
-            data_str3=data_str3+data_str2[i]
-            data_str3=data_str3+data_str1[i]
-        return data_str3
-    def sms_get_message_info(self,index):
-        message0=sms.searchPduMsg(index)  
-        if message0 == -1:
-            return -1
-        
-        sca_num  = int(message0[0:2],16) - 1
-        data_len = 2
-        addr_type= message0[data_len:data_len+1*2]
-        data_len = data_len+1*2
-        
-        sca      = message0[data_len:data_len+sca_num*2]
-        sca = self.sms_deal_phone_number(sca)
-        data_len = data_len+sca_num*2
-
-        pdu_tye   = int(message0[data_len:data_len+1*2],16)
-        data_len = data_len+1*2
-
-        oa_num   = int(message0[data_len:data_len+1*2],16)
-        data_len = data_len+1*2
-        oa_addr_type   = message0[data_len:data_len+1*2]
-        data_len = data_len+1*2
-
-        if oa_num % 2 == 1:
-             oa_num_t   = int((oa_num + 1)/2)
-        else:
-             oa_num_t   = int((oa_num )/2)
-
-        oa       = message0[data_len:data_len+oa_num_t*2]
-        oa       = self.sms_deal_phone_number(oa)
-        data_len = data_len+oa_num_t*2
-        pid      = message0[data_len:data_len+1*2]
-        
-        data_len = data_len+1*2
-        dcs      = message0[data_len:data_len+1*2]
-        data_len = data_len+1*2
-        scts     = message0[data_len:data_len+7*2] 
-        data_len = data_len+7*2
-        sub_message_len = int(message0[data_len:data_len+1*2],16)
-        data_len = data_len+1*2
-        sub_message_head = message0[data_len:data_len+6*2]
-        data_len = data_len+6*2
-        sub_message_data = message0[data_len:data_len+sub_message_len*2]
-
-        if ((pdu_tye & 0x40 ) >> 6) == 1:
-            message_ref = int(sub_message_head[6:8],16)
-            message_total_num = int(sub_message_head[8:10],16)
-            message_seq = int(sub_message_head[10:12],16)
-            return [message_ref,message_total_num,message_seq,pdu_tye,sub_message_len,message0]
-        else:
-            return [0,1,1,pdu_tye,sub_message_len,message0]
-
-
-
-    def send_sms_max_to_Ble(self,event,msg):
-        msg_nums = sms.getMsgNums()
-        if msg_nums == -1:
-            msg_nums = 0
-        sms_data = sms.getSaveLoc()
-        if sms_data != -1:
-            sms_max = sms_data[0][2]
-            self.reply_cmd('15',"@sms_max:"+str(sms_max)+"@current_num:"+str(msg_nums))
-        pass
-    
-    def get_all_sms_data(self,event,msg):
-        msg_total = ""
-        SMS_lis={}
-        SMS_lis_count = 0
-        sms_data = sms.getSaveLoc()
-        if sms_data == -1:
-            return
-        sms_max = sms_data[0][2]
-        self.msg_nums = sms.getMsgNums() 
-        if self.msg_nums_old != self.msg_nums:
-            self.send_data = []
-        self.msg_nums_old = self.msg_nums
-        if self.send_data == [] :
-            for i in range(self.msg_nums):
-                phonenum = ""
-                data =""
-                time = ""
-                data_len = 0
-                message=self.sms_get_message_info(self.msg_nums-i-1)
-                if message == -1:
-                    break
-                data = message[5]
-                sms_data = []
-                code = message[0]
-                num = message[1]
-                curren_num = message[2]
-                data_len = message[4]
-                sms_data.append(code)
-                sms_data.append(num)
-                sms_data.append(curren_num)
-                sms_data.append(data)
-                sms_data.append(data_len)
-                self.send_data.append(sms_data)
-        count = len(self.send_data)
-        for i in range(count):
-            text = self.send_data[i]
-            msg_total = "@code:"+str(text[0])+"@totalcodenum:"+str(text[1])+"@currcodeid:"+str(text[2])+"@data:"+str(text[3])
-            self.reply_cmd('17',msg_total)
-
-    def notifyIncomingcall(self, incomming_numb):
-        self.clear_remain()
-        __head = '0C'
-        __message = str(incomming_numb)
-        self.__Socket_UDP(__head, __message)
-        return 0
-
-    def notifyConnecteCall(self, phone_numb):
-        self.clear_remain()
-        __head = '0A'
-        __message = str(phone_numb)       
-        self.__Socket_UDP(__head, __message)
-        return 0
-
-    def notifyDisconnectCall(self, phone_numb):
-        self.clear_remain()
-        __head = '0B'
-        __message = str(phone_numb)            
-        self.__Socket_UDP(__head, __message)
-        return 0
-    
-    def wait_network_ready(self):
-        if(self.__waiting_netstat == 1):
-            return 0
-        self.__waiting_netstat = 1
-        stage, state = checkNet.waitNetworkReady(30)
-        pm.wakelock_unlock(lpm_fd)
-        if stage == 3 and state == 1:
-            self.set_network_config()
-            self.__net_connected = 1
-            eventMesh.publish("set_network_state",self.__net_connected)
-            self.__waiting_netstat = 0
-            return 0
-        else:
-            self.reset_network_config()
-            self.__net_connected = 0
-            eventMesh.publish("set_network_state",self.__net_connected)
-            self.__waiting_netstat = 0
-            return -1
-
-    def timesync(self,_timesync):
-        self.clear_remain()
-        message = str(_timesync)
-        self.__Socket_UDP('0D', message)
-        return 0
-    
-    def reply_timesync(self,_timesync):
-        self.clear_remain()
-        message = str(_timesync)
-        self.__Socket_UDP_noreply('0D', message)
-        return 0
-
-    def reply_cmd(self,cmd,_timesync):
-        try :
-            self.clear_remain()
-            message = str(_timesync)
-            self.__Socket_UDP_noreply(cmd, message)
-        except:
-            clog.info('reply_cmd')
-        return 0
-    
-    def clear_remain(self):
-        self.__err = 0
-    def router_add(self, ip='192.168.4.1', mask='255.255.255.0'):
-        self.ip = ip
-        self.mask = mask
-        return slip.router_add(self.ip, self.mask)
-    
-    def ipconfig(self):
-        return slip.ipconfig()
-
-    def set_dns(self, pri_dns='8.8.8.8', sec_dns='114.114.114.114'):
-        self.pri_dns = pri_dns
-        self.sec_dns = sec_dns
-        return slip.set_dns(self.pri_dns,self.sec_dns)
-    
-    def set_default_NIC(self, ip_str):
-        self.ip_str = ip_str
-        return slip.set_default_netif(self.ip_str)
-    
-    def reset_network_config(self):
-        if (self.__net_connected == 0):
-            return 0
-        Info = dataCall.getInfo(1,0)
-        default_NIC_ip = Info[2][2]    
-        segment_ip = '172.16.4.0'     
-        mask = '255.255.255.0'        
-        cat1service.set_default_NIC(default_NIC_ip)
-        cat1service.router_add(segment_ip, mask)
-
-        pri_dns = '8.8.8.8'          
-        sec_dns = '114.114.114.114'     
-        cat1service.set_dns(pri_dns, sec_dns)
-        cat1service.ipconfig()
-
-    def set_network_config(self):
-        if (self.__net_connected == 1) :
-            return 0
-        Info = dataCall.getInfo(1,0)
-        default_NIC_ip = Info[2][2]  
-        segment_ip = '172.16.1.0'      
-        mask = '255.255.255.0'       
-        cat1service.set_default_NIC(default_NIC_ip)
-        cat1service.router_add(segment_ip, mask)
-
-        pri_dns = '8.8.8.8'             
-        sec_dns = '114.114.114.114'  
-        cat1service.set_dns(pri_dns, sec_dns)
-        cat1service.ipconfig()
-        if eventMesh.publish("get_dmp_change_mode") == 0:
-            return
-        if 1:
-            if eventMesh.publish("get_dmp_change_mode") == 1:
-                eventMesh.publish("set_network_state",1)
-        if 1: 
-            if eventMesh.publish("get_dmp_change_mode") > 1:
-                eventMesh.publish("set_network_state",1)
-                if self.china_mobile_init == 1:
-                    return
-                self.china_mobile_init = 1
-
-    def cat1_reply_iccid_to_ble(self,event,msg):
-        ICCID_DATA = str("ICCID:")+str(msg)
-        self.reply_cmd('11',"{}".format(ICCID_DATA))
-        pass
-    def cat1_reply_timesec_to_ble(self,event,msg):
-       
-        self.reply_cmd('14',"REGIST_TIME:{}".format(msg))
-        pass
-
-    def stop(self):
-        slip.destroy()
-        return 0
-
-    def __pack_tlv_format(self, head, content):
-        if len(content) == 0 or len(content) > 9999 or len(head) != 2:
-            return -1
-        len_str ='%04d' % len(content)
-        tlv_pack = CAT1_SERVICE_HEAD+head+len_str+content
-        return tlv_pack
-    
-    def __unpack_tlv_format(self, msg):
-        self.msg = str(msg)[2:]
-        tag = self.msg[0:2]
-        length = self.msg[2:6]
-        value = self.msg[6:]
-        len_str ='%04d' % len(value)
-        if len(value) == 0 or len(value) > 9999 or len(tag) != 2 or len_str != self.msg[2:6]:
-            return -1
-        unpack = (tag,length,value)
-        return unpack
-    def __Socket_UDP(self, head, content):
-        self.send_data_q.put([head,content])
-    def Socket_SEND_Thread(self):
-        while True:
-            try:
-                data=self.send_data_q.get()
-                self.ack_sem=1
-                self.__Socket_UDP_write( data[0], data[1])
-                count=20
-                
-                while count & self.ack_sem :
-                    utime.sleep_ms(1)
-                    count=count-1
-                    self.__Socket_UDP_write( data[0], data[1])
-            except Exception :
-                clog.error("sned Socket >>>")
-   
-    def __Socket_UDP_write(self, head, content):
-        try:
-            gpioWakeBT.write(1)
-            utime.sleep_ms(2)
-            gpioWakeBT.write(0)
-            utime.sleep_ms(20)
-            msg = self.__pack_tlv_format(head, content)
-            server_addr = ('172.16.1.5',1000)
-            self.__err = 0
-            self.__sock.sendto(msg,server_addr)
-            self.__wait_resp = 1
-            self.__wait_resp = 0
-            return 1
-        except Exception as error:
-            clog.error(error)
-        return 0
-   
-    def __Socket_UDP_noreply(self, head, content):
-         self.send_data_q.put([head,content])
-
-    def __Socket_Thread(self):
-        while True:
-            try:
-                data=self.__sock.recv(1024)
-                if data:
-                    value = self.__unpack_tlv_format(data.decode())
-                    if value != -1:
-                        if value[1] == 'FF':
-                            self.btmcu_cmd_handler(value[0],value[2])
-                        else:
-                            self.btmcu_cmd_handler(value[0],value[2])
-                    else:
-                        clog.error("data error!!")
-            except Exception as recverr:
-                if "110" in str(recverr):
-                    self.__err = 1
-                else:
-                    utime.sleep(1)
-                    self.__sock = self.__socket_reinit()         
-cat1service = Cat1Service()
-
-def voice_callback(args):
-    if args[0] == 10:
-        if eventMesh.publish("get_volte_switch") == 0: #关闭VOLTE功能
-            voiceCall.callEnd()
-        else:     
-            cat1service.notifyIncomingcall(args[6])
-    elif args[0] == 11:
-        if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能
-            cat1service.notifyConnecteCall(args[6])
-    elif args[0] == 12:
-        if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能
-            cat1service.notifyDisconnectCall(args[6])
-voiceCall.setCallback(voice_callback)
-def checknet_cb(arg):
-    _thread.start_new_thread(cat1service.wait_network_ready, ())
-timer = osTimer()
-timer.start(30000,1,checknet_cb)  
-
-def bootupmsg_cb(arg):
-    cat1service.bootup_msg_to_bt()
-    
-delaybootupmsg_timer = osTimer()
-delaybootupmsg_timer.start(1000,0,bootupmsg_cb)
-
-
-
diff --git a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/china_mobile_dmp.py b/code/sdk/files/leiniao/fs/user/system/cat1otaudp/china_mobile_dmp.py
deleted file mode 100644 (file)
index 632476e..0000000
+++ /dev/null
@@ -1,17 +0,0 @@
-import log
-
-# 设置日志输出级别
-log.basicConfig(level=log.INFO)
-fota_log = log.getLogger("china_mobile")
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/is_need_updata.txt b/code/sdk/files/leiniao/fs/user/system/cat1otaudp/is_need_updata.txt
deleted file mode 100644 (file)
index e69de29..0000000
diff --git a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/main.py b/code/sdk/files/leiniao/fs/user/system/cat1otaudp/main.py
deleted file mode 100644 (file)
index ab14d8b..0000000
+++ /dev/null
@@ -1,27 +0,0 @@
-import example
-import log
-from machine import UART
-
-# 设置日志输出级别
-log.basicConfig(level=log.INFO)
-# 设置输出到debug口
-uart = UART(UART.UART0, 115200, 8, 0, 1, 0)
-log.set_output(uart)
-clog = log.getLogger("cat1")
-
-main_flag = 1
-
-
-try:
-    example.exec('/usr/main_init.py')
-    clog.info("启动main_init成功!!!!!\r\n")
-except Exception as e:
-    main_flag = 0
-    clog.error("启动失败!!!!!\r\n".format(e))
-
-try:
-    example.exec('/usr/tcpserver.py')
-    clog.info("启动tcpserver成功!!!!!\r\n")
-except Exception as e:
-    clog.error("启动失败!!!!!\r\n".format(e))
-
diff --git a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/tcpserver.py b/code/sdk/files/leiniao/fs/user/system/cat1otaudp/tcpserver.py
deleted file mode 100644 (file)
index afe23b2..0000000
+++ /dev/null
@@ -1,602 +0,0 @@
-from misc import Power
-import usocket
-import log
-import utime
-from machine import UART
-import _thread
-from queue import Queue
-from machine import Pin
-from machine import ExtInt
-import osTimer
-import utime
-import ql_fs
-import binascii
-import ujson
-import uos
-
-
-log.basicConfig(level=log.INFO)
-clog = log.getLogger("cat1")
-
-USR_FILE_PATH = "/usr" #
-BAK_FILE_PATH = "{}/TmpPyFile".format(USR_FILE_PATH)
-BAK_FILE_TMP = "_bak"
-CAT1_SERVICE_HEAD = "FE"
-CAT1_FILE_DATA_HEAD = "FF"
-CAT1_REPLAY_STATE="00"
-CAT1_CREAT_DIR_FAILE= "01"
-CAT1_CREAT_DIR_OK= "02"
-CAT1_NO_REPLAY_OTA_OK= "03"
-CAT1_WRITE_FILE_SUCC= "04"
-CAT1_WRITE_FILE_ERROR = "05"
-CAT1_CRC_ERROR = "06"
-CAT1_SEND_HEAD_ERR = "07"
-CAT1_OTA_TIMEOUT_BLE_NO_REPLAY = "08"
-CAT1_CREAT_FILE_ERROR = "09"
-CAT1_CREAT_FILE_SUCC = "0A"
-CAT1_ALLPY_FILE_TRANSFER_END = "0B"
-CAT1_REPLAY_OTA_SUCC = "0C"
-CAT1_REPLAY_OTA_FALIE = "0D"
-CAT1_REPLAY_FILE_SIZE_OK = "0E"
-CAT1_REPLAY_FILE_SIZE_ERR = "0F"
-CAT1_REPLAY_OTA_END_FAILE = "10" 
-CAT1_NEED_UPDATE_OTA = "11"
-CAT1_TCP_STOP_OTA = 0 
-CAT1_TCP_START_OTA = 1 
-CAT1_TCP_START_SEND_SINGLE_FILE_INFO= 2
-CAT1_TCP_START_SEND_FILE_DATA= 3 
-CAT1_TCP_START_OTA_FAILE = 4 
-CAT1_TCP_START_OTA_SUCC = 5
-CAT1_TCP_START_SEND_ALLFILE_FINESH = 6 
-CAT1_TCP_SEND_SINGLE_FINESH = 7 
-CAT1_TCP_START_ERROR_INFO = 255 
-
-gpioWakeBT = Pin(Pin.GPIO21, Pin.OUT, Pin.PULL_DISABLE, 1)
-gpioWakeBT.set_dir(Pin.OUT)
-gpioWakeBT.write(0)
-FILE_TRANSFER_TIMEOUT=60  
-class TcpServiceInit:
-    AP = 0  
-    STA = 1
-
-    def __init__(self, uart=UART.UART4, mode=AP):
-        self.__uart = uart
-        self.__mode = mode
-        self.Cat1FileState = 0
-        self.Cat1FileReplayBle = 0
-        self.Cat1TimeCount = 0
-        self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT
-        self.Cat1FileTransTimer = osTimer()
-        self.Cat1OtaTimeOut = osTimer()
-        self.crc_err = 0
-        self.allPyRecvFlag = 0
-        self.ota_state =0
-        self.ota_bstate =0
-        self.fileNameTmp = ""
-        self.fileNameList = []
-        self.fileSizeList = []
-        self.fileSize = 0
-        self.updateTimer = osTimer()
-        self.updateTimerCount = 0
-        self.updateTimerFlag = 0
-        self.sock = None
-        self.bakFlag = "0"
-        self.conn= None
-        self.__sock_file = None
-        self.__sock_file = self.__socket_file_init()
-        self.__thread_file = _thread.start_new_thread(self.__Socket_File_Thread, ())
-        self.conn_thread=_thread.start_new_thread(self._client_conn_proc, ())
-
-    def __pack_tlv_format(self, head, content):
-        head1 = head
-        content1 = content
-        if len(content1) == 0 or len(content1) > 9999 or len(head1) != 2:
-            return -1
-        len_str ='%04d' % len(content1)
-        tlv_pack = CAT1_SERVICE_HEAD+head1+len_str+content1
-        return tlv_pack
-
-    def __unpack_tlv_format(self, msg):
-        msg_tmp = str(msg)[2:]
-        tag = msg_tmp[0:2]
-        length = msg_tmp[2:6]
-        value = msg_tmp[6:]
-        len_str ='%04d' % len(value)
-        if len(value) == 0 or len(value) > 9999 or len(tag) != 2 or len_str != msg_tmp[2:6]:
-            return -1
-        unpack = (tag,length,value)
-        return unpack
-
-    def __socket_file_init(self): 
-        self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM, usocket.IPPROTO_TCP_SER)
-        self.sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
-        bind_addr = ('172.16.1.2', 5001) 
-        self.sock.bind(bind_addr)
-        self.sock.listen(10)
-        return self.sock
-    
-    def __Socket_TCP_file_noreply(self, head, content):
-        head1 = head
-        content1 = content
-        gpioWakeBT.write(1)
-        utime.sleep_ms(2)
-        gpioWakeBT.write(0)
-        utime.sleep_ms(20)
-        msg = self.__pack_tlv_format(head1,content1)
-        if msg == -1: 
-            return 0
-        try:
-            self.conn.send(msg)
-        except Exception as e:
-            clog.info("self.__sock_file error {}".format(e))
-        return 0
-
-    def _client_conn_proc(self):
-        while True:
-            if  self.conn==None:
-                utime.sleep_ms(20)
-                continue
-            try:
-                data = self.conn.recv(1024)
-                if not data:
-                    clog.info("__Socket_File_Thread data null:\r\n")
-                else:
-                    self.src_data(data.decode('uft-8'))
-            except:
-                self.conn.close()
-                break
-            
-    def __Socket_File_Thread(self):
-        while True:
-            try :
-                cli_conn, cli_ip_addr, cli_port = self.__sock_file.accept()
-                self.conn=cli_conn
-                clog.info('[serveice] accept a client: %s, %s' % (cli_ip_addr, cli_port))
-            except :
-                utime.sleep_ms(20)
-    
-    def cat1FileTimerCb(self,*argc):
-        clog.info("timer test\r\n")
-        if self.Cat1PyFileTimout > 0:
-            self.Cat1PyFileTimout-=1
-        if self.Cat1PyFileTimout == 0:
-            self.Cat1PyFileTimout = 0
-            self.Cat1FileState = 0
-            self.deleteTmpFile()
-            self.deleteUsrTmpFile()
-            self.__Socket_TCP_file_noreply(CAT1_OTA_TIMEOUT_BLE_NO_REPLAY,"ota error") #结束文件接收不完整的
-            self.Cat1FileTransTimer.stop() 
-            pass
-
-    def crc_cal(self,msg):
-        bytes_data = msg.encode('utf-8')
-        hex_data = binascii.hexlify(bytes_data)
-        hex_data = hex_data.decode()
-        data = hex_data
-        crcValue = 0
-        j = 0
-        i = 0
-        json_state = 0
-        crcbuf = 0
-        data_len = len(str(data))
-        try:
-            if data_len % 2 != 0: 
-                json_state = 0
-                return [json_state,crcbuf]
-        except Exception as e:
-            json_state = 0
-        for i in range(data_len):
-            if j >= data_len:
-                break
-            try:
-                decimal_number = int(str(data[j:j+2]), 16)
-                crcValue=crcValue+decimal_number
-                crcValue = crcValue&0xff
-            except Exception as e:
-                clog.info("crc_cal")
-            j+=2
-        crcbuf = crcValue%256
-        crcbuf = 256-crcbuf
-        crcbuf = crcbuf%256
-        return [json_state,"%02x"%(crcbuf)]
-    def deleteTmpFile(self):
-        tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
-        if tmp_dir == True:
-            ql_fs.rmdirs(BAK_FILE_PATH)
-             
-    def deleteUsrTmpFile(self):
-        return       
-
-    def src_data(self,data):
-        if self.updateTimerFlag == 0:
-            self.updateTimerFlag = 1
-            self.updateTimer.stop()
-        msg = ""
-        json_state = 0
-        try:
-            msg = ujson.loads(data)
-            json_state = 1
-        except Exception as e:
-            json_state = 0
-        if json_state == 0:
-            value = self.__unpack_tlv_format(data)
-            self.cmd_data(value[0],value[2])
-            return
-        else:
-           self.file_data(msg) 
-        pass
-    def cmd_data(self,cmd,parm):
-        if cmd == "01":
-            self.bakFlag = str(parm)
-        pass
-    def file_data(self,msg):
-        if "Code" in msg:
-            Code = int(msg["Code"])
-            if Code == CAT1_TCP_STOP_OTA:
-                self.allPyRecvFlag = 0
-                self.Cat1FileState = 0
-                self.Cat1FileTransTimer.stop()
-                self.deleteTmpFile()
-                self.deleteUsrTmpFile()
-                pass
-            elif Code == CAT1_TCP_START_OTA:
-                self.ota_state =0
-                self.ota_bstate =0
-                self.allPyRecvFlag = 0
-                self.fileNameList = []
-                self.fileSizeList = []
-                self.allPyRecvFlag = 0
-                self.Cat1FileState = 0
-                self.deleteUsrTmpFile()
-                self.Cat1OtaTimeOut.stop()
-                check_dir = ql_fs.path_exists(BAK_FILE_PATH)
-                mk_dir_state = 0
-                if check_dir == True:
-                    try:
-                        self.deleteTmpFile()
-                    except Exception as e:
-                        clog.info("移除失败\r\n")
-                check_dir = ql_fs.path_exists(BAK_FILE_PATH)      
-                if check_dir == False:
-                    try:
-                        ql_fs.mkdirs(BAK_FILE_PATH) 
-                        mk_dir_state = 1
-                    except Exception as e:
-                        mk_dir_state = 0
-                else: 
-                   mk_dir_state = 1 
-                if mk_dir_state == 0:
-                    self.__Socket_TCP_file_noreply(CAT1_CREAT_DIR_FAILE,"creat dir error!")
-                else:
-                    self.Cat1FileState = 1
-                    self.fileNameList = []
-                    self.fileSizeList = []
-                    self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT
-                    self.Cat1FileTransTimer.stop()
-                    self.Cat1FileTransTimer.start(1000,1,self.cat1FileTimerCb)
-                    self.__Socket_TCP_file_noreply(CAT1_CREAT_DIR_OK,"creat dir success!")
-                    
-            elif Code == CAT1_TCP_START_SEND_SINGLE_FILE_INFO and self.Cat1FileState == 1:
-                self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT 
-                self.fileNameTmp = str(msg["fileName"])
-                self.fileSize = msg["fileSize"]
-                self.fileNameList = msg["fileNameList"]
-                path = "{}/{}".format(BAK_FILE_PATH,self.fileNameTmp)
-                check_touch = ql_fs.path_exists("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
-                if check_touch == True:
-                    try:
-                        uos.remove("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
-                    except Exception as e:
-                        clog.info("移除文件失败\r\n")
-                    try:
-                        with open(path,"w+") as fd:
-                            fd.write("")
-                        fd.close()
-                        self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_SUCC,"1creat file or dir success!")
-                    except Exception as e:
-                        self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"1creat file or dir err!")
-                else:
-                    try:
-                        with open(path,"w+") as fd:
-                            fd.write("")
-                        fd.close()
-                        self.crc_err = 0
-              
-                        self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_SUCC,"2creat file or dir success!")
-                    except Exception as e:
-                        self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"2creat file or dir err!")
-          
-
-            elif Code == CAT1_TCP_START_SEND_FILE_DATA and self.Cat1FileState == 1: 
-                self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT 
-                if len(self.fileNameTmp) == 0: 
-                    return
-                data = msg["data"]
-                if len(data) == 0:
-                    return
-                tmpdata = str(data)
-                head = tmpdata[0:2]
-                if head != CAT1_FILE_DATA_HEAD or len(tmpdata) <= 8:
-                    clog.info("head {}\r\n".format(head))
-                    self.__Socket_TCP_file_noreply(CAT1_SEND_HEAD_ERR,"head error!")
-                    return
-                datalen = str(tmpdata[2:6]) 
-                datalen = int("0x" + datalen, 16) 
-                data_buf = tmpdata[6:]
-                data_buf = data_buf[:-2]
-                crc = tmpdata[-2:]
-                if len(str(data_buf)) == 0 or len(str(data_buf)) != datalen:
-                    self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_ERROR,"crc error or data null!")
-                    return
-                data = str(data_buf)
-                path = "{}/{}".format(BAK_FILE_PATH,str(self.fileNameTmp))
-                try:
-                    with open(path,"a") as fd:
-                        fd.write(data)
-                    fd.close()
-                    self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_SUCC,"write file success!")
-                
-                except Exception as e:
-                    self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_ERROR,"write file error!")
-                 
-            elif Code == CAT1_TCP_START_OTA_FAILE and self.Cat1FileState == 1:
-                self.allPyRecvFlag = 0
-                self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"OTA FAILE")
-                self.Cat1FileState = 0
-                self.Cat1FileTransTimer.stop()
-                self.deleteTmpFile()
-                self.deleteUsrTmpFile()
-                pass
-            elif Code == CAT1_TCP_START_SEND_ALLFILE_FINESH and self.Cat1FileState == 1:
-                if self.bakFlag == "0":
-                    if self.allPyRecvFlag == 1:
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!")
-                    else:
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!")
-                        self.deleteTmpFile()
-                        self.Cat1FileState = 0
-                        self.Cat1FileTransTimer.stop()
-                        self.Cat1OtaTimeOut.stop()
-                        self.Cat1TimeCount = 0
-                        self.ota_state = 1
-                        self.allPyRecvFlag = 1
-                        self.Cat1OtaTimeOut.start(5000,0,self.otaTimeOut)
-                    return
-                tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
-                if tmp_dir == True:
-                    filenamesList = uos.listdir(BAK_FILE_PATH)
-                    list1 = sorted(filenamesList)
-                    list2 = sorted(self.fileNameList)
-                    if list1 != list2:
-                        self.deleteTmpFile()
-                        self.Cat1FileState = 0
-                        self.Cat1FileTransTimer.stop()
-                        self.deleteUsrTmpFile()
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
-                        return
-                    try:
-                        copy_state = 1
-                        compare_flag = 1
-                        copy_flag = 0
-                        filenamesList = uos.listdir(BAK_FILE_PATH)
-                        for tmp in filenamesList:
-                            dst_path = "{}/{}".format(USR_FILE_PATH,tmp)
-                            src_path = "{}/{}".format(BAK_FILE_PATH,tmp)
-                            ret = False
-                            file_size = 0
-                            try:
-                                ret = ql_fs.file_copy(dst_path,src_path) 
-                        
-                                if ret == True:
-                                    dstfile_size = ql_fs.path_getsize(dst_path)
-                                    srcfile_size = ql_fs.path_getsize(src_path)
-                                    if dstfile_size != srcfile_size:
-                                        compare_flag = 0
-                                        break
-                                    else:
-                                        try:
-                                            compare_flag = 1
-                                            uos.remove(src_path)
-                                            filenamesList = uos.listdir(BAK_FILE_PATH)
-                                        except Exception as e:
-                                            clog.info("copy file \r\n")
-                                else:
-                                    compare_flag = 0
-                                    break
-                            except Exception as e:
-                                clog.info("copy file \r\n")
-                                
-                        if copy_state == 0 or compare_flag == 0 :
-                            self.deleteUsrTmpFile()
-                            self.deleteTmpFile()
-                            self.Cat1FileState = 0
-                            self.Cat1FileTransTimer.stop()
-                            self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!22")
-                            return
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!")
-                        self.deleteTmpFile()
-                        self.Cat1FileState = 0
-                        self.Cat1FileTransTimer.stop()
-                        self.Cat1OtaTimeOut.stop()
-                        self.Cat1TimeCount = 0
-                        self.ota_state = 1
-                        self.allPyRecvFlag = 1
-                        self.Cat1OtaTimeOut.start(5000,0,self.otaTimeOut)
-                    except Exception as e:
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!33")
-                        self.deleteUsrTmpFile()
-                        self.deleteTmpFile()
-                        self.Cat1FileState = 0
-                        self.Cat1FileTransTimer.stop()
-                else:
-                    if self.ota_state == 1:
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!")
-                        pass
-                    else:
-                        self.deleteTmpFile()
-                        self.Cat1FileState = 0
-                        self.Cat1FileTransTimer.stop()
-                        self.deleteUsrTmpFile()
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
-
-            elif Code == CAT1_TCP_START_OTA_SUCC and self.Cat1FileState == 1:
-                if self.bakFlag == "0":
-                    self.deleteUsrTmpFile()
-                    self.deleteTmpFile()
-                    self.Cat1FileState = 0
-                    self.Cat1FileTransTimer.stop()
-                    if self.allPyRecvFlag == 1:
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!")
-                    else:
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
-                    return
-
-                if self.allPyRecvFlag == 0:
-                    self.deleteTmpFile()
-                    self.deleteUsrTmpFile()
-                    self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
-                    return
-                tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
-                if tmp_dir == True:
-                    filenamesList = uos.listdir(BAK_FILE_PATH)
-                    list1 = sorted(filenamesList)
-                    list2 = sorted(self.fileNameList)
-                    if list1 != list2:
-                        self.deleteTmpFile()
-                        self.Cat1FileState = 0
-                        self.Cat1FileTransTimer.stop()
-                        self.deleteUsrTmpFile()
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
-                        return
-                    
-                    try:
-                        copy_state = 1
-                        compare_flag = 1
-                        filenamesList = uos.listdir(BAK_FILE_PATH)
-                        for tmp in filenamesList:
-                            dst_path = "{}/{}".format(USR_FILE_PATH,tmp)
-                            src_path = "{}/{}".format(BAK_FILE_PATH,tmp)
-                            ret = False
-                            file_size = 0
-                            try:
-                                ret = ql_fs.file_copy(dst_path,src_path) 
-                                if ret == True:
-                                    dstfile_size = ql_fs.path_getsize(dst_path)
-                                    srcfile_size = ql_fs.path_getsize(src_path)
-                                    if dstfile_size != srcfile_size:
-                                        compare_flag = 0
-                                        break
-                                    else:
-                                        try:
-                                            compare_flag = 1
-                                            uos.remove(src_path)
-                                            filenamesList = uos.listdir(BAK_FILE_PATH)
-                                        except Exception as e:
-                                            clog.info("file\r\n")
-                                else:
-                                    compare_flag = 0
-                                    break
-                                
-                            except Exception as e:
-                                clog.info("file\r\n")
-                        if copy_state == 0 or compare_flag == 0 :
-                            self.deleteUsrTmpFile()
-                            self.deleteTmpFile()
-                            self.Cat1FileState = 0
-                            self.Cat1FileTransTimer.stop()
-                            self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!22")
-                            return
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!")
-                        self.deleteTmpFile()
-                        self.Cat1FileState = 0
-                        self.Cat1FileTransTimer.stop()
-                        self.Cat1OtaTimeOut.stop()
-                        self.Cat1TimeCount = 0
-                        self.ota_bstate = 1
-                        self.conn.close()
-                        self.Cat1OtaTimeOut.start(10000,0,self.otaTimeOut)
-                    except Exception as e:
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!33")
-                        self.deleteUsrTmpFile()
-                        self.deleteTmpFile()
-                        self.Cat1FileState = 0
-                        self.Cat1FileTransTimer.stop()
-                else:
-                    if self.ota_bstate == 1:
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!")
-                        pass
-                    else:
-                        self.deleteTmpFile()
-                        self.Cat1FileState = 0
-                        self.Cat1FileTransTimer.stop()
-                        self.deleteUsrTmpFile()
-                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
-
-            elif Code == CAT1_TCP_SEND_SINGLE_FINESH and self.Cat1FileState == 1: 
-                self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT 
-                tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
-                if tmp_dir == True:
-                    tmp_file = ql_fs.path_exists("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
-                    if tmp_file == True: 
-                        file_size = ql_fs.path_getsize("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
-                        if self.fileSize != file_size:
-                            self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file size err") 
-                        else:
-                            if self.bakFlag == "0":
-                                dst_path = "{}/{}".format(USR_FILE_PATH,self.fileNameTmp)
-                                src_path = "{}/{}".format(BAK_FILE_PATH,self.fileNameTmp)
-                                ret = False
-                                try:
-                                    ret = ql_fs.file_copy(dst_path,src_path) 
-                                    if ret == True:
-                                        dstfile_size = ql_fs.path_getsize(dst_path)
-                                        srcfile_size = ql_fs.path_getsize(src_path)
-                                        if dstfile_size != srcfile_size:
-                                            src_file = ql_fs.path_exists(src_path)
-                                            if src_file == True:
-                                                try:
-                                                    uos.remove(src_path)
-                                                except Exception as e:
-                                                    clog.info("copy 文件异常出错 yichu!{}:\r\n".format(e))
-                                            self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file size err")
-                                            return
-                                        else:
-                                            src_file = ql_fs.path_exists(src_path)
-                                            if src_file == True:
-                                                try:
-                                                    uos.remove(src_path)
-                                                except Exception as e:
-                                                    clog.info("copy 文件异常出错!!!!!!!!!!{}:\r\n".format(e))
-                                            self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_OK,"file size ok")
-                                            return
-                                    else:
-                                        self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file copy err") 
-                                except Exception as e:
-                                    self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file copy err")
-                            else:
-                                self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_OK,"file copy ok")
-                    else:
-                        self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"creat file or dir err!")
-                        pass
-                else:
-                    self.__Socket_TCP_file_noreply(CAT1_CREAT_DIR_FAILE,"creat file or dir error!")
-                    pass
-            else:
-                if self.Cat1FileState == 0:
-                    if self.Cat1FileReplayBle == 1:
-                        return
-                    self.Cat1FileReplayBle = 1
-                    self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"reset start!") 
-                    self.Cat1FileState == 0
-                    self.Cat1FileTransTimer.stop() 
-                    self.Cat1PyFileTimout = 0
-                    self.fileNameList=[]
-                    self.deleteTmpFile()
-                    self.deleteUsrTmpFile()
-                    
-    def otaTimeOut(self,*argc):
-        clog.info("重启成功!!!!!!!!\r\n")
-
-TcpService = TcpServiceInit()
-
-
diff --git a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/telecom_dmp.py b/code/sdk/files/leiniao/fs/user/system/cat1otaudp/telecom_dmp.py
deleted file mode 100644 (file)
index f60e748..0000000
+++ /dev/null
@@ -1,5 +0,0 @@
-import log
-
-# 设置日志输出级别
-log.basicConfig(level=log.INFO)
-fota_log = log.getLogger("telecom_dmp")
index e083e5e..fcf407b 100644 (file)
@@ -90,6 +90,9 @@ set(SOURCES
     ${CMAKE_LWIP_SOURCE_DIR}/src/core/init.c
     ${CMAKE_LWIP_SOURCE_DIR}/src/core/sys.c
     ${CMAKE_LWIP_SOURCE_DIR}/src/core/altcp_alloc.c
+    ${CMAKE_LWIP_SOURCE_DIR}/src/apps/http/http_client.c
+    ${CMAKE_LWIP_SOURCE_DIR}/src/apps/altcp_tls/altcp_tls_mbedtls.c
+    ${CMAKE_LWIP_SOURCE_DIR}/src/apps/altcp_tls/altcp_tls_mbedtls_mem.c
     ${CMAKE_LWIP_SOURCE_DIR}/src/netif/lowpan6_common.c
     ${CMAKE_LWIP_SOURCE_DIR}/src/netif/lowpan6.c
     ${CMAKE_LWIP_SOURCE_DIR}/src/api/if_api.c
index 20f7b8c..10f2785 100644 (file)
@@ -200,6 +200,14 @@ extern "C" {
 #define SLIP_USE_RX_THREAD      1    // 启用接收线程作为主线程处理队列
 #endif
 
+/* 增加 SLIP 接收线程栈大小,防止在处理大量数据时栈溢出
+ * 注意:处理 TCP/HTTPS 数据时调用链很深(netif->input -> ip_input -> tcp_input -> tcp_process -> altcp_recved -> mbedtls_ssl_read)
+ * 需要足够大的栈空间来避免栈溢出
+ */
+#ifndef SLIP_RX_THREAD_STACKSIZE
+#define SLIP_RX_THREAD_STACKSIZE  16384  // 16KB 栈大小(处理 HTTPS/TLS 数据时需要更大的栈)
+#endif
+
 #ifndef SLIP_DEBUG
 #define SLIP_DEBUG              LWIP_DBG_ON
 #endif
@@ -245,6 +253,22 @@ extern "C" {
 
 
 #define LWIP_HTTPC_HAVE_FILE_IO 1
+
+/* Enable altcp API for layered protocols (TLS support) */
+#ifndef LWIP_ALTCP
+#define LWIP_ALTCP                      1
+#endif
+
+/* Enable TLS support for altcp API */
+#ifndef LWIP_ALTCP_TLS
+#define LWIP_ALTCP_TLS                  1
+#endif
+
+/* Enable mbedTLS backend for altcp TLS */
+#ifndef LWIP_ALTCP_TLS_MBEDTLS
+#define LWIP_ALTCP_TLS_MBEDTLS          1
+#endif
+
 /*
   To support the CMSIS interface, you need to enable this macro.
   By default, this macro is not supported.
@@ -588,7 +612,8 @@ extern "C" {
 #endif
 
 #ifndef LWIP_WND_SCALE
-#define LWIP_WND_SCALE    0
+#define LWIP_WND_SCALE    1
+#define TCP_RCV_SCALE     1
 #endif
 
 #ifndef LWIP_SOCK_FILTER
index 1518b48..16c5672 100644 (file)
 
 #include "altcp_tls_mbedtls_structs.h"
 #include "altcp_tls_mbedtls_mem.h"
-#if (MBEDTLS_VERSION_NUMBER == 0x03010000)
+#if (MBEDTLS_VERSION_NUMBER >= 0x03010000)
 #include "mbedtls/pk.h"
 #include "mbedtls/net_sockets.h"
 #include "mbedtls/x509_crt.h"
-
 #else
-#include "mbedtls/certs.h"
 #include "mbedtls/x509.h"
 #include "mbedtls/net.h"
 #include "mbedtls/ssl_internal.h" /* to call mbedtls_flush_output after ERR_MEM */
@@ -204,6 +202,19 @@ altcp_mbedtls_lower_recv(void *arg, struct altcp_pcb *inner_conn, struct pbuf *p
   altcp_mbedtls_state_t *state;
   struct altcp_pcb *conn = (struct altcp_pcb *)arg;
 
+  /* 添加日志:记录TLS层接收TCP数据 */
+  if (p != NULL) {
+    printf("[ALTCP_TLS] altcp_mbedtls_lower_recv: received TCP data, len=%u, tot_len=%u, err=%d\n", 
+           p->len, p->tot_len, err);
+    LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                ("[ALTCP_TLS] altcp_mbedtls_lower_recv: received TCP data, len=%u, tot_len=%u, err=%d\n", 
+                 p->len, p->tot_len, err));
+  } else {
+    printf("[ALTCP_TLS] altcp_mbedtls_lower_recv: pbuf is NULL, err=%d\n", err);
+    LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                ("[ALTCP_TLS] altcp_mbedtls_lower_recv: pbuf is NULL, err=%d\n", err));
+  }
+
   LWIP_ASSERT("no err expected", err == ERR_OK);
   LWIP_UNUSED_ARG(err);
 
@@ -226,6 +237,17 @@ altcp_mbedtls_lower_recv(void *arg, struct altcp_pcb *inner_conn, struct pbuf *p
     return ERR_CLSD;
   }
 
+  /* 添加日志:记录握手状态 */
+  if (!(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) {
+    printf("[ALTCP_TLS] altcp_mbedtls_lower_recv: handshake not done yet, processing handshake data\n");
+    LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                ("[ALTCP_TLS] altcp_mbedtls_lower_recv: handshake not done yet, processing handshake data\n"));
+  } else {
+    printf("[ALTCP_TLS] altcp_mbedtls_lower_recv: handshake done, processing application data\n");
+    LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                ("[ALTCP_TLS] altcp_mbedtls_lower_recv: handshake done, processing application data\n"));
+  }
+
   /* handle NULL pbuf (inner connection closed) */
   if (p == NULL) {
     /* remote host sent FIN, remember this (SSL state is destroyed
@@ -284,7 +306,38 @@ altcp_mbedtls_lower_recv_process(struct altcp_pcb *conn, altcp_mbedtls_state_t *
       return ERR_OK;
     }
     if (ret != 0) {
-      LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ssl_handshake failed: %d\n", ret));
+      /* 详细的握手错误日志 */
+      char error_buf[256];
+      mbedtls_strerror(ret, error_buf, sizeof(error_buf));
+      /* 使用 printf 确保日志输出(因为 LWIP_DEBUGF 可能被关闭) */
+      printf("[ALTCP_TLS] SSL handshake failed: ret=%d (0x%04x), error=%s\n", ret, (unsigned int)(-ret), error_buf);
+      LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_SERIOUS, 
+                  ("[ALTCP_TLS] SSL handshake failed: ret=%d (0x%04x), error=%s\n", ret, (unsigned int)(-ret), error_buf));
+      
+      /* 记录常见错误码的详细说明(使用错误码数值,避免依赖可能不存在的宏) */
+      const char *error_detail = "";
+      /* 检查错误码范围(mbedTLS SSL 错误码通常在 -0x7000 到 -0x7FFF 范围) */
+      if (ret < -0x7000 && ret > -0x8000) {
+        /* 常见的 SSL 错误码(根据 mbedTLS 错误码定义) */
+        if (ret == -0x7100) {  /* MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION */
+          error_detail = " (Bad protocol version - TLS version mismatch)";
+        } else if (ret == -0x7200) {  /* MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN */
+          error_detail = " (No cipher chosen - cipher suite mismatch)";
+        } else if (ret == -0x7500) {  /* MBEDTLS_ERR_SSL_HANDSHAKE_FAILURE */
+          error_detail = " (Handshake failure - server rejected handshake)";
+        } else if (ret == -0x7880) {  /* MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY */
+          error_detail = " (Peer closed connection during handshake)";
+        } else if (ret == -0x7280) {  /* MBEDTLS_ERR_SSL_CONN_EOF */
+          error_detail = " (Connection EOF during handshake)";
+        } else if (ret == -0x7400) {  /* MBEDTLS_ERR_SSL_TIMEOUT */
+          error_detail = " (Handshake timeout)";
+        }
+      }
+      if (error_detail[0] != '\0') {
+        LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
+                    ("[ALTCP_TLS] Error detail:%s\n", error_detail));
+      }
+      
       /* handshake failed, connection has to be closed */
       if (conn->err) {
         conn->err(conn->arg, ERR_CLSD);
@@ -299,6 +352,20 @@ altcp_mbedtls_lower_recv_process(struct altcp_pcb *conn, altcp_mbedtls_state_t *
     LWIP_ASSERT("state", state->bio_bytes_read == 0);
     LWIP_ASSERT("state", state->bio_bytes_appl == 0);
     state->flags |= ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE;
+    
+    /* 记录握手成功后协商的 TLS 版本和加密套件 */
+    {
+      const char *version_str = mbedtls_ssl_get_version(&state->ssl_context);
+      const char *ciphersuite = mbedtls_ssl_get_ciphersuite(&state->ssl_context);
+      mbedtls_ssl_protocol_version tls_version = mbedtls_ssl_get_version_number(&state->ssl_context);
+      /* 使用 printf 确保日志输出(因为 LWIP_DEBUGF 可能被关闭) */
+      printf("[ALTCP_TLS] SSL handshake succeeded: version=%s (0x%04x), ciphersuite=%s\n",
+             version_str ? version_str : "UNKNOWN", (unsigned int)tls_version, ciphersuite ? ciphersuite : "NULL");
+      LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                  ("[ALTCP_TLS] SSL handshake succeeded: version=%s (0x%04x), ciphersuite=%s\n",
+                   version_str ? version_str : "UNKNOWN", (unsigned int)tls_version, ciphersuite ? ciphersuite : "NULL"));
+    }
+    
     /* issue "connect" callback" to upper connection (this can only happen for active open) */
     if (conn->connected) {
       err_t err;
@@ -325,14 +392,23 @@ altcp_mbedtls_pass_rx_data(struct altcp_pcb *conn, altcp_mbedtls_state_t *state)
   LWIP_ASSERT("state != NULL", state != NULL);
   buf = state->rx_app;
   if (buf) {
+    printf("[ALTCP_TLS] altcp_mbedtls_pass_rx_data: passing decrypted data to application, len=%u\n", buf->tot_len);
+    LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                ("[ALTCP_TLS] altcp_mbedtls_pass_rx_data: passing decrypted data to application, len=%u\n", buf->tot_len));
     state->rx_app = NULL;
     if (conn->recv) {
       u16_t tot_len = buf->tot_len;
       /* this needs to be increased first because the 'recved' call may come nested */
       state->rx_passed_unrecved += tot_len;
       state->flags |= ALTCP_MBEDTLS_FLAGS_UPPER_CALLED;
+      printf("[ALTCP_TLS] altcp_mbedtls_pass_rx_data: calling conn->recv callback, len=%u\n", tot_len);
+      LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                  ("[ALTCP_TLS] altcp_mbedtls_pass_rx_data: calling conn->recv callback, len=%u\n", tot_len));
       err = conn->recv(conn->arg, conn, buf, ERR_OK);
       if (err != ERR_OK) {
+        printf("[ALTCP_TLS] altcp_mbedtls_pass_rx_data: conn->recv returned error, err=%d\n", err);
+        LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                    ("[ALTCP_TLS] altcp_mbedtls_pass_rx_data: conn->recv returned error, err=%d\n", err));
         if (err == ERR_ABRT) {
           return ERR_ABRT;
         }
@@ -373,8 +449,14 @@ altcp_mbedtls_handle_rx_appldata(struct altcp_pcb *conn, altcp_mbedtls_state_t *
   LWIP_ASSERT("state != NULL", state != NULL);
   if (!(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) {
     /* handshake not done yet */
+    printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: handshake not done yet, returning ERR_VAL\n");
+    LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                ("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: handshake not done yet, returning ERR_VAL\n"));
     return ERR_VAL;
   }
+  printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: starting to decrypt application data\n");
+  LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+              ("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: starting to decrypt application data\n"));
   do {
     /* allocate a full-sized unchained PBUF_POOL: this is for RX! */
     struct pbuf *buf = pbuf_alloc(PBUF_RAW, PBUF_POOL_BUFSIZE, PBUF_POOL);
@@ -385,12 +467,59 @@ altcp_mbedtls_handle_rx_appldata(struct altcp_pcb *conn, altcp_mbedtls_state_t *
     }
 
     /* decrypt application data, this pulls encrypted RX data off state->rx pbuf chain */
+    /* 记录调用前的状态 */
+    int bytes_avail_before = mbedtls_ssl_get_bytes_avail(&state->ssl_context);
+    u16_t state_rx_len = (state->rx != NULL) ? state->rx->tot_len : 0;
+    printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: before mbedtls_ssl_read: bytes_avail=%d, state->rx=%p (len=%u), bio_bytes_read=%d\n",
+           bytes_avail_before, state->rx, state_rx_len, state->bio_bytes_read);
     ret = mbedtls_ssl_read(&state->ssl_context, (unsigned char *)buf->payload, PBUF_POOL_BUFSIZE);
+    int bytes_avail_after = mbedtls_ssl_get_bytes_avail(&state->ssl_context);
+    if (ret > 0) {
+      printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: mbedtls_ssl_read decrypted %d bytes (bytes_avail: %d -> %d)\n", 
+             ret, bytes_avail_before, bytes_avail_after);
+      LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                  ("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: mbedtls_ssl_read decrypted %d bytes (bytes_avail: %d -> %d)\n", 
+                   ret, bytes_avail_before, bytes_avail_after));
+    }
     if (ret < 0) {
+      if (ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE) {
+        /* 检查 mbedTLS 内部状态 */
+        int bytes_avail = mbedtls_ssl_get_bytes_avail(&state->ssl_context);
+        printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: mbedtls_ssl_read wants more data (WANT_READ/WANT_WRITE), ret=%d, bytes_avail=%d, state->rx=%p\n", 
+               ret, bytes_avail, state->rx);
+        LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                    ("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: mbedtls_ssl_read wants more data (WANT_READ/WANT_WRITE), ret=%d, bytes_avail=%d, state->rx=%p\n", 
+                     ret, bytes_avail, state->rx));
+        pbuf_free(buf);
+        /* 如果 state->rx 还有数据,或者 bytes_avail > 0,说明可能还有数据可以处理 */
+        if (state->rx != NULL || bytes_avail > 0) {
+          printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: state->rx or bytes_avail has data, will retry on next poll\n");
+        }
+        return ERR_OK;
+      } else if (ret == MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET) {
+        /* TLS 1.3: NewSessionTicket is a normal post-handshake message, not an error.
+         * Continue processing to read actual application data. */
+        printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: received NewSessionTicket (TLS 1.3), continuing to read application data\n");
+        LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                    ("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: received NewSessionTicket (TLS 1.3), continuing to read application data\n"));
+        pbuf_free(buf);
+        /* Continue the loop to read actual application data */
+        continue;
+      } else {
+        char error_buf[256];
+        mbedtls_strerror(ret, error_buf, sizeof(error_buf));
+        printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: mbedtls_ssl_read error, ret=%d (0x%04x), error=%s\n", 
+               ret, (unsigned int)(-ret), error_buf);
+        LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
+                    ("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: mbedtls_ssl_read error, ret=%d (0x%04x), error=%s\n", 
+                     ret, (unsigned int)(-ret), error_buf));
+      }
       if (ret == MBEDTLS_ERR_SSL_CLIENT_RECONNECT) {
         /* client is initiating a new connection using the same source port -> close connection or make handshake */
         LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("new connection on same source port\n"));
         LWIP_ASSERT("TODO: new connection on same source port, close this connection", 0);
+        pbuf_free(buf);
+        return ERR_OK;
       } else if (ret == MBEDTLS_ERR_SSL_TIMEOUT) {
         /* SSL read timeout - may occur on slow links (e.g., UART SLIP)
          * If there's data in the RX buffer, retry instead of closing the connection */
@@ -404,21 +533,19 @@ altcp_mbedtls_handle_rx_appldata(struct altcp_pcb *conn, altcp_mbedtls_state_t *
         LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("SSL read timeout, no data pending\n"));
         pbuf_free(buf);
         return ERR_OK;
-      } else if ((ret != MBEDTLS_ERR_SSL_WANT_READ) && (ret != MBEDTLS_ERR_SSL_WANT_WRITE)) {
-        if (ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) {
-          LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was closed gracefully\n"));
-        } else if (ret == MBEDTLS_ERR_NET_CONN_RESET) {
-          LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was reset by peer\n"));
-        }
+      } else if (ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) {
+        LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was closed gracefully\n"));
+        pbuf_free(buf);
+        return ERR_OK;
+      } else if (ret == MBEDTLS_ERR_NET_CONN_RESET) {
+        LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was reset by peer\n"));
         pbuf_free(buf);
         return ERR_OK;
       } else {
+        /* Other errors: free buffer and return OK to allow retry */
         pbuf_free(buf);
         return ERR_OK;
       }
-      pbuf_free(buf);
-      altcp_abort(conn);
-      return ERR_ABRT;
     } else {
       err_t err;
       if (ret) {
@@ -495,6 +622,9 @@ altcp_mbedtls_bio_recv(void *ctx, unsigned char *buf, size_t len)
       /* close queued but not passed up yet */
       return 0;
     }
+    printf("[ALTCP_TLS] altcp_mbedtls_bio_recv: no data available (p=%p), returning WANT_READ\n", p);
+    LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                ("[ALTCP_TLS] altcp_mbedtls_bio_recv: no data available (p=%p), returning WANT_READ\n", p));
     return MBEDTLS_ERR_SSL_WANT_READ;
   }
   /* limit number of bytes again to copy from first pbuf in a chain only */
@@ -502,6 +632,11 @@ altcp_mbedtls_bio_recv(void *ctx, unsigned char *buf, size_t len)
   /* copy the data */
   ret = pbuf_copy_partial(p, buf, copy_len, 0);
   LWIP_ASSERT("ret == copy_len", ret == copy_len);
+  printf("[ALTCP_TLS] altcp_mbedtls_bio_recv: copied %u bytes from pbuf (p->len=%u, p->tot_len=%u, requested=%zu)\n", 
+         ret, p->len, p->tot_len, len);
+  LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+              ("[ALTCP_TLS] altcp_mbedtls_bio_recv: copied %u bytes from pbuf (p->len=%u, p->tot_len=%u, requested=%zu)\n", 
+               ret, p->len, p->tot_len, len));
   /* hide the copied bytes from the pbuf */
   err = pbuf_remove_header(p, ret);
   LWIP_ASSERT("error", err == ERR_OK);
@@ -510,6 +645,9 @@ altcp_mbedtls_bio_recv(void *ctx, unsigned char *buf, size_t len)
     state->rx = p->next;
     p->next = NULL;
     pbuf_free(p);
+    printf("[ALTCP_TLS] altcp_mbedtls_bio_recv: freed consumed pbuf, state->rx=%p\n", state->rx);
+    LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING,
+                ("[ALTCP_TLS] altcp_mbedtls_bio_recv: freed consumed pbuf, state->rx=%p\n", state->rx));
   }
 
   state->bio_bytes_read += (int)ret;
@@ -1116,7 +1254,7 @@ altcp_mbedtls_sndbuf(struct altcp_pcb *conn)
           size_t ret;
 #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
           /* @todo: adjust ssl_added to real value related to negociated cipher */
-          #if (MBEDTLS_VERSION_NUMBER == 0x03010000)
+          #if (MBEDTLS_VERSION_NUMBER >= 0x03010000)
           size_t max_frag_len = mbedtls_ssl_get_max_out_record_payload(&state->ssl_context);
           #else
           size_t max_frag_len = mbedtls_ssl_get_max_frag_len(&state->ssl_context);
@@ -1163,7 +1301,7 @@ altcp_mbedtls_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t
   /* HACK: if thre is something left to send, try to flush it and only
      allow sending more if this succeeded (this is a hack because neither
      returning 0 nor MBEDTLS_ERR_SSL_WANT_WRITE worked for me) */
-  #if (MBEDTLS_VERSION_NUMBER == 0x03010000)
+  #if (MBEDTLS_VERSION_NUMBER >= 0x03010000)
     if(mbedtls_ssl_flush_output(&state->ssl_context) !=0)
     {
       return ERR_MEM;
@@ -1176,23 +1314,31 @@ altcp_mbedtls_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t
     }
   }
   #endif
+  printf("[ALTCP_TLS] altcp_mbedtls_write: writing %u bytes to TLS connection\n", len);
   ret = mbedtls_ssl_write(&state->ssl_context, (const unsigned char *)dataptr, len);
+  printf("[ALTCP_TLS] altcp_mbedtls_write: mbedtls_ssl_write returned %d (len=%u)\n", ret, len);
   /* try to send data... */
   altcp_output(conn->inner_conn);
   if (ret >= 0) {
     if (ret == len) {
       state->flags |= ALTCP_MBEDTLS_FLAGS_APPLDATA_SENT;
+      printf("[ALTCP_TLS] altcp_mbedtls_write: all %u bytes written successfully\n", len);
       return ERR_OK;
     } else {
       /* @todo/@fixme: assumption: either everything sent or error */
+      printf("[ALTCP_TLS] altcp_mbedtls_write: WARNING: partial write, ret=%d, len=%u\n", ret, len);
       LWIP_ASSERT("ret <= 0", 0);
       return ERR_MEM;
     }
   } else {
     if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) {
+      printf("[ALTCP_TLS] altcp_mbedtls_write: WANT_WRITE, need to retry\n");
       /* @todo: convert error to err_t */
       return ERR_MEM;
     }
+    char error_buf[256];
+    mbedtls_strerror(ret, error_buf, sizeof(error_buf));
+    printf("[ALTCP_TLS] altcp_mbedtls_write: ERROR: ret=%d (0x%04x), error=%s\n", ret, (unsigned int)(-ret), error_buf);
     LWIP_ASSERT("unhandled error", 0);
     return ERR_VAL;
   }
@@ -1215,23 +1361,30 @@ altcp_mbedtls_bio_send(void *ctx, const unsigned char *dataptr, size_t size)
     return MBEDTLS_ERR_NET_INVALID_CONTEXT;
   }
 
+  printf("[ALTCP_TLS] altcp_mbedtls_bio_send: sending %zu bytes to TCP layer\n", size);
   while (size_left) {
     u16_t write_len = (u16_t)LWIP_MIN(size_left, 0xFFFF);
     err_t err = altcp_write(conn->inner_conn, (const void *)dataptr, write_len, apiflags);
     if (err == ERR_OK) {
       written += write_len;
       size_left -= write_len;
+      dataptr += write_len;  /* 修复:更新 dataptr 指针 */
+      printf("[ALTCP_TLS] altcp_mbedtls_bio_send: wrote %u bytes to TCP, total written=%d, remaining=%zu\n", 
+             write_len, written, size_left);
     } else if (err == ERR_MEM) {
+      printf("[ALTCP_TLS] altcp_mbedtls_bio_send: ERR_MEM, written=%d, remaining=%zu\n", written, size_left);
       if (written) {
         return written;
       }
       return 0; /* MBEDTLS_ERR_SSL_WANT_WRITE; */
     } else {
+      printf("[ALTCP_TLS] altcp_mbedtls_bio_send: ERROR: err=%d\n", err);
       LWIP_ASSERT("tls_write, tcp_write: err != ERR MEM", 0);
       /* @todo: return MBEDTLS_ERR_NET_CONN_RESET or MBEDTLS_ERR_NET_SEND_FAILED */
       return MBEDTLS_ERR_NET_SEND_FAILED;
     }
   }
+  printf("[ALTCP_TLS] altcp_mbedtls_bio_send: all %zu bytes sent successfully, total written=%d\n", size, written);
   return written;
 }
 
index 2e767db..2d261e8 100644 (file)
     "\r\n"
 #define HTTPC_REQ_11_PROXY_PORT_FORMAT(host, host_port, uri, srv_name) HTTPC_REQ_11_PROXY_PORT, host, host_port, uri, HTTPC_CLIENT_AGENT, srv_name
 
-//x-www-form-urlencoded
-//application/json
-////////////////////////////////////////post报文///////////////////////////////////////////////////
 /* POST request basic */  
 #define HTTPC_REQ_11_POST "POST %s HTTP/1.1\r\n" /* URI */\
     "User-Agent: %s\r\n" /* User-Agent */ \
       
 #define HTTPC_REQ_11_HOST_FORMAT_POST(uri, srv_name, arglen, args) HTTPC_REQ_11_HOST_POST, uri, HTTPC_CLIENT_AGENT, srv_name, arglen, args
 
-////////////////////////////////////////PUT报文///////////////////////////////////////////////////
 /* PUT request basic */  
 #define HTTPC_REQ_11_PUT "PUT %s HTTP/1.1\r\n" /* URI */\
     "User-Agent: %s\r\n" /* User-Agent */ \
     "%s"
       
 #define HTTPC_REQ_11_FORMAT_PUT(uri, arglen, args)  HTTPC_REQ_11_PUT, uri, HTTPC_CLIENT_AGENT, arglen, args
-      
-//       PUT /api/user HTTP/1.1
-// Host: example.com
-// Content-Type: application/json
-// Content-Length: 123
-
-// {
-// "id": 123,
-// "name": "John Doe",
-// "email": "johndoe@example.com",
-// "age": 30
-// }
+
 /* PUT request with host */
 #define HTTPC_REQ_11_HOST_PUT "PUT %s HTTP/1.1\r\n" /* URI */\
     "User-Agent: %s\r\n" /* User-Agent */ \
       
 #define HTTPC_REQ_11_HOST_FORMAT_PUT(uri, srv_name, arglen, args) HTTPC_REQ_11_HOST_PUT, uri, HTTPC_CLIENT_AGENT, srv_name, arglen, args
 
-
-
 typedef enum ehttpc_parse_state {
   HTTPC_PARSE_WAIT_FIRST_LINE = 0,
   HTTPC_PARSE_WAIT_HEADERS,
   HTTPC_PARSE_RX_DATA
 } httpc_parse_state_t;
 
-typedef struct _httpc_state
+struct _httpc_state
 {
   struct altcp_pcb* pcb;
   ip_addr_t remote_addr;
@@ -217,7 +200,8 @@ typedef struct _httpc_state
   char* server_name;
   char* uri;
 #endif
-} httpc_state_t;
+};
+/* httpc_state_t is typedef'd in http_client.h */
 
 /** Free http client state and deallocate all resources within */
 static err_t
@@ -349,10 +333,25 @@ httpc_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t r)
   httpc_state_t* req = (httpc_state_t*)arg;
   LWIP_UNUSED_ARG(r);
 
+  /* 添加日志:记录数据接收 */
+  if (p != NULL) {
+    printf("[HTTP_CLIENT] httpc_tcp_recv: received data, len=%u, tot_len=%u, parse_state=%d, err=%d\n", 
+           p->len, p->tot_len, req ? req->parse_state : -1, r);
+    LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: received data, len=%u, tot_len=%u, parse_state=%d, err=%d\n", 
+                               p->len, p->tot_len, req ? req->parse_state : -1, r));
+  } else {
+    printf("[HTTP_CLIENT] httpc_tcp_recv: pbuf is NULL, parse_state=%d, err=%d\n", 
+           req ? req->parse_state : -1, r);
+    LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: pbuf is NULL, parse_state=%d, err=%d\n", 
+                               req ? req->parse_state : -1, r));
+  }
+
   if (p == NULL) {
     httpc_result_t result;
     if (req->parse_state != HTTPC_PARSE_RX_DATA) {
       /* did not get RX data yet */
+      printf("[HTTP_CLIENT] httpc_tcp_recv: connection closed before receiving data, parse_state=%d\n", req->parse_state);
+      LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: connection closed before receiving data, parse_state=%d\n", req->parse_state));
       result = HTTPC_RESULT_ERR_CLOSED;
     } else if ((req->hdr_content_len != HTTPC_CONTENT_LEN_INVALID) &&
       (req->hdr_content_len != req->rx_content_len)) {
@@ -368,15 +367,26 @@ httpc_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t r)
   if (req->parse_state != HTTPC_PARSE_RX_DATA) {
     if (req->rx_hdrs == NULL) {
       req->rx_hdrs = p;
+      printf("[HTTP_CLIENT] httpc_tcp_recv: first header pbuf received, len=%u\n", p ? p->tot_len : 0);
+      LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: first header pbuf received, len=%u\n", p ? p->tot_len : 0));
     } else {
       pbuf_cat(req->rx_hdrs, p);
+      printf("[HTTP_CLIENT] httpc_tcp_recv: header pbuf concatenated, total_len=%u\n", req->rx_hdrs ? req->rx_hdrs->tot_len : 0);
+      LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: header pbuf concatenated, total_len=%u\n", req->rx_hdrs ? req->rx_hdrs->tot_len : 0));
     }
     if (req->parse_state == HTTPC_PARSE_WAIT_FIRST_LINE) {
       u16_t status_str_off;
       err_t err = http_parse_response_status(req->rx_hdrs, &req->rx_http_version, &req->rx_status, &status_str_off);
       if (err == ERR_OK) {
         /* don't care status string */
+        printf("[HTTP_CLIENT] httpc_tcp_recv: HTTP status line parsed, version=0x%04x, status=%u\n", 
+               req->rx_http_version, req->rx_status);
+        LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: HTTP status line parsed, version=0x%04x, status=%u\n", 
+                                   req->rx_http_version, req->rx_status));
         req->parse_state = HTTPC_PARSE_WAIT_HEADERS;
+      } else {
+        printf("[HTTP_CLIENT] httpc_tcp_recv: failed to parse HTTP status line, err=%d\n", err);
+        LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: failed to parse HTTP status line, err=%d\n", err));
       }
     }
     if (req->parse_state == HTTPC_PARSE_WAIT_HEADERS) {
@@ -384,12 +394,18 @@ httpc_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t r)
       err_t err = http_wait_headers(req->rx_hdrs, &req->hdr_content_len, &total_header_len);
       if (err == ERR_OK) {
         struct pbuf *q;
+        printf("[HTTP_CLIENT] httpc_tcp_recv: all headers received, total_len=%u, content_len=%u\n", 
+               total_header_len, req->hdr_content_len);
+        LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: all headers received, total_len=%u, content_len=%u\n", 
+                                   total_header_len, req->hdr_content_len));
         /* full header received, send window update for header bytes and call into client callback */
         altcp_recved(pcb, total_header_len);
         if (req->conn_settings) {
           if (req->conn_settings->headers_done_fn) {
             err = req->conn_settings->headers_done_fn(req, req->callback_arg, req->rx_hdrs, total_header_len, req->hdr_content_len);
             if (err != ERR_OK) {
+              printf("[HTTP_CLIENT] httpc_tcp_recv: headers_done_fn returned error, err=%d\n", err);
+              LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: headers_done_fn returned error, err=%d\n", err));
               return httpc_close(req, HTTPC_RESULT_LOCAL_ABORT, req->rx_status, err);
             }
           }
@@ -400,6 +416,13 @@ httpc_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t r)
         req->rx_hdrs = NULL;
         /* go on with data */
         req->parse_state = HTTPC_PARSE_RX_DATA;
+        printf("[HTTP_CLIENT] httpc_tcp_recv: switched to RX_DATA state, remaining pbuf=%p\n", p);
+        LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: switched to RX_DATA state, remaining pbuf=%p\n", p));
+      } else {
+        printf("[HTTP_CLIENT] httpc_tcp_recv: waiting for more header data, current_len=%u\n", 
+               req->rx_hdrs ? req->rx_hdrs->tot_len : 0);
+        LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: waiting for more header data, current_len=%u\n", 
+                                   req->rx_hdrs ? req->rx_hdrs->tot_len : 0));
       }
     }
   }
@@ -409,7 +432,7 @@ httpc_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t r)
       /* directly return here: the connection migth already be aborted from the callback! */
       err_t error=req->recv_fn(req->callback_arg, pcb, p, r);
       if (req->conn_settings && req->conn_settings->file_rx_fn) {
-          req->conn_settings->file_rx_fn(req,p->tot_len,req->rx_content_len); 
+          req->conn_settings->file_rx_fn(req, p->tot_len, req->rx_content_len); 
       }
       return error;
     } else {
@@ -477,12 +500,21 @@ httpc_tcp_connected(void *arg, struct altcp_pcb *pcb, err_t err)
   LWIP_UNUSED_ARG(pcb);
   LWIP_UNUSED_ARG(err);
 
+  /* 添加日志:确认HTTP请求发送时机(应该在TLS握手成功后) */
+  printf("[HTTP_CLIENT] httpc_tcp_connected: sending HTTP request, len=%u\n", req->request ? req->request->len - 1 : 0);
+  LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_connected: sending HTTP request, len=%u\n", req->request ? req->request->len - 1 : 0));
+
   /* send request; last char is zero termination */
   r = altcp_write(req->pcb, req->request->payload, req->request->len - 1, TCP_WRITE_FLAG_COPY);
   if (r != ERR_OK) {
      /* could not write the single small request -> fail, don't retry */
+     printf("[HTTP_CLIENT] httpc_tcp_connected: altcp_write failed, err=%d\n", r);
+     LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_connected: altcp_write failed, err=%d\n", r));
      return httpc_close(req, HTTPC_RESULT_ERR_MEM, 0, r);
   }
+  printf("[HTTP_CLIENT] httpc_tcp_connected: HTTP request sent successfully, calling altcp_output\n");
+  LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_connected: HTTP request sent successfully, calling altcp_output\n"));
+  
   /* everything written, we can free the request */
   pbuf_free(req->request);
   req->request = NULL;
@@ -566,7 +598,6 @@ static int
 httpc_create_request_string(const httpc_connection_t *settings, const char* server_name, int server_port, const char* uri,
                             int use_host, char *buffer, size_t buffer_size)
 {
-  //  printf("httpc_create_request_string  use_post %d use_proxy %d use_host %d \r\n",settings->use_post,settings->use_proxy,use_host);
   if (settings->use_proxy) {
     LWIP_ASSERT("server_name != NULL", server_name != NULL);
     if (server_port != HTTP_DEFAULT_PORT)
@@ -582,29 +613,24 @@ httpc_create_request_string(const httpc_connection_t *settings, const char* serv
 
     if (settings->use_post)
     {
-                 return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT_POST(uri, server_name, settings->arglen, settings->args));
-      // printf("%s\r\n",buffer);
-         }
+      return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT_POST(uri, server_name, settings->arglen, settings->args));
+    }
     if (settings->use_put)
     {
-                 return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT_PUT(uri, server_name, settings->arglen, settings->args));
-      // printf("%s\r\n",buffer);
-         }
+      return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT_PUT(uri, server_name, settings->arglen, settings->args));
+    }
 
     return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT(uri, server_name));
   } 
   else 
   {
-
-     if (settings->use_put)
+    if (settings->use_put)
     {
-                 return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT_PUT(uri, server_name, settings->arglen, settings->args));
-      // printf("%s\r\n",buffer);
-         }
+      return snprintf(buffer, buffer_size, HTTPC_REQ_11_FORMAT_PUT(uri, settings->arglen, settings->args));
+    }
 
     if (settings->use_post){
-       return snprintf(buffer, buffer_size, HTTPC_REQ_11_FORMAT_POST(uri, settings->arglen, settings->args));
-      
+      return snprintf(buffer, buffer_size, HTTPC_REQ_11_FORMAT_POST(uri, settings->arglen, settings->args));
     }
     return snprintf(buffer, buffer_size, HTTPC_REQ_11_FORMAT(uri));
   }
index 8a06308..0a5be60 100644 (file)
@@ -121,6 +121,7 @@ typedef void (*httpc_result_fn)(void *arg, httpc_result_t httpc_result, u32_t rx
  * @return if != ERR_OK is returned, the connection is aborted
  */
 typedef err_t (*httpc_headers_done_fn)(httpc_state_t *connection, void *arg, struct pbuf *hdr, u16_t hdr_len, u32_t content_len);
+typedef err_t (*httpc_file_rx_fn)(httpc_state_t *connection, u32_t rx_len, u32_t rx_total_len);
 
 typedef struct _httpc_connection {
   ip_addr_t proxy_addr;
@@ -137,6 +138,15 @@ typedef struct _httpc_connection {
   /* this callback is called after receiving the http headers
      It can abort the connection by returning != ERR_OK */
   httpc_headers_done_fn headers_done_fn;
+
+  /* this callback is called after receiving some bytes of download file */
+  httpc_file_rx_fn file_rx_fn;
+  
+  /* POST/PUT support */
+  u8_t  use_post;
+  u8_t  use_put;
+  u16_t arglen;
+  u8_t* args;
 } httpc_connection_t;
 
 err_t httpc_get_file(const ip_addr_t* server_addr, u16_t port, const char* uri, const httpc_connection_t *settings,
index e0a1ac9..cd1bbda 100644 (file)
@@ -72,6 +72,7 @@
 #include "osal_wait.h"  // 包含 osal_msleep 函数
 #include "lwip/ip6_addr.h"
 #include "lwip/netif.h"
+#include "lwip/tcpip.h"  // 包含 tcpip_input,用于线程安全的数据包处理
 #include <los_task.h>
 #include <los_typedef.h>
 #include "custom_utils.h"
@@ -528,11 +529,6 @@ slipif_rxbyte_input(struct netif *netif, u8_t c)
     return;
   }
   
-  if (netif->input == NULL) {
-    LWIP_DEBUGF(SLIP_DEBUG, ("ERROR: slipif_rxbyte_input: netif->input is NULL\n"));
-    return;
-  }
-  
   LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: processing byte 0x%02x\n", c));
   
   struct pbuf *p;
@@ -541,14 +537,19 @@ slipif_rxbyte_input(struct netif *netif, u8_t c)
     LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: complete packet received, length=%d\n", p->tot_len));
     g_slipif_error_stats.packets_received++;
     g_slipif_error_stats.bytes_received += p->tot_len;
-    if (netif->input(p, netif) != ERR_OK) {
-      LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: netif->input failed, freeing pbuf\n"));
+    
+    /* 使用 tcpip_input 进行线程安全的数据包处理
+     * 这样数据包处理在 tcpip 线程的栈上执行,而不是在当前线程的栈上
+     */
+    err_t input_result = tcpip_input(p, netif);
+    if (input_result != ERR_OK) {
+      LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: tcpip_input failed (ret=%d), freeing pbuf\n", input_result));
       g_slipif_error_stats.netif_input_fail_count++;
       g_slipif_error_stats.packets_dropped++;
       g_slipif_error_stats.bytes_dropped += p->tot_len;
       pbuf_free(p);
     } else {
-      LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: packet sent to IP layer successfully\n"));
+      LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: packet queued to tcpip thread successfully\n"));
     }
   }
 }
@@ -607,13 +608,18 @@ slipif_loop_thread(void *nf)
       }
       /* 有残留数据:继续处理 */
     } else {
-      /* 信号量触发:有数据到达,处理队列 */
+      /* 信号量触发:有数据到达,处理队列
+       * 注意:由于使用了 tcpip_input,数据包处理在 tcpip 线程的栈上执行,
+       * 不会在 slipif_loop_thread 的栈上累积,所以可以安全地批量处理
+       */
       u16_t processed_count = slipif_process_rxqueue(netif);
       
-      /* 如果处理了数据包,继续处理队列直到清空(批量处理提高效率) */
+      /* 如果处理了数据包,继续处理队列直到清空(批量处理提高效率)
+       * 由于使用了 tcpip_input,不会导致栈溢出,可以安全地批量处理
+       */
       while (processed_count > 0) {
         processed_count = slipif_process_rxqueue(netif);
-        /* 如果队列还有数据,继续处理(不休眠) */
+        /* 如果队列还有数据,继续处理 */
         if (processed_count == 0) {
           break;  // 队列已清空,退出循环等待下一个信号量
         }
@@ -923,7 +929,10 @@ slipif_process_rxqueue(struct netif *netif)
   }
   
   u16_t processed_count = 0;
-  const u16_t MAX_PACKETS_PER_CALL = 10;  // 防止一次处理过多数据包
+  /* 由于使用了 tcpip_input,数据包处理在 tcpip 线程的栈上执行,
+   * 不会在 slipif_loop_thread 的栈上累积,所以可以安全地处理更多包
+   */
+  const u16_t MAX_PACKETS_PER_CALL = 20;  // 可以处理更多包,因为不会导致栈溢出
   
   while (priv->rxpackets != NULL && processed_count < MAX_PACKETS_PER_CALL) {
     struct pbuf *p = priv->rxpackets;
@@ -949,19 +958,28 @@ slipif_process_rxqueue(struct netif *netif)
     
     // LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: processing pbuf 0x%p, length=%d\n", q, q->tot_len));
     
-    /* 释放锁,避免在 netif->input 中长时间持有锁 */
+    /* 释放锁,避免在数据包处理中长时间持有锁 */
     sys_mutex_unlock(&priv->rxqueue_mutex);
     
     g_slipif_error_stats.packets_received++;
     g_slipif_error_stats.bytes_received += q->tot_len;
-    if (netif->input(q, netif) != ERR_OK) {
-      LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: netif->input failed, freeing pbuf\n"));
+    
+    /* 使用 tcpip_input 进行线程安全的数据包处理
+     * 这是从设计上解决栈溢出问题的关键:
+     * - tcpip_input 会将数据包放入 tcpip 线程的消息队列
+     * - 数据包处理在 tcpip 线程的栈上执行,而不是在 slipif_loop_thread 的栈上
+     * - 这样避免了在 slipif_loop_thread 栈上累积很深的调用链
+     * - 即使处理大量数据包,也不会导致 slipif_loop_thread 栈溢出
+     */
+    err_t input_result = tcpip_input(q, netif);
+    if (input_result != ERR_OK) {
+      LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: tcpip_input failed (ret=%d), freeing pbuf\n", input_result));
       g_slipif_error_stats.netif_input_fail_count++;
       g_slipif_error_stats.packets_dropped++;
       g_slipif_error_stats.bytes_dropped += q->tot_len;
       pbuf_free(q);
     } else {
-      // LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: packet sent to IP layer successfully\n"));
+      // LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: packet queued to tcpip thread successfully\n"));
     }
     
     processed_count++;
index 53293b8..25dd5c3 100644 (file)
@@ -46,7 +46,7 @@ ${CMAKE_CURRENT_SOURCE_DIR}/Service/cat1_runtime.c
 ${CMAKE_CURRENT_SOURCE_DIR}/Service/pdu.c
 ${CMAKE_CURRENT_SOURCE_DIR}/Service/cat1_utils.c
 ${CMAKE_CURRENT_SOURCE_DIR}/Service/api_shell.c
-${CMAKE_CURRENT_SOURCE_DIR}/Service/http_client.c
+# ${CMAKE_CURRENT_SOURCE_DIR}/Service/http_client.c  # 使用 lwIP 标准库的 HTTP 客户端
 ${CMAKE_CURRENT_SOURCE_DIR}/Service/sntp.c
 ${CMAKE_CURRENT_SOURCE_DIR}/Service/cat1_server_hal.c
 # ${CMAKE_CURRENT_SOURCE_DIR}/slip/uart_slip.c
index 25328b6..d30a24c 100644 (file)
@@ -62,6 +62,10 @@ extern "C" {
 #include "cat1_utils.h"
 #include "cmsis_os.h"
 
+#include "cmsis_os2.h"
+extern osStatus_t osDelay(uint32_t ticks);
+#define cat1_msleep(ms) osDelay(ms) /* osDelay(1) : 1ms */
+
 static uint8_t g_skip_cat1_service_udp_transfer = 0;
 static f_cat1_msg_callback g_cat1_msg_callback_func=NULL;
 #define PEER_IP "172.16.1.2"
@@ -858,6 +862,22 @@ static int decodeNetStat(char* msg)
         if (g_py_ver >= PY_SRV_VER_SUPORT_PY_OTA_MINI_VER &&  g_py_ver<PY_SRV_VER_CURRENT )
         {
             cat1_print_dbg("start cat1 python ota\n");
+            
+            /* 判断是否需要使用TCP方式升级(g_py_ver > 16使用TCP,否则使用UDP) */
+            if (g_py_ver > 16)
+            {
+                /* TCP方式:先发送1D指令启动CAT1的TCP服务 */
+                cat1_print_dbg("Using TCP mode for OTA, sending 1D command to start TCP service\n");
+                cat1_start_tcp_ota_init();
+                cat1_tcp_server_init();
+                
+                /* 等待TCP服务启动完成(给CAT1一些时间启动TCP服务) */
+                cat1_msleep(2000);  /* 等待2秒,确保TCP服务启动完成 */
+                
+                cat1_print_dbg("TCP service should be ready, starting OTA\n");
+            }
+            
+            /* 开始OTA升级 */
             Cat1_OTA(CAT1_TCP_START_OTA);
         }else{
             cat1_print_dbg("current PyVer %d, mini pyVer %d , local pyVer %d,  skip cat1 python ota!\n",g_py_ver,PY_SRV_VER_SUPORT_PY_OTA_MINI_VER,PY_SRV_VER_CURRENT);
@@ -1590,9 +1610,7 @@ static int udp_socket_init()
 
     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)
 {
     char rx_buffer[512];
index 6074d0c..05f8fea 100644 (file)
@@ -6,7 +6,7 @@ extern "C" {
 #endif /* __cplusplus */
 #include "errcode.h"
 #ifdef SUPPORT_CAT1_SERVICE
-#include "http_client.h"
+#include "lwip/apps/http_client.h"
 #include "lwip/altcp.h"
 
 /* Define httpc_file_rx_fn if not already defined */
index 07fcafd..a78373c 100644 (file)
@@ -20,7 +20,7 @@ struct timezone {
     int tz_dsttime;
 };
 
-uint8_t g_cat1_enable_debug=CAT1_LOG_LEVEL_WARNING;//CAT1_LOG_LEVEL_MAX;
+uint8_t g_cat1_enable_debug=CAT1_LOG_LEVEL_MAX;//CAT1_LOG_LEVEL_WARNING;//CAT1_LOG_LEVEL_MAX;
 
 static uint16_t g_timezone_quarters = 0xFFFF;
 /**
index 4ac37f2..bbae59a 100644 (file)
@@ -9,25 +9,32 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-#ifndef SUPPORT_CAT1_SERVICE
-
-/**
- * @brief HTTP客户端文件下载桩函数
- * @param url 下载URL
- * @param file_path 本地文件路径
- * @param timeout 超时时间
- * @return 总是返回失败(-1)
- */
-int httpc_get_file_dns_to_disk(const char *url, const char *file_path, int timeout)
-{
-    (void)url;
-    (void)file_path;
-    (void)timeout;
+// /* 检查lwip库是否提供了httpc_get_file_dns_to_disk函数 */
+// /* 如果lwip库可用且启用了HTTP客户端文件IO功能,就不需要桩函数 */
+// #if !defined(LWIP_HTTPC_HAVE_FILE_IO) || (LWIP_HTTPC_HAVE_FILE_IO == 0)
+// #ifndef SUPPORT_CAT1_SERVICE
+
+// /**
+//  * @brief HTTP客户端文件下载桩函数
+//  * @param url 下载URL
+//  * @param file_path 本地文件路径
+//  * @param timeout 超时时间
+//  * @return 总是返回失败(-1)
+//  * 
+//  * 注意:如果lwip库已经提供了httpc_get_file_dns_to_disk函数(LWIP_HTTPC_HAVE_FILE_IO=1),
+//  *       此桩函数不会被编译,以避免符号冲突
+//  */
+// int httpc_get_file_dns_to_disk(const char *url, const char *file_path, int timeout)
+// {
+//     (void)url;
+//     (void)file_path;
+//     (void)timeout;
     
-    // 桩函数 - 不实现实际功能
-    return -1;
-}
-#endif
+//     // 桩函数 - 不实现实际功能
+//     return -1;
+// }
+// #endif
+// #endif /* LWIP_HTTPC_HAVE_FILE_IO */
 
 
 
index cdf3820..bbc62b5 100644 (file)
@@ -24,6 +24,7 @@ set(SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/ln_http_client.c
     ${CMAKE_CURRENT_SOURCE_DIR}/ln_http_download_client.c
     ${CMAKE_CURRENT_SOURCE_DIR}/ln_file_write_queue.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/zhihui_http_client.c
 )
 
 # 公共头文件路径(供其他模块引用)
diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ZHIHUI_HTTP_CLIENT_README.md b/code/sdk/zhihui/leiniao/imsl_ln/ZHIHUI_HTTP_CLIENT_README.md
new file mode 100644 (file)
index 0000000..8478b1f
--- /dev/null
@@ -0,0 +1,203 @@
+# zhihui_http_client 使用说明
+
+## 概述
+
+`zhihui_http_client` 是基于 lwIP 标准 HTTP 客户端的 HTTP/HTTPS 下载实现,支持:
+- HTTP 和 HTTPS 下载
+- SSL/TLS 配置(超时、加密算法等)
+- 性能优化(可配置 SSL 参数以解决超时问题)
+- 与现有 OpenHarmony HttpClient 接口兼容
+
+## 切换实现
+
+在 `ln_api.h` 中通过宏 `LN_HTTP_USE_LWIP_CLIENT` 切换:
+
+```c
+/* 0=使用 OpenHarmony HttpClient(默认) */
+/* 1=使用 lwIP HTTP 客户端 */
+#define LN_HTTP_USE_LWIP_CLIENT 0
+```
+
+## 接口说明
+
+### 基本下载接口
+
+```c
+int zhihui_http_download_file_resume(
+    const char *url,                    // 文件 URL(支持 http:// 和 https://)
+    const char *save_path,              // 保存路径
+    size_t resume_offset,               // 续传偏移量(0 表示从头开始)
+    const zhihui_ssl_config_t *ssl_config,  // SSL 配置(HTTPS 需要,HTTP 可传 NULL)
+    zhihui_http_result_fn result_cb,    // 结果回调函数(可选)
+    zhihui_http_progress_fn progress_cb,// 进度回调函数(可选)
+    void *callback_arg                  // 回调函数参数
+);
+```
+
+### SSL 配置
+
+```c
+typedef struct {
+    const uint8_t *ca_cert;             // CA 证书(PEM 格式),NULL 表示使用默认
+    size_t ca_cert_len;                 // CA 证书长度
+    uint32_t handshake_timeout_ms;      // SSL 握手超时(毫秒),0 表示默认
+    uint32_t read_timeout_ms;           // SSL 读取超时(毫秒),0 表示默认
+    uint32_t write_timeout_ms;          // SSL 写入超时(毫秒),0 表示默认
+    bool skip_cert_verify;              // 是否跳过证书验证(仅用于测试)
+    const int *cipher_suites;           // 加密套件数组(NULL 表示使用默认)
+    int min_tls_version;                // 最小 TLS 版本(0 表示默认)
+    int max_tls_version;                // 最大 TLS 版本(0 表示默认)
+} zhihui_ssl_config_t;
+```
+
+### 使用示例
+
+#### 1. 基本 HTTP 下载
+
+```c
+int ret = zhihui_http_download_file(
+    "http://example.com/file.bin",
+    "/path/to/save/file.bin",
+    NULL,  // HTTP 不需要 SSL 配置
+    NULL,  // 结果回调(可选)
+    NULL,  // 进度回调(可选)
+    NULL   // 回调参数
+);
+```
+
+#### 2. HTTPS 下载(使用默认 SSL 配置)
+
+```c
+const zhihui_ssl_config_t *ssl_config = zhihui_ssl_config_default(true);  // true=跳过验证(测试用)
+int ret = zhihui_http_download_file(
+    "https://example.com/file.bin",
+    "/path/to/save/file.bin",
+    ssl_config,
+    NULL,
+    NULL,
+    NULL
+);
+```
+
+#### 3. HTTPS 下载(自定义 SSL 配置)
+
+```c
+zhihui_ssl_config_t ssl_config = {0};
+zhihui_ssl_config_init(
+    &ssl_config,
+    ca_cert_pem,        // CA 证书(PEM 格式)
+    ca_cert_len,        // CA 证书长度
+    30000,              // 握手超时 30 秒
+    false               // 不跳过验证
+);
+
+/* 配置高性能加密套件(可选) */
+static const int fast_ciphers[] = {
+    MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+    MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+    0  // 结束标记
+};
+ssl_config.cipher_suites = fast_ciphers;
+
+int ret = zhihui_http_download_file(
+    "https://example.com/file.bin",
+    "/path/to/save/file.bin",
+    &ssl_config,
+    NULL,
+    NULL,
+    NULL
+);
+```
+
+## SSL 性能优化
+
+### 1. 调整超时时间
+
+```c
+ssl_config.handshake_timeout_ms = 60000;  // 握手超时 60 秒
+ssl_config.read_timeout_ms = 30000;       // 读取超时 30 秒
+```
+
+### 2. 使用高性能加密套件
+
+```c
+/* 推荐的高性能加密套件(按性能排序) */
+static const int fast_ciphers[] = {
+    MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,      // 最快
+    MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+    MBEDTLS_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+    0
+};
+ssl_config.cipher_suites = fast_ciphers;
+```
+
+### 3. 限制 TLS 版本
+
+```c
+/* 仅使用 TLS 1.2 和 1.3(避免旧版本性能问题) */
+ssl_config.min_tls_version = MBEDTLS_SSL_VERSION_TLS1_2;
+ssl_config.max_tls_version = MBEDTLS_SSL_VERSION_TLS1_3;
+```
+
+## 注意事项
+
+1. **异步操作**:lwIP HTTP 客户端是异步的,下载结果通过回调函数通知。如果需要同步等待,需要在回调中设置信号量或事件。
+
+2. **断点续传**:当前实现中,lwIP HTTP 客户端不支持自定义 Range 头,断点续传功能受限。如果需要完整的断点续传支持,需要扩展 lwIP HTTP 客户端。
+
+3. **SSL 配置**:SSL 配置(超时、加密套件等)需要在创建 TLS 配置时设置。当前实现中,部分高级配置需要通过扩展 `altcp_tls_config` 结构来实现。
+
+4. **编译依赖**:需要启用以下 lwIP 配置:
+   - `LWIP_ALTCP = 1`
+   - `LWIP_ALTCP_TLS = 1`
+   - `LWIP_ALTCP_TLS_MBEDTLS = 1`
+   - `LWIP_TCP = 1`
+   - `LWIP_CALLBACK_API = 1`
+   - `LWIP_DNS = 1`
+
+## 与 OpenHarmony HttpClient 的对比
+
+| 特性 | OpenHarmony HttpClient | lwIP HTTP Client |
+|------|----------------------|------------------|
+| HTTP 支持 | ✅ | ✅ |
+| HTTPS 支持 | ✅ | ✅ |
+| SSL 配置 | 通过结构体字段 | 通过 `zhihui_ssl_config_t` |
+| 超时配置 | 有限 | 可配置握手/读写超时 |
+| 加密算法选择 | 默认 | 可自定义 |
+| 断点续传 | ✅ | ⚠️ 受限 |
+| 同步/异步 | 同步 | 异步 |
+
+## 调试 SSL 超时问题
+
+1. **增加握手超时**:
+   ```c
+   ssl_config.handshake_timeout_ms = 60000;  // 增加到 60 秒
+   ```
+
+2. **使用更快的加密套件**:
+   ```c
+   ssl_config.cipher_suites = fast_ciphers;  // 使用 AES-GCM
+   ```
+
+3. **启用调试日志**:
+   在 `altcp_tls_mbedtls_opts.h` 中启用调试:
+   ```c
+   #define ALTCP_MBEDTLS_DEBUG LWIP_DBG_ON
+   #define ALTCP_MBEDTLS_LIB_DEBUG LWIP_DBG_ON
+   ```
+
+4. **检查网络延迟**:
+   使用 ping 或 traceroute 检查到服务器的网络延迟。
+
+## TODO
+
+- [ ] 扩展 lwIP HTTP 客户端支持自定义 Range 头(断点续传)
+- [ ] 实现同步等待机制(信号量/事件)
+- [ ] 扩展 `altcp_tls_config` 以支持更多 SSL 配置选项
+- [ ] 添加 SSL 性能统计(握手时间、传输速度等)
+
+
+
+
+
+
index 741a8c7..df67b43 100644 (file)
@@ -482,6 +482,11 @@ int uapi_ln_download_file(const char *url, const char *save_path)
     int ret = -1;
     size_t total_written = 0;
     // 打开文件准备写入
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+    /* 测试模式:不打开文件 */
+    FILE *fd = NULL;
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] Test mode: skip file open");
+#else
     FILE *fd = fopen(save_path, "wb+");
     if (!fd)
     {
@@ -495,12 +500,15 @@ int uapi_ln_download_file(const char *url, const char *save_path)
     {
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] setvbuf failed, using default buffer");
     }
+#endif
 
     HTTPC_RESULT prep = ln_http_prepare_auto(&client_data, 2048, LN_CLIENT_PREPARE_SIZE * 2);
     if (prep != HTTP_SUCCESS)
     {
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] prepare failed: %d", prep);
+#if !LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
         fclose(fd);
+#endif
         g_ln_is_file_downloading = 0;
         return ERRCODE_FAIL;
     }
@@ -510,7 +518,9 @@ int uapi_ln_download_file(const char *url, const char *save_path)
     if (ret != 0)
     {
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] connection failed, ret=0x%x", ret);
+#if !LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
         fclose(fd);
+#endif
         HttpClientUnprepare(&client_data);
         g_ln_is_file_downloading = 0;
         return ERRCODE_FAIL;
@@ -521,22 +531,51 @@ int uapi_ln_download_file(const char *url, const char *save_path)
     if (ret != 0)
     {
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] send request failed, ret=0x%x", ret);
+#if !LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
         fclose(fd);
+#endif
         HttpClientClse(&client);
         HttpClientUnprepare(&client_data);
         g_ln_is_file_downloading = 0;
         return ERRCODE_FAIL;
     }
 
+    /* 性能统计变量 */
+    uint32_t download_start_time_ms = 0;
+    uint32_t total_recv_time_ms = 0;
+    uint32_t total_write_time_ms = 0;
+    size_t total_bytes_received = 0;
+    int packet_count = 0;
+    
+    /* 记录下载开始时间 */
+    extern uint32_t uapi_tcxo_get_ms(void);
+    download_start_time_ms = uapi_tcxo_get_ms();
+    
     // 接收响应数据
     do
     {
+        uint32_t recv_start_time_ms = uapi_tcxo_get_ms();
         HTTPC_RESULT recv_res = HttpClientRecvResponse(&client, &client_data);
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] recv_res = %d", recv_res);
+        uint32_t recv_end_time_ms = uapi_tcxo_get_ms();
+        uint32_t recv_duration_ms = 0;
+        if (recv_end_time_ms >= recv_start_time_ms) {
+            recv_duration_ms = recv_end_time_ms - recv_start_time_ms;
+        } else {
+            recv_duration_ms = (0xFFFFFFFF - recv_start_time_ms) + recv_end_time_ms + 1;
+        }
+        total_recv_time_ms += recv_duration_ms;
+        
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] recv_res = %d, recv_duration=%ums", recv_res, recv_duration_ms);
         if (recv_res == HTTP_SUCCESS || recv_res == HTTP_EAGAIN)
         {
             if (client_data.contentBlockLen > 0)
             {
+                total_bytes_received += client_data.contentBlockLen;
+                uint32_t write_start_time_ms = uapi_tcxo_get_ms();
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+                /* 测试模式:只统计不写入 */
+                size_t written = client_data.contentBlockLen;  /* 模拟写入成功 */
+#else
                 size_t written = fwrite(client_data.responseBuf, 1, client_data.contentBlockLen, fd);
                 WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] written = %zu", written);
                 if (written != client_data.contentBlockLen)
@@ -548,7 +587,23 @@ int uapi_ln_download_file(const char *url, const char *save_path)
                     HttpClientUnprepare(&client_data);
                     return ERRCODE_FAIL;
                 }
+#endif
+                uint32_t write_end_time_ms = uapi_tcxo_get_ms();
+                uint32_t write_duration_ms = 0;
+                if (write_end_time_ms >= write_start_time_ms) {
+                    write_duration_ms = write_end_time_ms - write_start_time_ms;
+                } else {
+                    write_duration_ms = (0xFFFFFFFF - write_start_time_ms) + write_end_time_ms + 1;
+                }
+                total_write_time_ms += write_duration_ms;
+                
                 total_written += written;
+                packet_count++;
+                
+                /* 打印性能日志 */
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                             "[DOWNLOAD_PERF] packet=%d, data_len=%d, recv_duration=%ums, write_duration=%ums", 
+                             packet_count, client_data.contentBlockLen, recv_duration_ms, write_duration_ms);
             }
         }
         else
@@ -557,6 +612,59 @@ int uapi_ln_download_file(const char *url, const char *save_path)
             break;
         }
     } while (client_data.isMore);
+    
+    /* 计算下载总耗时和性能统计 */
+    uint32_t download_end_time_ms = uapi_tcxo_get_ms();
+    uint32_t total_download_time_ms = 0;
+    if (download_end_time_ms >= download_start_time_ms) {
+        total_download_time_ms = download_end_time_ms - download_start_time_ms;
+    } else {
+        total_download_time_ms = (0xFFFFFFFF - download_start_time_ms) + download_end_time_ms + 1;
+    }
+    
+    /* 计算网络速度(KB/s) */
+    float network_speed_kbps = 0.0f;
+    float recv_speed_kbps = 0.0f;
+    float write_speed_kbps = 0.0f;
+    if (total_download_time_ms > 0) {
+        network_speed_kbps = (total_bytes_received * 1000.0f) / (total_download_time_ms * 1024.0f);
+    }
+    if (total_recv_time_ms > 0) {
+        recv_speed_kbps = (total_bytes_received * 1000.0f) / (total_recv_time_ms * 1024.0f);
+    }
+    if (total_write_time_ms > 0 && total_bytes_received > 0) {
+        write_speed_kbps = (total_bytes_received * 1000.0f) / (total_write_time_ms * 1024.0f);
+    }
+    
+    /* 打印性能统计报告 */
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] =========================================");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 总下载时间: %u ms (%.2f 秒)", 
+                 total_download_time_ms, total_download_time_ms / 1000.0f);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 总接收字节: %zu bytes (%.2f KB)", 
+                 total_bytes_received, total_bytes_received / 1024.0f);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 总接收耗时: %u ms (%.2f%% 总时间)", 
+                 total_recv_time_ms, (total_download_time_ms > 0) ? (total_recv_time_ms * 100.0f / total_download_time_ms) : 0.0f);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 总写入耗时: %u ms (%.2f%% 总时间)", 
+                 total_write_time_ms, (total_download_time_ms > 0) ? (total_write_time_ms * 100.0f / total_download_time_ms) : 0.0f);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 平均网络速度: %.2f KB/s", network_speed_kbps);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 平均接收速度: %.2f KB/s", recv_speed_kbps);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 平均写入速度: %.2f KB/s", write_speed_kbps);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 数据包数量: %d", packet_count);
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 测试模式: 只统计不写入文件");
+#endif
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] =========================================");
 
     if (client_data.responseContentLen == 0)
     {
@@ -571,6 +679,7 @@ int uapi_ln_download_file(const char *url, const char *save_path)
     else
     {
         ret = ERRCODE_FAIL;
+#if !LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] 文件下载失败删除不完整文件,save_path = %s", save_path);
         int ret = 0;
         ret = unlink(save_path);
@@ -582,11 +691,18 @@ int uapi_ln_download_file(const char *url, const char *save_path)
         {
             WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "删除不完整文件成功\r\n");
         }
+#else
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] 文件下载失败 (测试模式,不删除文件)");
+#endif
     }
 
     HttpClientUnprepare(&client_data);
     HttpClientClse(&client);
+#if !LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
     fclose(fd);
+#else
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] Test mode: skip file close");
+#endif
     g_ln_is_file_downloading = 0;
 
 #if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE)
@@ -631,8 +747,37 @@ int uapi_ln_download_with_retry(const char *url, const char *save_path, int max_
 @param save_path 保存路径(若存在则尝试从已下载大小处续传)
 @return ERRCODE_SUCC 成功,ERRCODE_FAIL 失败(失败不删除部分文件)
 */
+#if LN_HTTP_USE_LWIP_CLIENT
+#include "zhihui_http_client.h"
+#endif
+
 int uapi_ln_download_file_resume(const char *url, const char *save_path)
 {
+#if LN_HTTP_USE_LWIP_CLIENT
+    /* 使用 lwIP HTTP 客户端实现 */
+    long long resume_offset = 0;
+    /* 判断是否存在部分文件,计算续传偏移 */
+    {
+        FILE *fexist = fopen(save_path, "rb");
+        if (fexist)
+        {
+            if (fseek(fexist, 0, SEEK_END) == 0)
+            {
+                long pos = ftell(fexist);
+                if (pos > 0)
+                    resume_offset = (long long)pos;
+            }
+            fclose(fexist);
+        }
+    }
+    
+    /* 使用默认 SSL 配置(跳过验证,仅用于测试) */
+    const zhihui_ssl_config_t *ssl_config = zhihui_ssl_config_default(true);
+    
+    /* 调用 lwIP HTTP 客户端 */
+    return zhihui_http_download_file_resume(url, save_path, (size_t)resume_offset, ssl_config, NULL, NULL, NULL);
+#else
+    /* 使用 OpenHarmony HttpClient 实现(原有实现) */
     if (!url || !save_path)
     {
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] url or save_path is NULL");
@@ -677,6 +822,16 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
     int ret = -1;
     size_t total_written = 0;
     
+    /* 性能统计变量 */
+    uint32_t download_start_time_ms = 0;
+    uint32_t total_recv_time_ms = 0;
+    uint32_t total_write_time_ms = 0;
+    size_t total_bytes_received = 0;
+    
+    /* 记录下载开始时间 */
+    extern uint32_t uapi_tcxo_get_ms(void);
+    download_start_time_ms = uapi_tcxo_get_ms();
+    
 #if LN_HTTP_DOWNLOAD_USE_QUEUE
     /* 文件句柄和写入上下文(用于异步写入) */
     FILE *fd = NULL;
@@ -690,6 +845,12 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
     int is_first_packet = 1;  /* 是否为第一包 */
 #else
     /* 直接写文件模式:打开文件 */
+    int packet_count = 0;  /* 数据包计数 */
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+    /* 测试模式:不打开文件 */
+    FILE *fd = NULL;
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode: skip file open");
+#else
     const char *open_mode = resume_offset > 0 ? "ab+" : "wb+";
     FILE *fd = fopen(save_path, open_mode);
     if (!fd)
@@ -705,6 +866,7 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
     }
     
     /* 如果续传,文件已打开在末尾位置,无需额外操作 */
+#endif
 #endif
 
     if(resume_offset > 0)
@@ -749,6 +911,29 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] set header %s", header_buf);
     }
 
+    /* 根据URL判断HTTP/HTTPS并设置客户端参数 */
+    if (url)
+    {
+        if (strncmp(url, "https://", 8) == 0)
+        {
+            client.isHttp = false;  /* HTTPS */
+            client.remotePort = 443;
+        }
+        else if (strncmp(url, "http://", 7) == 0)
+        {
+            client.isHttp = true;   /* HTTP */
+            client.remotePort = 80;
+        }
+        else
+        {
+            /* 默认使用HTTPS */
+            client.isHttp = false;
+            client.remotePort = 443;
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] URL协议未知,默认使用HTTPS: %s", url);
+        }
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] URL=%s, isHttp=%d, port=%d", url, client.isHttp, client.remotePort);
+    }
+
     /* 建立连接并发送请求 */
     ret = HttpClientConn(&client, url);
     if (ret != 0)
@@ -802,6 +987,10 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
             write_ctx.total_written = 0;
             write_ctx.ref_count = 0;
             is_first_packet = 1;
+#else
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+            /* 测试模式:不重新打开文件 */
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode: skip file reopen");
 #else
             /* 重新打开文件为覆盖模式 */
             fclose(fd);
@@ -818,14 +1007,20 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
             {
                 WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] setvbuf failed, using default buffer");
             }
+#endif
 #endif
         }
 
         /* 写入首块内容(若有)*/
         if (client_data.contentBlockLen > 0)
         {
+            uint32_t write_start_time_ms = uapi_tcxo_get_ms();
 #if LN_HTTP_DOWNLOAD_USE_QUEUE
             const char *open_mode = resume_offset > 0 ? "ab+" : "wb+";
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+            /* 测试模式:只统计不写入 */
+            errcode_t write_ret = ERRCODE_SUCC;  /* 模拟成功 */
+#else
             errcode_t write_ret = ln_file_write_queue_add_task(
                 &fd,
                 &write_ctx,
@@ -844,12 +1039,26 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
                 HttpClientUnprepare(&client_data);
                 return ERRCODE_FAIL;
             }
+#endif
+            uint32_t write_end_time_ms = uapi_tcxo_get_ms();
+            uint32_t write_duration_ms = 0;
+            if (write_end_time_ms >= write_start_time_ms) {
+                write_duration_ms = write_end_time_ms - write_start_time_ms;
+            } else {
+                write_duration_ms = (0xFFFFFFFF - write_start_time_ms) + write_end_time_ms + 1;
+            }
+            total_write_time_ms += write_duration_ms;
             
             total_written += client_data.contentBlockLen;
+            total_bytes_received += client_data.contentBlockLen;
             packet_count++;
             is_first_packet = 0;
 #else
             /* 直接写入文件 */
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+            /* 测试模式:只统计不写入 */
+            size_t written = client_data.contentBlockLen;  /* 模拟写入成功 */
+#else
             size_t written = fwrite(client_data.responseBuf, 1, client_data.contentBlockLen, fd);
             if (written != client_data.contentBlockLen)
             {
@@ -861,7 +1070,18 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
                 HttpClientUnprepare(&client_data);
                 return ERRCODE_FAIL;
             }
+#endif
+            uint32_t write_end_time_ms = uapi_tcxo_get_ms();
+            uint32_t write_duration_ms = 0;
+            if (write_end_time_ms >= write_start_time_ms) {
+                write_duration_ms = write_end_time_ms - write_start_time_ms;
+            } else {
+                write_duration_ms = (0xFFFFFFFF - write_start_time_ms) + write_end_time_ms + 1;
+            }
+            total_write_time_ms += write_duration_ms;
+            
             total_written += written;
+            total_bytes_received += client_data.contentBlockLen;
 #endif
         }
     }
@@ -889,7 +1109,35 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
         }
 #endif
         
+        /* 记录接收开始时间 */
+        extern uint32_t uapi_tcxo_get_ms(void);
+        uint32_t recv_start_time_ms = uapi_tcxo_get_ms();
+        
         HTTPC_RESULT recv_res = HttpClientRecvResponse(&client, &client_data);
+        
+        /* 记录接收结束时间并计算耗时 */
+        uint32_t recv_end_time_ms = uapi_tcxo_get_ms();
+        uint32_t recv_duration_ms = 0;
+        if (recv_end_time_ms >= recv_start_time_ms) {
+            recv_duration_ms = recv_end_time_ms - recv_start_time_ms;
+        } else {
+            /* 处理时间戳溢出 */
+            recv_duration_ms = (0xFFFFFFFF - recv_start_time_ms) + recv_end_time_ms + 1;
+        }
+        
+        /* 累计接收耗时和接收字节数 */
+        total_recv_time_ms += recv_duration_ms;
+        if (client_data.contentBlockLen > 0) {
+            total_bytes_received += client_data.contentBlockLen;
+        }
+        
+#if LN_HTTP_DOWNLOAD_USE_QUEUE
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] recv_res=%d, isMore=%d, contentBlockLen=%d, total_written=%zu, ref_count=%u, recv_duration=%ums", 
+                     recv_res, client_data.isMore, client_data.contentBlockLen, total_written, write_ctx.ref_count, recv_duration_ms);
+#else
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] recv_res=%d, isMore=%d, contentBlockLen=%d, total_written=%zu, recv_duration=%ums", 
+                     recv_res, client_data.isMore, client_data.contentBlockLen, total_written, recv_duration_ms);
+#endif
         if (recv_res == HTTP_SUCCESS || recv_res == HTTP_EAGAIN)
         {
             if (client_data.contentBlockLen > 0)
@@ -898,6 +1146,21 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
                 /* 判断是否为最后一包 */
                 int is_last = (!client_data.isMore) ? 1 : 0;
                 
+                /* 记录入队前时间 */
+                uint32_t enqueue_start_time_ms = uapi_tcxo_get_ms();
+                
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+                /* 测试模式:只统计不写入 */
+                errcode_t write_ret = ERRCODE_SUCC;  /* 模拟成功 */
+                uint32_t enqueue_end_time_ms = uapi_tcxo_get_ms();
+                uint32_t enqueue_duration_ms = 0;
+                if (enqueue_end_time_ms >= enqueue_start_time_ms) {
+                    enqueue_duration_ms = enqueue_end_time_ms - enqueue_start_time_ms;
+                } else {
+                    enqueue_duration_ms = (0xFFFFFFFF - enqueue_start_time_ms) + enqueue_end_time_ms + 1;
+                }
+                total_write_time_ms += enqueue_duration_ms;
+#else
                 /* 使用异步写入队列 */
                 errcode_t write_ret = ln_file_write_queue_add_task(
                     &fd,
@@ -910,6 +1173,17 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
                     is_last  /* is_last_packet */
                 );
                 
+                /* 记录入队后时间并计算入队耗时 */
+                uint32_t enqueue_end_time_ms = uapi_tcxo_get_ms();
+                uint32_t enqueue_duration_ms = 0;
+                if (enqueue_end_time_ms >= enqueue_start_time_ms) {
+                    enqueue_duration_ms = enqueue_end_time_ms - enqueue_start_time_ms;
+                } else {
+                    /* 处理时间戳溢出 */
+                    enqueue_duration_ms = (0xFFFFFFFF - enqueue_start_time_ms) + enqueue_end_time_ms + 1;
+                }
+                total_write_time_ms += enqueue_duration_ms;
+                
                 if (write_ret != ERRCODE_SUCC) {
                     WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Failed to add write task");
                     if (header_buf) free(header_buf);
@@ -918,10 +1192,16 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
                     HttpClientUnprepare(&client_data);
                     return ERRCODE_FAIL;
                 }
+#endif
                 
                 total_written += client_data.contentBlockLen;
                 packet_count++;
                 
+                /* 打印下载性能分析日志:接收耗时、入队耗时 */
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                             "[DOWNLOAD_PERF] packet=%d, data_len=%d, recv_duration=%ums, enqueue_duration=%ums", 
+                             packet_count, client_data.contentBlockLen, recv_duration_ms, enqueue_duration_ms);
+                
                 /* 检查写入错误 */
                 if (ln_file_write_queue_get_status(&write_ctx) == LN_FILE_WRITE_STATUS_ERROR) {
                     WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Write error detected");
@@ -936,6 +1216,11 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
                              total_written, packet_count);
 #else
                 /* 直接写入文件 */
+                uint32_t write_start_time_ms = uapi_tcxo_get_ms();
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+                /* 测试模式:只统计不写入 */
+                size_t written = client_data.contentBlockLen;  /* 模拟写入成功 */
+#else
                 size_t written = fwrite(client_data.responseBuf, 1, client_data.contentBlockLen, fd);
                 if (written != client_data.contentBlockLen)
                 {
@@ -947,22 +1232,59 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
                     HttpClientUnprepare(&client_data);
                     return ERRCODE_FAIL;
                 }
+#endif
+                uint32_t write_end_time_ms = uapi_tcxo_get_ms();
+                uint32_t write_duration_ms = 0;
+                if (write_end_time_ms >= write_start_time_ms) {
+                    write_duration_ms = write_end_time_ms - write_start_time_ms;
+                } else {
+                    write_duration_ms = (0xFFFFFFFF - write_start_time_ms) + write_end_time_ms + 1;
+                }
+                total_write_time_ms += write_duration_ms;
+                
                 total_written += written;
+                packet_count++;
+                
+                /* 打印写入性能日志 */
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                             "[DOWNLOAD_PERF] packet=%d, data_len=%d, recv_duration=%ums, write_duration=%ums", 
+                             packet_count, client_data.contentBlockLen, recv_duration_ms, write_duration_ms);
 #endif
             }
         }
         else
         {
-            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] recv failed: %d", recv_res);
-            /* 网络异常,标记下载失败 */
+           
+            /* 网络异常,标记写入队列错误状态,停止继续添加任务 */
+            /* 关键设计改进:设置ERROR状态,但wait_done会等待所有已提交的任务完成(ref_count==0) */
+            /* 这样可以确保文件大小准确,避免重试时offset计算错误 */
+#if LN_HTTP_DOWNLOAD_USE_QUEUE
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] recv failed: %d, isMore=%d, total_written=%zu, ref_count=%u", 
+              recv_res, client_data.isMore, total_written, write_ctx.ref_count);
+            write_ctx.status = LN_FILE_WRITE_STATUS_ERROR;
+            write_ctx.error_code = ERRCODE_FAIL;
+#else
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] recv failed: %d, isMore=%d, total_written=%zu", 
+                recv_res, client_data.isMore, total_written);
+#endif
             break;
         }
     }
 
     int final_code = HttpClientGetResponseCode(&client);
-    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] final code=%d, total_written=%zu", final_code, total_written);
+#if LN_HTTP_DOWNLOAD_USE_QUEUE
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] final code=%d, total_written=%zu, isMore=%d, ref_count=%u, status=%d", 
+                 final_code, total_written, client_data.isMore, write_ctx.ref_count, write_ctx.status);
+#else
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] final code=%d, total_written=%zu, isMore=%d", 
+                 final_code, total_written, client_data.isMore);
+#endif
     
 #if LN_HTTP_DOWNLOAD_USE_QUEUE
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+    /* 测试模式:不等待写入队列 */
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode: skip waiting for write queue");
+#else
     /* 判断下载是否成功:只有HTTP状态码200/206且正常结束才等待文件写入完成 */
     int download_success = ((final_code == 200 || final_code == 206) && client_data.isMore == 0);
     
@@ -974,26 +1296,136 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
             WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Wait for write tasks timeout or error");
         }
     } else {
-        /* ä¸\8b载失败ï¼\88ç½\91ç»\9cå¼\82常ç­\89ï¼\89ï¼\8cä¸\8dç­\89å¾\85æ\96\87ä»¶å\86\99å\85¥å®\8cæ\88\90ï¼\8cç\9b´æ\8e¥å\85³é\97­æ\96\87ä»¶ */
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Download failed (code=%d, isMore=%d), skip waiting for write tasks", 
+        /* ä¸\8b载失败ï¼\88ç½\91ç»\9cå¼\82常ç­\89ï¼\89ï¼\8cä½\86ä»\8dé\9c\80ç­\89å¾\85å\86\99å\85¥é\98\9få\88\97å®\8cæ\88\90ï¼\8cç¡®ä¿\9dæ\96\87件大å°\8få\87\86ç¡®ç\94¨äº\8eé\87\8dè¯\95 */
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Download failed (code=%d, isMore=%d), waiting for write tasks to complete...", 
                      final_code, client_data.isMore);
+        /* 等待写入队列完成,使用较长的超时时间(30秒),确保所有任务都完成(ref_count==0) */
+        errcode_t wait_ret = ln_file_write_queue_wait_done(&write_ctx, 30000);  /* 最多等待30秒 */
+        if (wait_ret != ERRCODE_SUCC) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Wait for write tasks timeout after 30s, status=%d, ref_count=%u, but continue to close file", 
+                         write_ctx.status, write_ctx.ref_count);
+        } else {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] All write tasks completed successfully, ref_count=%u, total_written=%zu", 
+                         write_ctx.ref_count, write_ctx.total_written);
+        }
     }
+#endif
+#endif
     
-    /* 获取实际写入的字节数 */
-    size_t actual_written = ln_file_write_queue_get_written(&write_ctx);
-    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Actual written: %zu bytes", actual_written);
+    /* 安全关闭文件并获取实际写入大小 */
+    size_t actual_written = 0;
     
-    /* 安全关闭文件 */
+#if LN_HTTP_DOWNLOAD_USE_QUEUE
+    /* 异步队列写入模式 */
+    /* 安全关闭文件(会等待文件关闭完成) */
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+    /* 测试模式:不关闭文件(文件可能未打开) */
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode: skip file close");
+    actual_written = total_written;
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode: actual_written=%zu bytes (from total_written)", actual_written);
+#else
     ln_file_write_queue_close_file(&fd, &write_ctx);
+    
+    /* 关键设计改进:关闭文件后,从文件系统读取实际文件大小,而不是使用记录的total_written */
+    /* 这样可以确保重试时offset的准确性,避免因写入失败或部分写入导致的不一致 */
+    {
+        FILE *fcheck = fopen(save_path, "rb");
+        if (fcheck) {
+            if (fseek(fcheck, 0, SEEK_END) == 0) {
+                long file_size = ftell(fcheck);
+                if (file_size >= 0) {
+                    actual_written = (size_t)file_size;
+                }
+            }
+            fclose(fcheck);
+        }
+    }
+    
+    /* 验证文件实际大小与记录的一致性(用于调试) */
+    size_t recorded_written = ln_file_write_queue_get_written(&write_ctx);
+    if (actual_written != recorded_written) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 文件大小不一致: 实际文件=%zu字节, 记录=%zu字节, 使用实际文件大小", 
+                     actual_written, recorded_written);
+    } else {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 文件大小验证通过: %zu字节", actual_written);
+    }
+    
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Final actual_written: %zu bytes (from file system)", actual_written);
+#endif
 #else
     /* 直接写文件模式:刷新缓冲区并关闭文件 */
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+    /* 测试模式:不关闭文件(文件可能未打开) */
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode: skip file close");
+    actual_written = total_written;
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode (no write), total_written=%zu bytes", actual_written);
+#else
     fflush(fd);
     fclose(fd);
-    size_t actual_written = total_written;
+    actual_written = total_written;
     WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Direct write mode, total_written=%zu bytes", actual_written);
 #endif
+#endif
+    
+    /* 计算下载总耗时和性能统计 */
+    uint32_t download_end_time_ms = uapi_tcxo_get_ms();
+    uint32_t total_download_time_ms = 0;
+    if (download_end_time_ms >= download_start_time_ms) {
+        total_download_time_ms = download_end_time_ms - download_start_time_ms;
+    } else {
+        total_download_time_ms = (0xFFFFFFFF - download_start_time_ms) + download_end_time_ms + 1;
+    }
+    
+    /* 计算网络速度(KB/s) */
+    float network_speed_kbps = 0.0f;
+    float recv_speed_kbps = 0.0f;
+    float write_speed_kbps = 0.0f;
+    if (total_download_time_ms > 0) {
+        network_speed_kbps = (total_bytes_received * 1000.0f) / (total_download_time_ms * 1024.0f);
+    }
+    if (total_recv_time_ms > 0) {
+        recv_speed_kbps = (total_bytes_received * 1000.0f) / (total_recv_time_ms * 1024.0f);
+    }
+    if (total_write_time_ms > 0 && total_bytes_received > 0) {
+        write_speed_kbps = (total_bytes_received * 1000.0f) / (total_write_time_ms * 1024.0f);
+    }
+    
+    /* 打印性能统计报告 */
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] =========================================");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 总下载时间: %u ms (%.2f 秒)", 
+                 total_download_time_ms, total_download_time_ms / 1000.0f);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 总接收字节: %zu bytes (%.2f KB)", 
+                 total_bytes_received, total_bytes_received / 1024.0f);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 总接收耗时: %u ms (%.2f%% 总时间)", 
+                 total_recv_time_ms, (total_download_time_ms > 0) ? (total_recv_time_ms * 100.0f / total_download_time_ms) : 0.0f);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 总写入耗时: %u ms (%.2f%% 总时间)", 
+                 total_write_time_ms, (total_download_time_ms > 0) ? (total_write_time_ms * 100.0f / total_download_time_ms) : 0.0f);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 平均网络速度: %.2f KB/s", network_speed_kbps);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 平均接收速度: %.2f KB/s", recv_speed_kbps);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 平均写入速度: %.2f KB/s", write_speed_kbps);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 数据包数量: %d", packet_count);
+#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] 测试模式: 只统计不写入文件");
+#endif
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[DOWNLOAD_PERF_REPORT] =========================================");
+    
+    /* 判断下载是否真正成功:需要HTTP状态码200/206、有数据写入、且下载完成(isMore=0) */
+    int is_download_complete = (client_data.isMore == 0);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 判断下载结果: final_code=%d, actual_written=%zu, isMore=%d, is_complete=%d", 
+                 final_code, actual_written, client_data.isMore, is_download_complete);
     
-    if ((final_code == 200 || final_code == 206) && actual_written > 0)
+    if ((final_code == 200 || final_code == 206) && actual_written > 0 && is_download_complete)
     {
         ret = ERRCODE_SUCC;
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 下载成功 (%s), written=%zu", 
@@ -1002,7 +1434,12 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
     else
     {
         ret = ERRCODE_FAIL;
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 下载失败,保留部分文件供下次续传");
+        if (actual_written > 0 && !is_download_complete) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 下载未完成(isMore=%d),保留部分文件供下次续传,已写入=%zu字节", 
+                         client_data.isMore, actual_written);
+        } else {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 下载失败,保留部分文件供下次续传");
+        }
     }
 
     if (header_buf) free(header_buf);
@@ -1015,7 +1452,9 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path)
 #endif
 
     return ret;
+#endif /* LN_HTTP_USE_LWIP_CLIENT */
 }
+
 /* 断点续传下载函数封装:带重试,不做UI通知与资源释放 */
 int uapi_ln_download_file_resume_with_retry(const char *url, const char *save_path, int max_retries)
 {
index 891c471..303efff 100644 (file)
@@ -87,6 +87,25 @@ typedef struct
 #define LN_HTTP_DOWNLOAD_USE_QUEUE 1  // 默认使用异步队列写入
 #endif
 
+/* 测试模式:只统计不写入文件,用于评测网络速度(1=只统计不写入,0=正常写入) */
+#ifndef LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE
+#define LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE 1  // 1=只统计不写入,0=正常写入
+#endif
+
+/* HTTP 下载实现选择:0=使用 OpenHarmony HttpClient,1=使用 lwIP HTTP 客户端 */
+#ifndef LN_HTTP_USE_LWIP_CLIENT
+#define LN_HTTP_USE_LWIP_CLIENT 1  // 0=OpenHarmony HttpClient,1=lwIP HTTP Client (默认使用 zhihui_http_client)
+#endif
+
+/* 表情下载测试模式:启用后所有表情都从固定测试地址下载(1=启用测试模式,0=正常模式) */
+#ifndef LN_EMOJI_DOWNLOAD_TEST_MODE
+#define LN_EMOJI_DOWNLOAD_TEST_MODE 0  // 0=正常模式,1=测试模式
+#endif
+
+#if LN_EMOJI_DOWNLOAD_TEST_MODE
+#define LN_EMOJI_TEST_BASE_URL "http://110.42.224.129:8089/LEINIAO/blue"
+#endif
+
 #define LN_HTTP_SERVICE_CMD_GET_DEVICE_TOKEN 0x1   /* 获取设备 token */
 #define LN_HTTP_SERVICE_CMD_SPEECH_CHAT_STREAM 0x2 /* 语音对话流 */
 #define LN_HTTP_SERVICE_CMD_SSE_RECV 0x3           /* 语音对话流分片接收 */
index 6bea265..9f84289 100644 (file)
@@ -527,7 +527,48 @@ static void ln_emoji_download(void *arg)
                 uapi_create_folder(dir_buf);
             }
         }
-        if (uapi_ln_download_file_resume_with_retry(pkg->emojis[i].emojiUrl, save_path, 10) != ERRCODE_SUCC)
+        
+        /* 测试模式:从固定测试地址下载 */
+        const char *download_url = pkg->emojis[i].emojiUrl;
+        char test_url[MAX_PATH_LEN] = {0};
+#if LN_EMOJI_DOWNLOAD_TEST_MODE
+        /* 测试模式:根据emotion名称映射到测试文件名 */
+        const char *emotion = pkg->emojis[i].emotion ? pkg->emojis[i].emotion : "";
+        const char *test_filename = NULL;
+        
+        /* 映射emotion到测试文件名(只支持测试服务器上存在的文件) */
+        if (strcmp(emotion, "angry") == 0) {
+            test_filename = "angry.zip";
+        } else if (strcmp(emotion, "dizzy") == 0) {
+            test_filename = "dizzy.zip";
+        } else if (strcmp(emotion, "heartbeat") == 0) {
+            test_filename = "heartbeat.zip";
+        } else if (strcmp(emotion, "laughing") == 0) {
+            test_filename = "laughing.zip";
+        } else if (strcmp(emotion, "shocked") == 0) {
+            test_filename = "shocked.zip";
+        } else if (strcmp(emotion, "sleepy") == 0) {
+            test_filename = "sleepy.zip";
+        } else if (strcmp(emotion, "speechless") == 0) {
+            test_filename = "speechless.zip";
+        } else if (strcmp(emotion, "wronged") == 0) {
+            test_filename = "wronged.zip";
+        }
+        
+        /* 测试模式:强制使用测试URL,如果没有对应的测试文件,使用第一个可用的测试文件作为默认 */
+        if (test_filename) {
+            snprintf(test_url, sizeof(test_url), "%s/%s", LN_EMOJI_TEST_BASE_URL, test_filename);
+            download_url = test_url;
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] 测试模式: emotion=%s, 使用测试URL=%s", emotion, download_url);
+        } else {
+            /* 没有对应的测试文件,使用默认测试文件(angry.mp4) */
+            snprintf(test_url, sizeof(test_url), "%s/angry.mp4", LN_EMOJI_TEST_BASE_URL);
+            download_url = test_url;
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] 测试模式: emotion=%s 没有对应的测试文件,使用默认测试URL=%s", emotion, download_url);
+        }
+#endif
+        
+        if (uapi_ln_download_file_resume_with_retry(download_url, save_path, 10) != ERRCODE_SUCC)
         {
             all_success = 0;
             failed_count++;
index fd4a41c..9cfb19e 100644 (file)
@@ -35,6 +35,17 @@ static void ln_file_write_thread(void *arg)
         int ret = osal_msg_queue_read_copy(g_file_write_queue, (void *)&task, &msg_size, OSAL_MSGQ_WAIT_FOREVER);
         
         if (ret == OSAL_SUCCESS && msg_size == sizeof(ln_file_write_task_t)) {
+            /* 记录出队时间戳并计算队列等待时间(用于性能分析) */
+            extern uint32_t uapi_tcxo_get_ms(void);
+            uint32_t dequeue_time_ms = uapi_tcxo_get_ms();
+            uint32_t queue_wait_time_ms = 0;
+            if (dequeue_time_ms >= task.enqueue_time_ms) {
+                queue_wait_time_ms = dequeue_time_ms - task.enqueue_time_ms;
+            } else {
+                /* 处理时间戳溢出 */
+                queue_wait_time_ms = (0xFFFFFFFF - task.enqueue_time_ms) + dequeue_time_ms + 1;
+            }
+            
             /* 更新状态为正在写入 */
             if (task.ctx) {
                 task.ctx->status = LN_FILE_WRITE_STATUS_WRITING;
@@ -85,8 +96,28 @@ static void ln_file_write_thread(void *arg)
             
             /* 写入数据(关闭任务可能 data_len=0,跳过写入) */
             if (task.file_handle && *task.file_handle && task.data && task.data_len > 0) {
+                /* 记录写入开始时间 */
+                uint32_t write_start_time_ms = uapi_tcxo_get_ms();
+                
                 size_t written = fwrite(task.data, 1, task.data_len, *task.file_handle);
                 
+                /* 记录写入结束时间并计算耗时 */
+                uint32_t write_end_time_ms = uapi_tcxo_get_ms();
+                uint32_t write_duration_ms = 0;
+                if (write_end_time_ms >= write_start_time_ms) {
+                    write_duration_ms = write_end_time_ms - write_start_time_ms;
+                } else {
+                    /* 处理时间戳溢出 */
+                    write_duration_ms = (0xFFFFFFFF - write_start_time_ms) + write_end_time_ms + 1;
+                }
+                
+                /* 打印性能分析日志:入队时间、出队时间、队列等待时间、写入耗时 */
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                             "[FILE_WRITE_PERF] data_len=%zu, enqueue=%u, dequeue=%u, queue_wait=%ums, write_duration=%ums, total=%ums", 
+                             task.data_len, task.enqueue_time_ms, dequeue_time_ms, 
+                             queue_wait_time_ms, write_duration_ms, 
+                             queue_wait_time_ms + write_duration_ms);
+                
                 if (written != task.data_len) {
                     WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
                                 "[FILE_WRITE_QUEUE] Write failed: written=%zu, expected=%zu", 
@@ -372,6 +403,10 @@ errcode_t ln_file_write_queue_add_task(
     task.is_first_packet = is_first_packet;
     task.is_last_packet = is_last_packet;
     
+    /* 记录入队时间戳(用于性能分析) */
+    extern uint32_t uapi_tcxo_get_ms(void);
+    task.enqueue_time_ms = uapi_tcxo_get_ms();
+    
     /* 更新状态为等待写入 */
     ctx->status = LN_FILE_WRITE_STATUS_PENDING;
     ctx->ref_count++;  /* 增加引用计数 */
@@ -434,14 +469,22 @@ errcode_t ln_file_write_queue_wait_done(ln_file_write_ctx_t *ctx, uint32_t timeo
     last_watchdog_kick_time = uapi_tcxo_get_ms();
     
     while (elapsed < timeout_ms || timeout_ms == 0) {
-        if (ctx->status == LN_FILE_WRITE_STATUS_DONE) {
-            return ERRCODE_SUCC;
-        }
-        if (ctx->status == LN_FILE_WRITE_STATUS_ERROR) {
-            return ERRCODE_FAIL;
-        }
-        if (ctx->status == LN_FILE_WRITE_STATUS_CLOSED) {
-            return ERRCODE_SUCC;
+        /* 关键设计改进:即使状态是ERROR,也要等待所有已提交的任务完成(ref_count==0) */
+        /* 这样可以确保文件大小准确,避免重试时offset计算错误 */
+        /* 只有当ref_count==0时,才根据状态返回成功或失败 */
+        if (ctx->ref_count == 0) {
+            /* 所有任务都已完成,根据状态返回结果 */
+            if (ctx->status == LN_FILE_WRITE_STATUS_DONE || 
+                ctx->status == LN_FILE_WRITE_STATUS_CLOSED) {
+                return ERRCODE_SUCC;
+            } else if (ctx->status == LN_FILE_WRITE_STATUS_ERROR) {
+                /* 即使有错误,但所有任务都已完成,文件大小是准确的,返回成功 */
+                /* 这样主线程可以正确获取文件大小用于重试 */
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                             "[FILE_WRITE_QUEUE] wait_done: All tasks completed with ERROR status, but file size is accurate");
+                return ERRCODE_SUCC;
+            }
+            /* 其他状态(PENDING/WRITING/CLOSING)不应该出现在ref_count==0时,但为了安全继续等待 */
         }
         
         /* 定期喂狗,防止长时间等待导致看门狗超时触发 NMI */
@@ -461,6 +504,10 @@ errcode_t ln_file_write_queue_wait_done(ln_file_write_ctx_t *ctx, uint32_t timeo
         }
     }
     
+    /* 超时:记录详细信息用于调试 */
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, 
+                 "[FILE_WRITE_QUEUE] wait_done timeout: status=%d, ref_count=%u, total_written=%zu", 
+                 ctx->status, ctx->ref_count, ctx->total_written);
     return ERRCODE_FAIL;  /* 超时 */
 }
 
@@ -470,17 +517,24 @@ errcode_t ln_file_write_queue_close_file(FILE **file_handle, ln_file_write_ctx_t
         return ERRCODE_FAIL;
     }
     
-    /* 等待所有写入任务完成 */
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] close_file: status=%d, ref_count=%u, total_written=%zu", 
+                 ctx->status, ctx->ref_count, ctx->total_written);
+    
+    /* 等待所有写入任务完成:关键设计改进,确保ref_count==0且状态为DONE或CLOSED */
     if (ctx->status != LN_FILE_WRITE_STATUS_CLOSED) {
-        /* 等待状态变为DONE或ERROR */
+        /* 等待所有任务完成:ref_count必须为0,且状态为DONE或ERROR */
         uint32_t wait_count = 0;
+        const uint32_t MAX_WAIT_COUNT = 3000;  /* 最多等待30秒(10ms * 3000) */
         extern uint32_t uapi_tcxo_get_ms(void);
         uint32_t last_watchdog_kick_time = uapi_tcxo_get_ms();
         const uint32_t WATCHDOG_KICK_INTERVAL_MS = 2000;  /* 每2秒喂一次狗(看门狗超时8秒) */
         
-        while ((ctx->status == LN_FILE_WRITE_STATUS_PENDING || 
-                ctx->status == LN_FILE_WRITE_STATUS_WRITING) && 
-               wait_count < 100) {
+        /* 关键:等待ref_count归零,确保所有任务都已完成 */
+        while ((ctx->ref_count > 0 || 
+                (ctx->status != LN_FILE_WRITE_STATUS_DONE && 
+                 ctx->status != LN_FILE_WRITE_STATUS_ERROR && 
+                 ctx->status != LN_FILE_WRITE_STATUS_CLOSED)) && 
+               wait_count < MAX_WAIT_COUNT) {
             /* 定期喂狗,防止长时间等待导致看门狗超时触发 NMI */
             uint32_t current_time = uapi_tcxo_get_ms();
             uint32_t time_since_last_kick = (current_time >= last_watchdog_kick_time) ? 
@@ -496,9 +550,12 @@ errcode_t ln_file_write_queue_close_file(FILE **file_handle, ln_file_write_ctx_t
             wait_count++;
         }
         
-        /* 如果还有未完成的任务,减少引用计数 */
-        if (ctx->ref_count > 0) {
-            ctx->ref_count--;
+        if (wait_count >= MAX_WAIT_COUNT) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] close_file: 等待写入任务超时, status=%d, ref_count=%u, total_written=%zu", 
+                         ctx->status, ctx->ref_count, ctx->total_written);
+        } else {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] close_file: 所有写入任务已完成, status=%d, ref_count=%u, total_written=%zu", 
+                         ctx->status, ctx->ref_count, ctx->total_written);
         }
         
         /* 如果文件还未关闭,且不是最后一包,需要发送关闭任务 */
@@ -537,6 +594,13 @@ errcode_t ln_file_write_queue_close_file(FILE **file_handle, ln_file_write_ctx_t
             osDelay(10);
             wait_count++;
         }
+        
+        if (wait_count >= 100) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] close_file: 等待文件关闭超时, status=%d, ref_count=%u", 
+                         ctx->status, ctx->ref_count);
+        } else {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] close_file: 文件关闭完成, status=%d", ctx->status);
+        }
     }
     
     return ERRCODE_SUCC;
index 9907eae..755d962 100644 (file)
@@ -38,6 +38,7 @@ typedef struct {
     size_t data_len;                   /* 数据长度 */
     int is_first_packet;               /* 是否为第一包(需要创建文件) */
     int is_last_packet;                /* 是否为最后一包(写入后关闭文件) */
+    uint32_t enqueue_time_ms;          /* 入队时间戳(毫秒),用于性能分析 */
 } ln_file_write_task_t;
 
 /**
diff --git a/code/sdk/zhihui/leiniao/imsl_ln/zhihui_http_client.c b/code/sdk/zhihui/leiniao/imsl_ln/zhihui_http_client.c
new file mode 100644 (file)
index 0000000..1f68c68
--- /dev/null
@@ -0,0 +1,1087 @@
+/**
+ * @file zhihui_http_client.c
+ * @brief 基于 lwIP HTTP 客户端的 HTTP/HTTPS 下载实现
+ */
+
+#include "zhihui_http_client.h"
+#include "lwip/apps/http_client.h"
+#include "lwip/altcp.h"
+#include "lwip/altcp_tcp.h"
+#include "lwip/altcp_tls.h"
+#include "lwip/dns.h"
+#include "lwip/ip_addr.h"
+#include "lwip/pbuf.h"
+#include "lwip/mem.h"
+#include "wearable_log.h"
+#include "los_task.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+/* 异步文件写入队列支持 */
+#if LN_HTTP_DOWNLOAD_USE_QUEUE
+#include "ln_file_write_queue.h"
+#endif
+
+#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS
+#include "mbedtls/ssl.h"
+#include "mbedtls/ssl_ciphersuites.h"
+#include "mbedtls/x509_crt.h"
+#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
+#include "psa/crypto.h"
+#endif
+#endif
+
+/* HTTPC_CONTENT_LEN_INVALID 定义(从 http_client.c 复制) */
+#ifndef HTTPC_CONTENT_LEN_INVALID
+#define HTTPC_CONTENT_LEN_INVALID 0xFFFFFFFF
+#endif
+
+/* httpc_state_t 结构体定义(从 http_client.c 复制,用于访问内部成员) */
+struct _httpc_state_internal {
+    struct altcp_pcb* pcb;
+    ip_addr_t remote_addr;
+    u16_t remote_port;
+    int timeout_ticks;
+    struct pbuf *request;
+    struct pbuf *rx_hdrs;
+    u16_t rx_http_version;
+    u16_t rx_status;
+    altcp_recv_fn recv_fn;
+    const httpc_connection_t *conn_settings;
+    void* callback_arg;
+    u32_t rx_content_len;
+    u32_t hdr_content_len;
+    int parse_state;
+#if HTTPC_DEBUG_REQUEST
+    char* server_name;
+    char* uri;
+#endif
+};
+
+/* altcp_tls_config 结构体定义(从 altcp_tls_mbedtls.c 复制,用于访问内部成员) */
+#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS
+struct altcp_tls_config_internal {
+    mbedtls_ssl_config conf;
+    void *cert;
+    void *pkey;
+    uint8_t cert_count;
+    uint8_t cert_max;
+    uint8_t pkey_count;
+    uint8_t pkey_max;
+    void *ca;
+};
+#endif
+
+/* 默认 SSL 配置 */
+static zhihui_ssl_config_t g_default_ssl_config = {0};
+static bool g_default_ssl_config_init = false;
+
+/* 下载状态结构 */
+typedef struct {
+    FILE *fd;
+    const char *save_path;
+    size_t resume_offset;
+    size_t total_written;
+    size_t total_bytes;
+    zhihui_http_result_fn result_cb;
+    zhihui_http_progress_fn progress_cb;
+    void *callback_arg;
+    int result;
+    uint32_t http_status;
+    int completed;  /* 0=进行中,1=完成,-1=失败 */
+    const char *hostname;  /* 用于 SSL 主机名验证 */
+    const zhihui_ssl_config_t *ssl_config;  /* SSL 配置,用于连接后设置参数 */
+    httpc_state_t *connection;  /* HTTP 连接句柄 */
+#if LN_HTTP_DOWNLOAD_USE_QUEUE
+    ln_file_write_ctx_t write_ctx;  /* 异步写入上下文 */
+    int is_first_packet;  /* 是否为第一包 */
+#endif
+} zhihui_download_state_t;
+
+/* URL 解析结果 */
+typedef struct {
+    char protocol[8];   /* http 或 https */
+    char host[256];
+    uint16_t port;
+    char path[512];
+    bool is_https;
+} zhihui_url_info_t;
+
+/**
+ * @brief 解析 URL
+ */
+static int zhihui_parse_url(const char *url, zhihui_url_info_t *info)
+{
+    const char *p = url;
+    const char *host_start, *path_start;
+    int port = 0;
+    
+    memset(info, 0, sizeof(zhihui_url_info_t));
+    
+    /* 解析协议 */
+    if (strncmp(p, "https://", 8) == 0) {
+        strcpy(info->protocol, "https");
+        info->is_https = true;
+        info->port = 443;
+        p += 8;
+    } else if (strncmp(p, "http://", 7) == 0) {
+        strcpy(info->protocol, "http");
+        info->is_https = false;
+        info->port = 80;
+        p += 7;
+    } else {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Invalid URL protocol: %s", url);
+        return -1;
+    }
+    
+    host_start = p;
+    
+    /* 查找路径开始位置 */
+    path_start = strchr(p, '/');
+    if (path_start == NULL) {
+        path_start = p + strlen(p);
+        strcpy(info->path, "/");
+    } else {
+        size_t path_len = strlen(path_start);
+        if (path_len >= sizeof(info->path)) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Path too long");
+            return -1;
+        }
+        strcpy(info->path, path_start);
+    }
+    
+    /* 提取主机和端口 */
+    size_t host_len = path_start - host_start;
+    const char *colon = strchr(host_start, ':');
+    if (colon != NULL && colon < path_start) {
+        /* 有端口号 */
+        host_len = colon - host_start;
+        port = atoi(colon + 1);
+        if (port > 0 && port < 65536) {
+            info->port = (uint16_t)port;
+        }
+    }
+    
+    if (host_len >= sizeof(info->host)) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Host too long");
+        return -1;
+    }
+    strncpy(info->host, host_start, host_len);
+    info->host[host_len] = '\0';
+    
+    return 0;
+}
+
+/**
+ * @brief 扩展 lwIP HTTP 客户端:在请求中添加自定义 HTTP 头
+ * @param connection HTTP 连接状态
+ * @param header_name 头名称(如 "Range")
+ * @param header_value 头值(如 "bytes=1024-")
+ * @return 0 成功,-1 失败
+ * 
+ * 注意:此函数在请求发送前修改请求字符串,在 "Connection: Close\r\n" 之前插入自定义头
+ */
+static int zhihui_http_add_custom_header(httpc_state_t *connection, const char *header_name, const char *header_value)
+{
+    if (connection == NULL || header_name == NULL || header_value == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Invalid parameters for add_custom_header");
+        return -1;
+    }
+    
+    /* 使用内部结构体访问成员 */
+    struct _httpc_state_internal *conn = (struct _httpc_state_internal *)connection;
+    if (conn->request == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Connection request is NULL");
+        return -1;
+    }
+    
+    struct pbuf *req = conn->request;
+    if (req->next != NULL) {
+        /* pbuf 必须是连续的 */
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Request pbuf is not contiguous");
+        return -1;
+    }
+    
+    char *old_request = (char *)req->payload;
+    u16_t old_len = req->len;
+    
+    /* 构建新的头字符串 */
+    char new_header[256];
+    int header_len = snprintf(new_header, sizeof(new_header), "%s: %s\r\n", header_name, header_value);
+    if (header_len < 0 || header_len >= (int)sizeof(new_header)) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Header string too long");
+        return -1;
+    }
+    
+    /* 查找 "Connection: Close\r\n" 的位置 */
+    const char *connection_marker = "Connection: Close\r\n";
+    char *connection_pos = strstr(old_request, connection_marker);
+    if (connection_pos == NULL) {
+        /* 如果没有找到,尝试查找 "\r\n\r\n"(请求头结束标记) */
+        connection_pos = strstr(old_request, "\r\n\r\n");
+        if (connection_pos == NULL) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Cannot find insertion point for custom header");
+            return -1;
+        }
+        /* 在 "\r\n\r\n" 之前插入 */
+    }
+    
+    /* 计算插入位置 */
+    size_t insert_pos = connection_pos - old_request;
+    size_t new_len = old_len + header_len;
+    
+    /* 分配新的 pbuf */
+    struct pbuf *new_req = pbuf_alloc(PBUF_RAW, (u16_t)(new_len + 1), PBUF_RAM);
+    if (new_req == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to allocate new request pbuf");
+        return -1;
+    }
+    
+    if (new_req->next != NULL) {
+        pbuf_free(new_req);
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] New request pbuf is not contiguous");
+        return -1;
+    }
+    
+    char *new_request = (char *)new_req->payload;
+    
+    /* 复制插入点之前的内容 */
+    memcpy(new_request, old_request, insert_pos);
+    
+    /* 插入新的头 */
+    memcpy(new_request + insert_pos, new_header, header_len);
+    
+    /* 复制插入点之后的内容 */
+    memcpy(new_request + insert_pos + header_len, old_request + insert_pos, old_len - insert_pos);
+    
+    /* 确保以 null 结尾(虽然 HTTP 请求不需要,但为了安全) */
+    new_request[new_len] = '\0';
+    new_req->len = (u16_t)new_len;
+    new_req->tot_len = (u16_t)new_len;
+    
+    /* 释放旧的 pbuf 并设置新的 */
+    pbuf_free(req);
+    conn->request = new_req;
+    
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Added custom header: %s: %s", header_name, header_value);
+    return 0;
+}
+
+/**
+ * @brief TLS allocator 参数结构(用于传递主机名)
+ */
+#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS
+typedef struct {
+    struct altcp_tls_config *tls_config;
+    const char *hostname;
+} zhihui_tls_alloc_arg_t;
+
+/**
+ * @brief 创建 TLS allocator
+ */
+static struct altcp_pcb *zhihui_tls_alloc(void *arg, u8_t ip_type)
+{
+    zhihui_tls_alloc_arg_t *alloc_arg = (zhihui_tls_alloc_arg_t *)arg;
+    if (alloc_arg == NULL || alloc_arg->tls_config == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: invalid argument (alloc_arg=%p, tls_config=%p)", 
+                     alloc_arg, alloc_arg ? alloc_arg->tls_config : NULL);
+        return NULL;
+    }
+    
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: creating TLS pcb, hostname=%s", 
+                 alloc_arg->hostname ? alloc_arg->hostname : "NULL");
+    
+    struct altcp_pcb *pcb = altcp_tls_new(alloc_arg->tls_config, ip_type);
+    if (pcb == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: altcp_tls_new failed");
+        return NULL;
+    }
+    
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: altcp_tls_new succeeded, pcb=%p", pcb);
+    
+    /* 在创建连接后立即设置主机名(在握手前) */
+    if (alloc_arg->hostname != NULL && strlen(alloc_arg->hostname) > 0) {
+        void *ssl_ctx = altcp_tls_context(pcb);
+        if (ssl_ctx == NULL) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: altcp_tls_context returned NULL, cannot set hostname");
+            /* 注意:即使无法设置主机名,也继续返回 pcb,让连接尝试继续 */
+        } else {
+            mbedtls_ssl_context *ssl = (mbedtls_ssl_context *)ssl_ctx;
+            int ret = mbedtls_ssl_set_hostname(ssl, alloc_arg->hostname);
+            if (ret != 0) {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: mbedtls_ssl_set_hostname failed: %d (hostname=%s)", 
+                             ret, alloc_arg->hostname);
+            } else {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: SSL hostname set successfully: %s", alloc_arg->hostname);
+            }
+        }
+    } else {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: hostname is NULL or empty, SNI will not be sent");
+    }
+    
+    return pcb;
+}
+#endif
+
+static struct altcp_tls_config *zhihui_create_tls_config(const zhihui_ssl_config_t *ssl_config, const char *hostname)
+{
+    struct altcp_tls_config *tls_config = NULL;
+    
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Creating TLS config: ssl_config=%p, hostname=%s, skip_verify=%d", 
+                 ssl_config, hostname ? hostname : "NULL", ssl_config ? ssl_config->skip_cert_verify : 1);
+    
+    if (ssl_config == NULL || ssl_config->skip_cert_verify) {
+        /* 使用默认配置(跳过验证,仅用于测试) */
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Creating TLS config with no CA cert (skip verify)");
+        tls_config = altcp_tls_create_config_client(NULL, 0);
+    } else {
+        /* 使用 CA 证书 */
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Creating TLS config with CA cert (len=%zu)", 
+                     ssl_config->ca_cert_len);
+        tls_config = altcp_tls_create_config_client(
+            ssl_config->ca_cert,
+            ssl_config->ca_cert_len
+        );
+    }
+    
+    if (tls_config == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to create TLS config (altcp_tls_create_config_client returned NULL)");
+        return NULL;
+    }
+    
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS config created successfully: %p", tls_config);
+    
+#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS
+    /* 应用 SSL 配置到 mbedtls_ssl_config */
+    if (ssl_config != NULL) {
+        /* 使用内部结构体访问成员 */
+        struct altcp_tls_config_internal *tls_config_internal = (struct altcp_tls_config_internal *)tls_config;
+        mbedtls_ssl_config *conf = &tls_config_internal->conf;
+        
+        /* 设置读取超时 */
+        if (ssl_config->read_timeout_ms > 0) {
+            mbedtls_ssl_conf_read_timeout(conf, ssl_config->read_timeout_ms);
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL read timeout configured: %u ms", ssl_config->read_timeout_ms);
+        } else {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL read timeout: using default");
+        }
+        
+        /* 配置 TLS 版本 - 支持 TLS 1.2 到 TLS 1.3 的协商(如果服务器不支持 TLS 1.3,自动回退到 TLS 1.2) */
+        if (ssl_config->min_tls_version > 0) {
+            mbedtls_ssl_conf_min_version(conf, MBEDTLS_SSL_MAJOR_VERSION_3, ssl_config->min_tls_version);
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL min version configured: %d", ssl_config->min_tls_version);
+        } else {
+            /* 默认最小版本:TLS 1.2(允许回退) */
+            mbedtls_ssl_conf_min_version(conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3);
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL min version: TLS 1.2 (default, allows fallback)");
+        }
+        if (ssl_config->max_tls_version > 0) {
+            mbedtls_ssl_conf_max_version(conf, MBEDTLS_SSL_MAJOR_VERSION_3, ssl_config->max_tls_version);
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL max version configured: %d", ssl_config->max_tls_version);
+        } else {
+            /* 默认最大版本:TLS 1.3(优先使用) */
+            mbedtls_ssl_conf_max_version(conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_4);
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL max version: TLS 1.3 (default, preferred)");
+        }
+        
+        /* 配置加密套件 - 同时支持 TLS 1.2 和 TLS 1.3 加密套件(优先 TLS 1.3) */
+        if (ssl_config->cipher_suites != NULL) {
+            mbedtls_ssl_conf_ciphersuites(conf, ssl_config->cipher_suites);
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL cipher suites configured (custom)");
+        } else {
+            /* 默认加密套件:优先 TLS 1.3,如果服务器不支持则使用 TLS 1.2 */
+            static const int default_ciphersuites[] = {
+                /* TLS 1.3 加密套件(按优先级排序,优先使用) */
+                MBEDTLS_TLS1_3_AES_128_GCM_SHA256,            /* 0x1301 - TLS_AES_128_GCM_SHA256 (最常用) */
+                MBEDTLS_TLS1_3_AES_256_GCM_SHA384,            /* 0x1302 - TLS_AES_256_GCM_SHA384 */
+                MBEDTLS_TLS1_3_CHACHA20_POLY1305_SHA256,      /* 0x1303 - TLS_CHACHA20_POLY1305_SHA256 */
+                MBEDTLS_TLS1_3_AES_128_CCM_SHA256,            /* 0x1304 - TLS_AES_128_CCM_SHA256 */
+                MBEDTLS_TLS1_3_AES_128_CCM_8_SHA256,          /* 0x1305 - TLS_AES_128_CCM_8_SHA256 */
+                
+                /* TLS 1.2 加密套件(按优先级排序,作为回退选项) */
+                MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,    /* 0xC02F - TLS 1.2 最常用 */
+                MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,    /* 0xC030 - TLS 1.2 */
+                MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,      /* 0x9E - TLS 1.2 */
+                MBEDTLS_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,      /* 0x9F - TLS 1.2 */
+                MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256,          /* 0x9C - TLS 1.2 */
+                MBEDTLS_TLS_RSA_WITH_AES_256_GCM_SHA384,          /* 0x9D - TLS 1.2 */
+                0  /* 结束标记 */
+            };
+            mbedtls_ssl_conf_ciphersuites(conf, default_ciphersuites);
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL cipher suites: using default (TLS 1.3 preferred, TLS 1.2 fallback)");
+        }
+        
+        /* 设置证书验证模式 */
+        if (ssl_config->skip_cert_verify) {
+            mbedtls_ssl_conf_authmode(conf, MBEDTLS_SSL_VERIFY_NONE);
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL cert verification: SKIP (TEST ONLY - insecure!)");
+        } else {
+            mbedtls_ssl_conf_authmode(conf, MBEDTLS_SSL_VERIFY_REQUIRED);
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL cert verification: REQUIRED");
+        }
+    } else {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL config is NULL, using default settings");
+    }
+    
+    /* 注意:主机名需要在连接建立后通过 mbedtls_ssl_set_hostname 设置 */
+    /* 这里保存 hostname 到配置中,后续在连接回调中设置 */
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS config setup completed, hostname will be set in allocator");
+#endif
+    
+    return tls_config;
+}
+
+/**
+ * @brief 配置已建立的 TLS 连接(设置主机名等)
+ * 注意:此函数在连接建立后调用,但主机名应该在 allocator 中已经设置
+ */
+#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS
+static void zhihui_configure_tls_connection(httpc_state_t *connection, const char *hostname, const zhihui_ssl_config_t *ssl_config)
+{
+    if (connection == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: connection is NULL");
+        return;
+    }
+    
+    /* 使用内部结构体访问成员 */
+    struct _httpc_state_internal *conn = (struct _httpc_state_internal *)connection;
+    if (conn->pcb == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: pcb is NULL");
+        return;
+    }
+    
+    /* 获取 TLS 上下文 */
+    void *ssl_ctx = altcp_tls_context(conn->pcb);
+    if (ssl_ctx == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: altcp_tls_context returned NULL (not a TLS connection?)");
+        return;
+    }
+    
+    mbedtls_ssl_context *ssl = (mbedtls_ssl_context *)ssl_ctx;
+    
+    /* 验证主机名是否已设置(应该在 allocator 中已设置) */
+    if (hostname != NULL && strlen(hostname) > 0) {
+        /* 注意:主机名应该在 allocator 中已经设置,这里只是验证 */
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: verifying hostname=%s (should be set in allocator)", hostname);
+        
+        /* 可以在这里再次设置主机名(如果之前设置失败) */
+        int ret = mbedtls_ssl_set_hostname(ssl, hostname);
+        if (ret != 0) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: Failed to set SSL hostname: %d", ret);
+        } else {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: SSL hostname verified/set: %s", hostname);
+        }
+    } else {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: hostname is NULL or empty");
+    }
+    
+    /* 注意:握手超时需要通过定时器实现,这里暂时无法直接设置 */
+    /* 如果需要设置握手超时,需要在连接建立时启动定时器 */
+}
+#endif
+
+/**
+ * @brief HTTP 接收数据回调
+ */
+static err_t zhihui_http_recv_cb(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err)
+{
+    zhihui_download_state_t *state = (zhihui_download_state_t *)arg;
+    
+    /* 添加日志:记录数据接收 */
+    if (p != NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] recv_cb: received data, len=%u, tot_len=%u, err=%d", 
+                     p->len, p->tot_len, err);
+    } else {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] recv_cb: pbuf is NULL, err=%d", err);
+    }
+    
+    if (err != ERR_OK) {
+        const char *err_str = "UNKNOWN";
+        switch (err) {
+            case ERR_MEM: err_str = "MEM"; break;
+            case ERR_BUF: err_str = "BUF"; break;
+            case ERR_TIMEOUT: err_str = "TIMEOUT"; break;
+            case ERR_CLSD: err_str = "CLSD"; break;
+            case ERR_RST: err_str = "RST"; break;
+            case ERR_ABRT: err_str = "ABRT"; break;
+            default: err_str = "UNKNOWN"; break;
+        }
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] recv_cb: error=%d (%s), p=%p", err, err_str, p);
+        if (state && state->result_cb) {
+            state->result_cb(state->callback_arg, ERRCODE_FAIL, state->total_written, state->http_status);
+        }
+        return ERR_OK;
+    }
+    
+    if (p == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] recv_cb: pbuf is NULL (connection closed?)");
+        if (state && state->result_cb) {
+            state->result_cb(state->callback_arg, ERRCODE_FAIL, state->total_written, state->http_status);
+        }
+        return ERR_OK;
+    }
+    
+    if (state == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] recv_cb: state is NULL");
+        pbuf_free(p);
+        return ERR_OK;
+    }
+    
+#if LN_HTTP_DOWNLOAD_USE_QUEUE
+    /* 使用异步文件写入队列 */
+    const char *open_mode = state->resume_offset > 0 ? "ab+" : "wb+";
+    errcode_t write_ret = ln_file_write_queue_add_task(
+        &state->fd,
+        &state->write_ctx,
+        state->is_first_packet ? state->save_path : NULL,  /* 第一包需要文件路径 */
+        state->is_first_packet ? open_mode : NULL,  /* 第一包需要打开模式 */
+        (const uint8_t *)p->payload,
+        p->len,
+        state->is_first_packet ? 1 : 0,  /* is_first_packet */
+        0  /* is_last_packet,在 result_cb 中处理最后一包 */
+    );
+    
+    if (write_ret != ERRCODE_SUCC) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to add write task: %d", write_ret);
+        pbuf_free(p);
+        if (state->result_cb) {
+            state->result_cb(state->callback_arg, ERRCODE_FAIL, state->total_written, state->http_status);
+        }
+        return ERR_OK;
+    }
+    
+    if (state->is_first_packet) {
+        state->is_first_packet = 0;
+    }
+#else
+    /* 直接写入文件 */
+    if (state->fd != NULL) {
+        size_t written = fwrite(p->payload, 1, p->len, state->fd);
+        if (written != p->len) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Write failed: %zu/%u", written, p->len);
+            pbuf_free(p);
+            if (state->result_cb) {
+                state->result_cb(state->callback_arg, ERRCODE_FAIL, state->total_written, state->http_status);
+            }
+            return ERR_OK;
+        }
+        fflush(state->fd);
+    }
+#endif
+    
+    state->total_written += p->len;
+    
+    /* 进度回调 */
+    if (state->progress_cb) {
+        state->progress_cb(state->callback_arg, state->total_written, state->total_bytes);
+    }
+    
+    /* 每接收一定数据量记录一次日志(避免日志过多) */
+    static size_t last_log_bytes = 0;
+    if (state->total_written - last_log_bytes >= 64 * 1024 || state->total_written < 4096) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Download progress: %zu/%zu bytes (%.1f%%)", 
+                     state->total_written, state->total_bytes, 
+                     state->total_bytes > 0 ? (100.0f * state->total_written / state->total_bytes) : 0.0f);
+        last_log_bytes = state->total_written;
+    }
+    
+    pbuf_free(p);
+    return ERR_OK;
+}
+
+/**
+ * @brief HTTP 头部接收完成回调
+ */
+static err_t zhihui_http_headers_done_cb(httpc_state_t *connection, void *arg, struct pbuf *hdr, u16_t hdr_len, u32_t content_len)
+{
+    zhihui_download_state_t *state = (zhihui_download_state_t *)arg;
+    const char *hdr_str = (const char *)hdr->payload;
+    
+    if (state == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] headers_done_cb: state is NULL");
+        pbuf_free(hdr);
+        return ERR_VAL;
+    }
+    
+    /* 保存连接句柄,用于后续配置 TLS */
+    state->connection = connection;
+    
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Headers received: hdr_len=%u, content_len=%u", hdr_len, content_len);
+    
+    /* 注意:TLS 主机名已在 allocator 中设置,这里不需要再次设置 */
+    /* 如果需要额外的 TLS 配置,可以在这里进行 */
+    
+    /* 解析 HTTP 状态码 */
+    state->http_status = 0;
+    if (hdr_len > 12 && strncmp(hdr_str, "HTTP/", 5) == 0) {
+        const char *status_start = strchr(hdr_str, ' ');
+        if (status_start != NULL) {
+            state->http_status = (uint32_t)atoi(status_start + 1);
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] HTTP status code: %u", state->http_status);
+        } else {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to parse HTTP status code");
+        }
+    } else {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Invalid HTTP response header (too short or not HTTP)");
+    }
+    
+    /* 检查状态码 */
+    if (state->http_status >= 400) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] HTTP error response: %u", state->http_status);
+        state->result = ERRCODE_FAIL;
+        state->completed = -1;  /* 标记为失败 */
+        pbuf_free(hdr);
+        return ERR_VAL;  /* 中止连接 */
+    }
+    
+    /* 解析 Content-Length */
+    const char *cl_header = strstr(hdr_str, "Content-Length:");
+    if (cl_header != NULL) {
+        state->total_bytes = (size_t)atoi(cl_header + 15);
+    } else {
+        state->total_bytes = content_len != HTTPC_CONTENT_LEN_INVALID ? content_len : 0;
+    }
+    
+    /* 检查是否支持 Range(206 Partial Content) */
+    if (state->http_status == 206) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Server supports Range requests (206 Partial Content)");
+    }
+    
+    pbuf_free(hdr);
+    return ERR_OK;
+}
+
+/**
+ * @brief HTTP 结果回调
+ */
+static void zhihui_http_result_cb(void *arg, httpc_result_t httpc_result, u32_t rx_content_len, u32_t srv_res, err_t err)
+{
+    zhihui_download_state_t *state = (zhihui_download_state_t *)arg;
+    
+    if (state == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] result_cb: state is NULL");
+        return;
+    }
+    
+    /* 转换结果码 */
+    int result = ERRCODE_FAIL;
+    if (httpc_result == HTTPC_RESULT_OK) {
+        result = ERRCODE_SUCC;
+        state->total_written = rx_content_len;
+        state->completed = 1;  /* 标记为完成 */
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Download completed successfully: %u bytes, status=%u", 
+                     rx_content_len, srv_res);
+    } else {
+        state->completed = -1;  /* 标记为失败 */
+        
+        /* 详细错误信息 */
+        const char *result_str = "UNKNOWN";
+        switch (httpc_result) {
+            case HTTPC_RESULT_ERR_UNKNOWN: result_str = "ERR_UNKNOWN"; break;
+            case HTTPC_RESULT_ERR_CONNECT: result_str = "ERR_CONNECT"; break;
+            case HTTPC_RESULT_ERR_HOSTNAME: result_str = "ERR_HOSTNAME"; break;
+            case HTTPC_RESULT_ERR_CLOSED: result_str = "ERR_CLOSED"; break;
+            case HTTPC_RESULT_ERR_TIMEOUT: result_str = "ERR_TIMEOUT"; break;
+            case HTTPC_RESULT_ERR_SVR_RESP: result_str = "ERR_SVR_RESP"; break;
+            case HTTPC_RESULT_ERR_MEM: result_str = "ERR_MEM"; break;
+            case HTTPC_RESULT_LOCAL_ABORT: result_str = "LOCAL_ABORT"; break;
+            case HTTPC_RESULT_ERR_CONTENT_LEN: result_str = "ERR_CONTENT_LEN"; break;
+            default: result_str = "UNKNOWN"; break;
+        }
+        
+        const char *err_str = "UNKNOWN";
+        switch (err) {
+            case ERR_OK: err_str = "OK"; break;
+            case ERR_MEM: err_str = "MEM"; break;
+            case ERR_BUF: err_str = "BUF"; break;
+            case ERR_TIMEOUT: err_str = "TIMEOUT"; break;
+            case ERR_RTE: err_str = "RTE"; break;
+            case ERR_INPROGRESS: err_str = "INPROGRESS"; break;
+            case ERR_VAL: err_str = "VAL"; break;
+            case ERR_WOULDBLOCK: err_str = "WOULDBLOCK"; break;
+            case ERR_USE: err_str = "USE"; break;
+            case ERR_ALREADY: err_str = "ALREADY"; break;
+            case ERR_ISCONN: err_str = "ISCONN"; break;
+            case ERR_CONN: err_str = "CONN"; break;
+            case ERR_IF: err_str = "IF"; break;
+            case ERR_ABRT: err_str = "ABRT"; break;
+            case ERR_RST: err_str = "RST"; break;
+            case ERR_CLSD: err_str = "CLSD"; break;
+            case ERR_ARG: err_str = "ARG"; break;
+            default: err_str = "UNKNOWN"; break;
+        }
+        
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Download failed: result=%d (%s), err=%d (%s), status=%u, rx_len=%u", 
+                     httpc_result, result_str, err, err_str, srv_res, rx_content_len);
+        
+        /* 如果是连接关闭错误,可能是 SSL 握手失败 */
+        if (httpc_result == HTTPC_RESULT_ERR_CLOSED && err == ERR_CLSD) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Connection closed unexpectedly - possible SSL/TLS handshake failure");
+        }
+    }
+    
+    state->result = result;
+    state->http_status = srv_res;
+    
+#if LN_HTTP_DOWNLOAD_USE_QUEUE
+    /* 使用异步写入队列:等待所有写入任务完成并关闭文件 */
+    if (result == ERRCODE_SUCC) {
+        /* 等待所有写入任务完成 */
+        errcode_t wait_ret = ln_file_write_queue_wait_done(&state->write_ctx, 30000);  /* 最多等待30秒 */
+        if (wait_ret != ERRCODE_SUCC) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Wait for write queue done failed or timeout");
+            result = ERRCODE_FAIL;
+            state->result = ERRCODE_FAIL;
+        } else {
+            /* 获取实际写入的字节数 */
+            state->total_written = ln_file_write_queue_get_written(&state->write_ctx);
+        }
+    }
+    
+    /* 安全关闭文件 */
+    ln_file_write_queue_close_file(&state->fd, &state->write_ctx);
+#else
+    /* 直接关闭文件 */
+    if (state->fd != NULL) {
+        fclose(state->fd);
+        state->fd = NULL;
+    }
+#endif
+    
+    /* 调用用户回调 */
+    if (state->result_cb) {
+        state->result_cb(state->callback_arg, result, state->total_written, state->http_status);
+    }
+}
+
+/**
+ * @brief 下载文件实现
+ */
+int zhihui_http_download_file_resume(
+    const char *url,
+    const char *save_path,
+    size_t resume_offset,
+    const zhihui_ssl_config_t *ssl_config,
+    zhihui_http_result_fn result_cb,
+    zhihui_http_progress_fn progress_cb,
+    void *callback_arg
+)
+{
+    zhihui_url_info_t url_info;
+    httpc_connection_t conn_settings = {0};
+    zhihui_download_state_t state = {0};
+    struct altcp_allocator_s allocator = {0};
+#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS
+    zhihui_tls_alloc_arg_t *tls_alloc_arg = NULL;
+#endif
+    err_t err;
+    httpc_state_t *connection = NULL;
+    FILE *fd = NULL;
+    
+    if (!url || !save_path) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Invalid parameters");
+        return ERRCODE_FAIL;
+    }
+    
+    /* 解析 URL */
+    if (zhihui_parse_url(url, &url_info) != 0) {
+        return ERRCODE_FAIL;
+    }
+    
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Download: %s -> %s, offset=%zu", url, save_path, resume_offset);
+    
+#if LN_HTTP_DOWNLOAD_USE_QUEUE
+    /* 初始化异步文件写入队列(如果未初始化) */
+    static int queue_initialized = 0;
+    if (!queue_initialized) {
+        if (ln_file_write_queue_init() != ERRCODE_SUCC) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to init file write queue");
+            return ERRCODE_FAIL;
+        }
+        queue_initialized = 1;
+    }
+    
+    /* 初始化写入上下文 */
+    state.write_ctx.status = LN_FILE_WRITE_STATUS_PENDING;
+    state.write_ctx.error_code = ERRCODE_SUCC;
+    state.write_ctx.total_written = 0;
+    state.write_ctx.ref_count = 0;
+    state.is_first_packet = 1;
+    state.fd = NULL;  /* 文件句柄由写入队列管理 */
+#else
+    /* 打开文件 */
+    const char *open_mode = resume_offset > 0 ? "ab" : "wb";
+    fd = fopen(save_path, open_mode);
+    if (fd == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to open file: %s", save_path);
+        return ERRCODE_FAIL;
+    }
+    
+    /* 设置文件缓冲区 */
+    setvbuf(fd, NULL, _IOFBF, 64 * 1024);
+    state.fd = fd;
+#endif
+    
+    /* 初始化状态 */
+    state.save_path = save_path;
+    state.resume_offset = resume_offset;
+    state.result_cb = result_cb;
+    state.progress_cb = progress_cb;
+    state.callback_arg = callback_arg;
+    state.result = ERRCODE_FAIL;
+    state.completed = 0;  /* 初始化为进行中 */
+    state.hostname = url_info.host;
+    state.ssl_config = ssl_config;
+    state.connection = NULL;
+    
+    /* 配置连接设置 */
+    conn_settings.use_proxy = 0;
+    conn_settings.result_fn = zhihui_http_result_cb;
+    conn_settings.headers_done_fn = zhihui_http_headers_done_cb;
+    
+    /* 配置 allocator */
+    if (url_info.is_https) {
+#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS
+#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
+        /* TLS 1.3 需要 PSA crypto 初始化 */
+        static int psa_crypto_initialized = 0;
+        if (!psa_crypto_initialized) {
+            psa_status_t psa_status = psa_crypto_init();
+            if (psa_status != PSA_SUCCESS) {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to initialize PSA crypto: %d (required for TLS 1.3)", psa_status);
+#if !LN_HTTP_DOWNLOAD_USE_QUEUE
+                fclose(fd);
+#endif
+                return ERRCODE_FAIL;
+            }
+            psa_crypto_initialized = 1;
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] PSA crypto initialized successfully (for TLS 1.3)");
+        }
+#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
+        
+        /* 创建 TLS 配置 */
+        struct altcp_tls_config *tls_config = zhihui_create_tls_config(ssl_config, url_info.host);
+        if (tls_config == NULL) {
+#if !LN_HTTP_DOWNLOAD_USE_QUEUE
+            fclose(fd);
+#endif
+            return ERRCODE_FAIL;
+        }
+        
+        /* 创建 allocator 参数(包含配置和主机名) */
+        tls_alloc_arg = (zhihui_tls_alloc_arg_t *)malloc(sizeof(zhihui_tls_alloc_arg_t));
+        if (tls_alloc_arg == NULL) {
+            altcp_tls_free_config(tls_config);
+#if !LN_HTTP_DOWNLOAD_USE_QUEUE
+            fclose(fd);
+#endif
+            return ERRCODE_FAIL;
+        }
+        tls_alloc_arg->tls_config = tls_config;
+        tls_alloc_arg->hostname = url_info.host;
+        
+        /* 设置 TLS allocator */
+        allocator.alloc = zhihui_tls_alloc;
+        allocator.arg = tls_alloc_arg;
+        conn_settings.altcp_allocator = &allocator;
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Using HTTPS with TLS allocator, hostname=%s", url_info.host);
+#else
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] HTTPS not supported (LWIP_ALTCP_TLS not enabled)");
+        fclose(fd);
+        return ERRCODE_FAIL;
+#endif
+    } else {
+        /* HTTP: 使用 TCP allocator */
+        allocator.alloc = altcp_tcp_alloc;
+        allocator.arg = NULL;
+        conn_settings.altcp_allocator = &allocator;
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Using HTTP with TCP allocator");
+    }
+    
+    /* 构建 URI */
+    char uri[512];
+    snprintf(uri, sizeof(uri), "%s", url_info.path);
+    
+    /* 发起下载请求 */
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Starting download: host=%s, port=%u, uri=%s", 
+                 url_info.host, url_info.port, uri);
+    
+    err = httpc_get_file_dns(
+        url_info.host,
+        url_info.port,
+        uri,
+        &conn_settings,
+        zhihui_http_recv_cb,
+        &state,
+        &connection
+    );
+    
+    if (err != ERR_OK) {
+        const char *err_str = "UNKNOWN";
+        switch (err) {
+            case ERR_MEM: err_str = "MEM"; break;
+            case ERR_VAL: err_str = "VAL"; break;
+            case ERR_ARG: err_str = "ARG"; break;
+            case ERR_INPROGRESS: err_str = "INPROGRESS"; break;
+            default: err_str = "UNKNOWN"; break;
+        }
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] httpc_get_file_dns failed: %d (%s)", err, err_str);
+#if !LN_HTTP_DOWNLOAD_USE_QUEUE
+        fclose(fd);
+#endif
+#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS
+        if (tls_alloc_arg != NULL) {
+            if (tls_alloc_arg->tls_config != NULL) {
+                altcp_tls_free_config(tls_alloc_arg->tls_config);
+            }
+            free(tls_alloc_arg);
+        }
+#endif
+        return ERRCODE_FAIL;
+    }
+    
+    /* 保存连接句柄到状态中,用于后续操作 */
+    if (connection != NULL) {
+        state.connection = connection;
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Connection established: pcb=%p", 
+                     ((struct _httpc_state_internal *)connection)->pcb);
+        
+        /* 如果是 HTTPS,验证 TLS 连接状态 */
+        if (url_info.is_https) {
+#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS
+            struct _httpc_state_internal *conn = (struct _httpc_state_internal *)connection;
+            if (conn->pcb != NULL) {
+                void *ssl_ctx = altcp_tls_context(conn->pcb);
+                if (ssl_ctx != NULL) {
+                    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS context verified: %p", ssl_ctx);
+                    /* 可以在这里再次验证主机名设置 */
+                    zhihui_configure_tls_connection(connection, url_info.host, ssl_config);
+                } else {
+                    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] WARNING: TLS context is NULL (not a TLS connection?)");
+                }
+            }
+#endif
+        }
+    } else {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] WARNING: connection is NULL after httpc_get_file_dns");
+    }
+    
+    /* 如果需要断点续传,添加 Range 头 */
+    if (resume_offset > 0 && connection != NULL) {
+        char range_value[64];
+        snprintf(range_value, sizeof(range_value), "bytes=%zu-", resume_offset);
+        
+        if (zhihui_http_add_custom_header(connection, "Range", range_value) == 0) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Added Range header: bytes=%zu-", resume_offset);
+        } else {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to add Range header, will download from beginning");
+            /* 如果添加 Range 头失败,继续下载(从头开始) */
+        }
+    }
+    
+    /* 注意:lwIP HTTP 客户端是异步的,下载结果通过回调函数通知 */
+    /* 如果需要同步等待,轮询等待完成 */
+    if (result_cb == NULL) {
+        /* 没有回调函数,需要同步等待 */
+        extern uint32_t uapi_tcxo_get_ms(void);
+        uint32_t start_time = uapi_tcxo_get_ms();
+        uint32_t timeout_ms = 300000;  /* 5分钟超时 */
+        uint32_t check_interval = 100;  /* 每100ms检查一次 */
+        
+        while (state.completed == 0) {
+            uint32_t elapsed = uapi_tcxo_get_ms() - start_time;
+            if (elapsed > timeout_ms) {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Download timeout after %u ms", elapsed);
+                state.completed = -1;
+                state.result = ERRCODE_FAIL;
+                break;
+            }
+            
+            /* 喂狗(防止看门狗超时) */
+            extern errcode_t uapi_watchdog_kick(void);
+            uapi_watchdog_kick();
+            
+            LOS_Msleep(check_interval);
+        }
+        
+#if LN_HTTP_DOWNLOAD_USE_QUEUE
+        /* 使用异步写入队列:等待所有写入任务完成并关闭文件 */
+        if (state.result == ERRCODE_SUCC) {
+            errcode_t wait_ret = ln_file_write_queue_wait_done(&state.write_ctx, 30000);  /* 最多等待30秒 */
+            if (wait_ret != ERRCODE_SUCC) {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Wait for write queue done failed or timeout");
+                state.result = ERRCODE_FAIL;
+            } else {
+                /* 获取实际写入的字节数 */
+                state.total_written = ln_file_write_queue_get_written(&state.write_ctx);
+            }
+        }
+        
+        /* 安全关闭文件 */
+        ln_file_write_queue_close_file(&state.fd, &state.write_ctx);
+#else
+        /* 关闭文件(如果还未关闭) */
+        if (state.fd != NULL) {
+            fclose(state.fd);
+            state.fd = NULL;
+        }
+#endif
+        
+        /* 清理 TLS 配置和 allocator 参数 */
+#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS
+        if (tls_alloc_arg != NULL) {
+            if (tls_alloc_arg->tls_config != NULL) {
+                altcp_tls_free_config(tls_alloc_arg->tls_config);
+            }
+            free(tls_alloc_arg);
+        }
+#endif
+        
+        return state.result;
+    }
+    
+    /* 有回调函数,异步模式,返回成功表示请求已发起 */
+    return ERRCODE_SUCC;
+}
+
+/**
+ * @brief 创建默认 SSL 配置
+ */
+const zhihui_ssl_config_t *zhihui_ssl_config_default(bool skip_verify)
+{
+    if (!g_default_ssl_config_init) {
+        zhihui_ssl_config_init(&g_default_ssl_config, NULL, 0, 0, skip_verify);
+        g_default_ssl_config_init = true;
+    }
+    return &g_default_ssl_config;
+}
+
+/**
+ * @brief 初始化 SSL 配置
+ */
+void zhihui_ssl_config_init(
+    zhihui_ssl_config_t *config,
+    const uint8_t *ca_cert,
+    size_t ca_cert_len,
+    uint32_t handshake_timeout_ms,
+    bool skip_verify
+)
+{
+    if (config == NULL) {
+        return;
+    }
+    
+    memset(config, 0, sizeof(zhihui_ssl_config_t));
+    config->ca_cert = ca_cert;
+    config->ca_cert_len = ca_cert_len;
+    config->handshake_timeout_ms = handshake_timeout_ms;
+    config->skip_cert_verify = skip_verify;
+    config->read_timeout_ms = 0;  /* 使用默认值 */
+    config->write_timeout_ms = 0; /* 使用默认值 */
+    config->min_tls_version = 0;  /* 使用默认值 */
+    config->max_tls_version = 0;  /* 使用默认值 */
+    config->cipher_suites = NULL; /* 使用默认值 */
+}
+
diff --git a/code/sdk/zhihui/leiniao/imsl_ln/zhihui_http_client.h b/code/sdk/zhihui/leiniao/imsl_ln/zhihui_http_client.h
new file mode 100644 (file)
index 0000000..829bc60
--- /dev/null
@@ -0,0 +1,144 @@
+/**
+ * @file zhihui_http_client.h
+ * @brief 基于 lwIP HTTP 客户端的 HTTP/HTTPS 下载实现
+ * 
+ * 该实现基于 lwIP 的标准 HTTP 客户端接口,支持:
+ * - HTTP 和 HTTPS 下载
+ * - 断点续传(Range 头)
+ * - SSL/TLS 配置(超时、加密算法等)
+ * - 性能优化(可配置 SSL 参数)
+ * 
+ * 与 OpenHarmony HttpClient 的区别:
+ * - 使用 lwIP 的 httpc_get_file_dns 接口
+ * - 通过 altcp_tls 支持 HTTPS
+ * - 可配置 SSL 超时和加密算法
+ */
+
+#ifndef ZHIHUI_HTTP_CLIENT_H
+#define ZHIHUI_HTTP_CLIENT_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include "errcode.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* SSL/TLS 配置结构 */
+typedef struct {
+    /* CA 证书(PEM 格式),如果为 NULL 则使用默认证书验证 */
+    const uint8_t *ca_cert;
+    size_t ca_cert_len;
+    
+    /* 客户端证书(双向认证,可选) */
+    const uint8_t *client_cert;
+    size_t client_cert_len;
+    
+    /* 客户端私钥(双向认证,可选) */
+    const uint8_t *client_key;
+    size_t client_key_len;
+    const uint8_t *client_key_pass;  /* 私钥密码(可选) */
+    size_t client_key_pass_len;
+    
+    /* SSL 握手超时(毫秒),0 表示使用默认值 */
+    uint32_t handshake_timeout_ms;
+    
+    /* SSL 读写超时(毫秒),0 表示使用默认值 */
+    uint32_t read_timeout_ms;
+    uint32_t write_timeout_ms;
+    
+    /* 是否跳过证书验证(仅用于测试,生产环境应设为 false) */
+    bool skip_cert_verify;
+    
+    /* 加密套件配置(可选,NULL 表示使用默认) */
+    const int *cipher_suites;  /* mbedtls 加密套件 ID 数组,以 0 结尾 */
+    
+    /* 最小/最大 TLS 版本(可选,0 表示使用默认) */
+    int min_tls_version;  /* MBEDTLS_SSL_VERSION_TLS1_2 等 */
+    int max_tls_version;
+} zhihui_ssl_config_t;
+
+/* HTTP 下载结果回调函数类型 */
+typedef void (*zhihui_http_result_fn)(void *arg, int result, size_t downloaded_bytes, uint32_t http_status_code);
+
+/* HTTP 下载进度回调函数类型 */
+typedef void (*zhihui_http_progress_fn)(void *arg, size_t downloaded_bytes, size_t total_bytes);
+
+/**
+ * @brief 下载文件(支持断点续传)
+ * @param url 文件 URL(支持 http:// 和 https://)
+ * @param save_path 保存路径
+ * @param resume_offset 续传偏移量(0 表示从头开始)
+ * @param ssl_config SSL 配置(HTTPS 需要,HTTP 可传 NULL)
+ * @param result_cb 结果回调函数(可选)
+ * @param progress_cb 进度回调函数(可选)
+ * @param callback_arg 回调函数参数
+ * @return ERRCODE_SUCC 成功,ERRCODE_FAIL 失败
+ */
+int zhihui_http_download_file_resume(
+    const char *url,
+    const char *save_path,
+    size_t resume_offset,
+    const zhihui_ssl_config_t *ssl_config,
+    zhihui_http_result_fn result_cb,
+    zhihui_http_progress_fn progress_cb,
+    void *callback_arg
+);
+
+/**
+ * @brief 下载文件(从头开始)
+ * @param url 文件 URL
+ * @param save_path 保存路径
+ * @param ssl_config SSL 配置(HTTPS 需要,HTTP 可传 NULL)
+ * @param result_cb 结果回调函数(可选)
+ * @param progress_cb 进度回调函数(可选)
+ * @param callback_arg 回调函数参数
+ * @return ERRCODE_SUCC 成功,ERRCODE_FAIL 失败
+ */
+static inline int zhihui_http_download_file(
+    const char *url,
+    const char *save_path,
+    const zhihui_ssl_config_t *ssl_config,
+    zhihui_http_result_fn result_cb,
+    zhihui_http_progress_fn progress_cb,
+    void *callback_arg
+) {
+    return zhihui_http_download_file_resume(url, save_path, 0, ssl_config, result_cb, progress_cb, callback_arg);
+}
+
+/**
+ * @brief 创建默认 SSL 配置(用于 HTTPS)
+ * @param skip_verify 是否跳过证书验证(仅用于测试)
+ * @return SSL 配置结构(静态分配,可重复使用)
+ */
+const zhihui_ssl_config_t *zhihui_ssl_config_default(bool skip_verify);
+
+/**
+ * @brief 创建自定义 SSL 配置
+ * @param config 配置结构指针(由调用者分配)
+ * @param ca_cert CA 证书(PEM 格式,可选)
+ * @param ca_cert_len CA 证书长度
+ * @param handshake_timeout_ms SSL 握手超时(毫秒,0 表示默认)
+ * @param skip_verify 是否跳过证书验证
+ */
+void zhihui_ssl_config_init(
+    zhihui_ssl_config_t *config,
+    const uint8_t *ca_cert,
+    size_t ca_cert_len,
+    uint32_t handshake_timeout_ms,
+    bool skip_verify
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZHIHUI_HTTP_CLIENT_H */
+
+
+
+
+
+
index 5a91bd5..2fa1121 100644 (file)
@@ -1601,12 +1601,36 @@ int32_t uapi_get_screen_state(void)
 {
     const power_display_svr_api_t *display_api = power_display_svr_get_api();
     screen_state_t state = display_api->get_screen_state();
-    // printf("uapi_get_screen_state = %s . \r\n", state==SCREEN_ON?"on":"off");
-    if( state == SCREEN_ON){
-        return 0;
-    }else{
-        return 1;
+    
+    /* 如果电源管理服务状态为OFF,直接返回OFF */
+    if (state == SCREEN_OFF) {
+        return 1;  /* screen off */
+    }
+    
+    /* 电源管理服务状态为ON时,必须检查LCD实际状态 */
+    /* 只有当LCD已初始化且实际状态为ON时,才返回ON */
+    if (state == SCREEN_ON) {
+        /* 检查LCD是否已初始化 */
+        extern bool uapi_is_lcd_connect(void);
+        if (uapi_is_lcd_connect()) {
+            /* LCD已初始化,检查LCD实际状态 */
+            bool lcd_actual_status = lcd_get_status();
+            if (lcd_actual_status == true) {
+                /* LCD已初始化且状态为ON,返回ON */
+                return 0;  /* screen on */
+            } else {
+                /* LCD已初始化但状态为OFF,返回OFF(状态不同步) */
+                return 1;  /* screen off */
+            }
+        } else {
+            /* LCD未初始化,即使电源管理服务状态为ON,也返回OFF */
+            /* 因为LCD还没准备好,不能认为屏幕是亮的 */
+            return 1;  /* screen off */
+        }
     }
+    
+    /* 其他情况返回OFF */
+    return 1;  /* screen off */
 }
 
 /**
diff --git a/tools/convert_cert_to_c.py b/tools/convert_cert_to_c.py
new file mode 100644 (file)
index 0000000..c3a4398
--- /dev/null
@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+将 PEM 格式的证书文件转换为 C 语言数组格式
+用法: python3 convert_cert_to_c.py <pem_file> <output_file> <var_name>
+"""
+
+import sys
+import os
+
+def pem_to_c_array(pem_file, output_file, var_name):
+    """将 PEM 文件转换为 C 数组"""
+    if not os.path.exists(pem_file):
+        print(f"Error: Certificate file not found: {pem_file}")
+        return False
+    
+    with open(pem_file, 'rb') as f:
+        pem_data = f.read()
+    
+    # 确保变量名合法
+    var_name = var_name.replace('-', '_').replace('.', '_')
+    
+    header_guard = f"{var_name.upper()}_H"
+    
+    with open(output_file, 'w') as f:
+        f.write(f"// CA Certificate for SSL/TLS verification\n")
+        f.write(f"// Generated from: {pem_file}\n")
+        f.write(f"// File size: {len(pem_data)} bytes\n\n")
+        f.write(f"#ifndef {header_guard}\n")
+        f.write(f"#define {header_guard}\n\n")
+        f.write(f"static const unsigned char {var_name}[] = {{\n")
+        
+        for i, byte in enumerate(pem_data):
+            if i % 16 == 0:
+                f.write("    ")
+            f.write(f"0x{byte:02x}")
+            if i < len(pem_data) - 1:
+                f.write(",")
+            if (i + 1) % 16 == 0:
+                f.write("\n")
+            elif i < len(pem_data) - 1:
+                f.write(" ")
+        
+        if len(pem_data) % 16 != 0:
+            f.write("\n")
+        
+        f.write(f"}};\n\n")
+        f.write(f"static const unsigned int {var_name}_len = {len(pem_data)};\n\n")
+        f.write(f"#endif // {header_guard}\n")
+    
+    print(f"✓ Certificate converted successfully:")
+    print(f"  Input:  {pem_file} ({len(pem_data)} bytes)")
+    print(f"  Output: {output_file}")
+    print(f"  Variable: {var_name} (length: {var_name}_len)")
+    return True
+
+def main():
+    if len(sys.argv) != 4:
+        print("Usage: python3 convert_cert_to_c.py <pem_file> <output_file> <var_name>")
+        print("\nExample:")
+        print("  python3 convert_cert_to_c.py ca_cert.pem ca_cert.h ca_cert_pem")
+        sys.exit(1)
+    
+    pem_file = sys.argv[1]
+    output_file = sys.argv[2]
+    var_name = sys.argv[3]
+    
+    if not pem_to_c_array(pem_file, output_file, var_name):
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()
+
+
+
+
+
diff --git a/tools/get_server_cert.sh b/tools/get_server_cert.sh
new file mode 100644 (file)
index 0000000..eab0859
--- /dev/null
@@ -0,0 +1,36 @@
+#!/bin/bash
+# 从服务器获取证书并保存为 PEM 格式
+
+if [ $# -lt 1 ]; then
+    echo "Usage: $0 <hostname> [port]"
+    echo "Example: $0 file-virtual-person-qcl.test.leiniao.com 443"
+    exit 1
+fi
+
+HOSTNAME=$1
+PORT=${2:-443}
+OUTPUT_FILE="${HOSTNAME}_cert.pem"
+
+echo "Fetching certificate from ${HOSTNAME}:${PORT}..."
+
+# 获取证书链
+openssl s_client -showcerts -connect "${HOSTNAME}:${PORT}" < /dev/null 2>/dev/null | \
+    sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' > "${OUTPUT_FILE}"
+
+if [ $? -eq 0 ] && [ -s "${OUTPUT_FILE}" ]; then
+    echo "✓ Certificate saved to: ${OUTPUT_FILE}"
+    echo ""
+    echo "Certificate info:"
+    openssl x509 -in "${OUTPUT_FILE}" -text -noout | head -20
+    echo ""
+    echo "To convert to C array, run:"
+    echo "  python3 convert_cert_to_c.py ${OUTPUT_FILE} ca_cert.h ca_cert_pem"
+else
+    echo "✗ Failed to fetch certificate"
+    exit 1
+fi
+
+
+
+
+