CAT1_SERVICE_HEAD = 'FE' #固定head
PROJECT_NAME = "Cat1SlipUDPService"
-PROJECT_VERSION = "PY_SRV_V15"
+PROJECT_VERSION = "PY_SRV_V16"
CONFIG_JSON="/usr/system_config.json"
CURRENT_APP_TYPE="pysrv"
+
+
+
+
+
# 设置日志输出级别
log.basicConfig(level=log.INFO)
cat1service_log = log.getLogger("cat1service")
elif (app_type == "pyota"):
return "PY_OTA_V14"
elif (app_type == "pysrv"):
- return "PY_SRV_V15"
+ return "PY_SRV_V16"
#如果没有configfile则创建它
if not ql_fs.path_exists(CONFIG_JSON):
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):
# 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))
+ # if ret != 0:
+ # ret = voiceCall.callStart(str(parm))
print("ret={} {} {}".format(ret,cmd,parm))
if ret != 0:
- self.reply_cmd('0F',"callfail")
+ self.reply_cmd('0F',"callcmd_fail")
+ else:
+ self.reply_cmd('0F',"callcmd_success")
+ else:
+ self.reply_cmd('0F',"callcmd_fail")
elif cmd == "02":
print(cmd)
# UDP_CMD_HUNGUP
- voiceCall.callEnd()
+ 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":
print(cmd)
# UDP_CMD_ANSWER
- voiceCall.callAnswer()
+ 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 == "04":
print(cmd)
result = check_fota()
voiceCall.startDtmf(str(parm),100) #100ms 持续时间 100-1000
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":
pass
elif cmd == "14":#
pass
+
pass
def notifyIncomingcall(self, incomming_numb):
self.clear_remain()
__head = '0C'
- self.__message = str(incomming_numb)
- self.__Socket_UDP(__head, self.__message)
+ __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'
- self.__message = str(phone_numb)
- self.__Socket_UDP(__head, self.__message)
+ __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'
- self.__message = str(phone_numb)
- self.__Socket_UDP(__head, self.__message)
+ __message = str(phone_numb)
+ self.__Socket_UDP(__head, __message)
# if self.__err == 1 or self.__value[2] != 'OK':
# return -1
return 0
# 查询网卡状态
def timesync(self,_timesync):
self.clear_remain()
- self.__message = str(_timesync)
- self.__Socket_UDP('0D', self.__message)
+ message = str(_timesync)
+ self.__Socket_UDP('0D', message)
return 0
def reply_timesync(self,_timesync):
self.clear_remain()
- self.__message = str(_timesync)
- self.__Socket_UDP_noreply('0D', self.__message)
+ message = str(_timesync)
+ self.__Socket_UDP_noreply('0D', message)
return 0
def reply_cmd(self,cmd,_timesync):
- self.clear_remain()
- self.__message = str(_timesync)
- self.__Socket_UDP_noreply(cmd, self.__message)
+ try :
+ print('reply_cmd 1')
+ self.clear_remain()
+ message = str(_timesync)
+ print('reply_cmd 2')
+ self.__Socket_UDP_noreply(cmd, message)
+ except:
+ print('reply_cmd')
return 0
def clear_remain(self):
# 封装tlv数据包
def __pack_tlv_format(self, head, content):
- self.head = head
- self.content = content
- if len(self.content) == 0 or len(self.content) > 9999 or len(self.head) != 2:
+ # self.head = head
+ # self.content = content
+ if len(content) == 0 or len(content) > 9999 or len(head) != 2:
print('illegal pack tlv content')
return -1
- len_str ='%04d' % len(self.content)
- tlv_pack = CAT1_SERVICE_HEAD+self.head+len_str+self.content
+ len_str ='%04d' % len(content)
+ tlv_pack = CAT1_SERVICE_HEAD+head+len_str+content
return tlv_pack
# 解码tlv数据包
def __unpack_tlv_format(self, msg):
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:
+ print("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])
+
+
+ print("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])
+
+ print("Socket_SEND_Thread while data:{} {}".format(data[0],data[1]))
+
+ if data:
+ print("data ok!!")
+ else:
+ print("data error!!")
+ except Exception :
+ print("sned Socket >>>")
+
+ def __Socket_UDP_write(self, head, content):
try:
- self.head = head
- self.content = content
+ ##self.head = head
+ # self.content = content
gpioWakeBT.write(1)
utime.sleep_ms(2)
gpioWakeBT.write(0)
utime.sleep_ms(20)
# 消息处理
- msg = self.__pack_tlv_format(self.head, self.content)
+ msg = self.__pack_tlv_format(head, content)
# 向服务端发送消息
server_addr = ('172.16.1.5',1000)
print("__Socket_UDP send msg {}".format(msg))
self.__err = 0
self.__sock.sendto(msg,server_addr)
+ print("__Socket_UDP send 2")
self.__wait_resp = 1
# data = self.__queue.get()
self.__wait_resp = 0
except Exception as error:
print(error)
return 0
-
+
def __Socket_UDP_noreply(self, head, content):
- self.head = head
- self.content = 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(1)
utime.sleep_ms(2)
gpioWakeBT.write(0)
utime.sleep_ms(20)
# 消息处理
- msg = self.__pack_tlv_format(self.head, self.content)
+ msg = self.__pack_tlv_format(head, content)
# 向服务端发送消息
server_addr = ('172.16.1.5',1000)
cat1service = Cat1Service()
-
+#send_data_q = Queue(100)
#voice call callback function
def voice_callback(args):
print('voicecall alerting, PhoneNO: ', args[6])
elif args[0] == 16:
print('voicecall holding, PhoneNO: ', args[6])
+ else:
+ print('voice_callback , args[0]: ', args[0])
#电话消息反馈
voiceCall.setCallback(voice_callback)
# timerCheckRevPin.start(1000,1,checkpin_cb)
+
+
+
+
# while True:
# utime.sleep(5)
}
else
{
+ StatusReset();
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "??????????????????????");
}
g_phoneStatus = PHONE_SINGLE_STATUS;
TOPIC_EVENT_CAT1_SIGNAL_UPDATE,
TOPIC_EVENT_CAT1_POWER_ON,
TOPIC_EVENT_CAT1_POWER_OFF,
+ TOPIC_EVENT_CAT1_CALL_FAIL,
#endif
#ifdef SUPPORT_DEVICE_PAIRING_NOTIFICATION
{TOPIC_EVENT_CAT1_SIGNAL_UPDATE, A_CORE_MASK, 1},
{TOPIC_EVENT_CAT1_POWER_ON, A_CORE_MASK, 1},
{TOPIC_EVENT_CAT1_POWER_OFF, A_CORE_MASK, 1},
+ {TOPIC_EVENT_CAT1_CALL_FAIL,A_CORE_MASK, 1},
#endif
};
UIViewGroup* CreateCalldialView(void);
UIViewGroup* SOS_cant_dial(void);
UIViewGroup* CALL_INCOMING_HINT(void);
+UIViewGroup* CALL_FAIL_HINT(void);
void HonrsViewChange(void);
VolumeSettingView *GetvolumeSetting(void);
{TOPIC_EVENT_CAT1_SIGNAL_UPDATE, PRIORITY_ONE},
{TOPIC_EVENT_CAT1_POWER_ON, PRIORITY_ONE},
{TOPIC_EVENT_CAT1_POWER_OFF, PRIORITY_ONE},
+ {TOPIC_EVENT_CAT1_CALL_FAIL,PRIORITY_ONE},
#endif
#ifdef SUPPORT_SPO2_NOTIFICATION
{TOPIC_EVENT_SPO2_UPDATE, PRIORITY_TWO},
MsgCenterSubscribeTopic(TOPIC_EVENT_CAT1_SIGNAL_UPDATE);
MsgCenterSubscribeTopic(TOPIC_EVENT_CAT1_POWER_ON);
MsgCenterSubscribeTopic(TOPIC_EVENT_CAT1_POWER_OFF);
+ MsgCenterSubscribeTopic(TOPIC_EVENT_CAT1_CALL_FAIL);
+
#endif
#ifdef SUPPORT_DEVICE_PAIRING_NOTIFICATION //如果支持设备配对通知
MsgCenterSubscribeTopic(TOPIC_EVENT_DEVICE_BIND);
return OHOS::CreateDebugOutputMainView();
}
+
+static OHOS::UIViewGroup* showcallfailNotify(void)
+{
+ return OHOS::CALL_FAIL_HINT();
+}
+
+
void MsgCenterNotifyAlarmProc(const Topic topic, Request* req)
{
unused(req);
}
+
+void MsgCenterNotifyCat1FailEProc(const Topic topic, Request* req)
+{
+ unused(req);
+
+ if (true != OHOS::ConfigModel::GetInstance()->GetDnotdisturb() && (!uapi_sleep_mode_flag_get()))
+ {
+ ui_api_vibrate_once_func();
+ }
+
+ //NotificationManager::GetInstance()->SetNotifyPriority(PRIORITY_ONE);
+
+ if(NotificationManager::GetInstance()->HasNotifyShowing())
+ NotificationManager::GetInstance()->StopNotify();
+
+ NotificationManager::GetInstance()->ShowNotify(showcallfailNotify,
+ static_cast<uint16_t>(topic), true);
+}
+
+
+
void MsgCenterNotifyHfpWatchProc(const Topic topic, Request* req)
{
unused(req);
{
cat1_call_hungup();
-
cat1_phone_state_change_cb(OPERATE_WATCH_FINISH);
+
+ CustomEventPublish(TOPIC_EVENT_CAT1_CALL_FAIL,NULL,0);
+
free(call_data);
return;
}
{TOPIC_EVENT_CAT1_SIGNAL_UPDATE, MsgCenterNotifyCat1SignalUpdateProc},
{TOPIC_EVENT_CAT1_POWER_ON, MsgCenterNotifyCat1PowerOnProc},
{TOPIC_EVENT_CAT1_POWER_OFF, MsgCenterNotifyCat1PowerOffProc},
+ {TOPIC_EVENT_CAT1_CALL_FAIL, MsgCenterNotifyCat1FailEProc},
#endif
#ifdef SUPPORT_DEVICE_PAIRING_NOTIFICATION
{TOPIC_EVENT_DEVICE_BIND, MsgCenterNotifyDeviceBindProc},
UIViewGroup* HintView = nullptr;
static UILabelExt *Hint_UILabel=nullptr;
+
+
+UIViewGroup* FAILHintView = nullptr;
+static UILabelExt *FAIL_Hint_UILabel=nullptr;
// typedef struct {
// char name[NAME_SIZE];
// unsigned char nameLen;
}
}
+void hintdialfailtimerCallBack(int data)
+{
+ {
+ NotificationManager::GetInstance()->StopNotify();
+ }
+
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "hintdialtimerCallBack ??????!");
+
+}
+
+
+static osTimerId_t CALL_FAIl_HINT_timer= NULL;
+
+void FreeFAILhintView(void)
+{
+ if (FAILHintView != nullptr) {
+
+ FAILHintView->RemoveAll();
+ if(FAIL_Hint_UILabel)
+ {
+ delete FAIL_Hint_UILabel;
+ FAIL_Hint_UILabel=nullptr;
+ }
+
+ if(CALL_FAIl_HINT_timer)
+ {
+ osTimerStop(CALL_FAIl_HINT_timer);
+ osStatus_t ret = osTimerDelete(CALL_FAIl_HINT_timer);
+ if (ret != osOK) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Disatransmitting_timer failed ret = %lx!", ret);
+ //return;
+ }
+ CALL_FAIl_HINT_timer = nullptr;
+ }
+
+
+ RootView::GetInstance()->Remove(FAILHintView);
+ delete FAILHintView;
+ FAILHintView = nullptr;
+ }
+}
+
+
+
+UIViewGroup* CALL_FAIL_HINT(void)
+{
+
+ if (FAILHintView == nullptr) {
+ FAILHintView = new UIViewGroup();
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CreateCallingView callingView null!");
+
+ }
+ FAILHintView->SetPosition(MATH_ZERO, MATH_ZERO);
+ FAILHintView->SetWidth(Screen::GetInstance().GetWidth());
+ FAILHintView->SetHeight(Screen::GetInstance().GetHeight());
+ FAILHintView->SetStyle(STYLE_BACKGROUND_OPA, 0);
+
+ if (FAIL_Hint_UILabel == nullptr) {
+ FAIL_Hint_UILabel = new UILabelExt();
+ }
+ FAIL_Hint_UILabel->SetPosition(62, 199); // widget's left position and top position
+ FAIL_Hint_UILabel->Resize(340, 30); // widget's width and height
+ FAIL_Hint_UILabel->SetViewId("label3");// Set style
+ FAIL_Hint_UILabel->SetStyle(STYLE_BACKGROUND_COLOR, 0xffAAAAAA);
+ FAIL_Hint_UILabel->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
+ FAIL_Hint_UILabel->SetStyle(STYLE_BORDER_RADIUS, 27);
+ FAIL_Hint_UILabel->SetStyle(STYLE_TEXT_FONT, 40);
+ FAIL_Hint_UILabel->SetStyle(STYLE_LINE_SPACE, 0);
+
+ // Set additional property
+ FAIL_Hint_UILabel->SetText("网络异常");
+ FAIL_Hint_UILabel->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
+ FAIL_Hint_UILabel->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ FAIL_Hint_UILabel->SetRollSpeed(0);
+ FAIL_Hint_UILabel->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 40);
+
+ FAILHintView->Add(FAIL_Hint_UILabel);
+ FAIL_Hint_UILabel->SetVisible(true);
+ FAIL_Hint_UILabel->LayoutCenterOfParent();
+
+ uint32_t tick;
+ osStatus_t retTimer;
+ // CALL_INCOMING_HINT_timer_FALG=3;
+
+ if(CALL_FAIl_HINT_timer)
+ osTimerDelete(CALL_FAIl_HINT_timer);
+ CALL_FAIl_HINT_timer=NULL;
+
+ CALL_FAIl_HINT_timer = osTimerNew((osTimerFunc_t)hintdialfailtimerCallBack, osTimerPeriodic, NULL, NULL);
+ tick =osMs2Tick(2000);// osMs2Tick(1000);
+ retTimer = osTimerStart(CALL_FAIl_HINT_timer, tick);
+ if (retTimer != osOK && CALL_FAIl_HINT_timer != NULL) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"StartCallTimer osTimerStart failed, ret = %lx!!", retTimer);
+ osTimerDelete(CALL_FAIl_HINT_timer);
+ CALL_FAIl_HINT_timer = NULL;
+ return NULL;
+ }
+
+ NotificationManager::GetInstance()->RegisterNotifyCleanupFunction(FreeFAILhintView);
+
+ return FAILHintView;
+
+}
+
+
+
UIViewGroup* CALL_INCOMING_HINT(void)
{
- HintView = new UIViewGroup();
+
if (HintView == nullptr) {
+ HintView = new UIViewGroup();
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CreateCallingView callingView null!");
- return nullptr;
+ //return nullptr;
}
HintView->SetPosition(MATH_ZERO, MATH_ZERO);
HintView->SetWidth(Screen::GetInstance().GetWidth());
Hint_UILabel->SetVisible(true);
Hint_UILabel->LayoutCenterOfParent();
+ if(CALL_INCOMING_HINT_timer)
+ osTimerDelete(CALL_INCOMING_HINT_timer);
+ CALL_INCOMING_HINT_timer=NULL;
+
uint32_t tick;
osStatus_t retTimer;
CALL_INCOMING_HINT_timer_FALG=3;
}
+
static void WatchActiveHandle()
{
DisableCallTimer(CallTimerType::NOTIFY_PHONE_DIAL_DISPLAY);
CAT1_SERVICE_HEAD = 'FE' #固定head
PROJECT_NAME = "Cat1SlipUDPService"
-PROJECT_VERSION = "PY_SRV_V15"
+PROJECT_VERSION = "PY_SRV_V16"
CONFIG_JSON="/usr/system_config.json"
CURRENT_APP_TYPE="pysrv"
+
+
+
+
+
# 设置日志输出级别
log.basicConfig(level=log.INFO)
cat1service_log = log.getLogger("cat1service")
elif (app_type == "pyota"):
return "PY_OTA_V14"
elif (app_type == "pysrv"):
- return "PY_SRV_V15"
+ return "PY_SRV_V16"
#如果没有configfile则创建它
if not ql_fs.path_exists(CONFIG_JSON):
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):
# 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))
+ # if ret != 0:
+ # ret = voiceCall.callStart(str(parm))
print("ret={} {} {}".format(ret,cmd,parm))
if ret != 0:
- self.reply_cmd('0F',"callfail")
+ self.reply_cmd('0F',"callcmd_fail")
+ else:
+ self.reply_cmd('0F',"callcmd_success")
+ else:
+ self.reply_cmd('0F',"callcmd_fail")
elif cmd == "02":
print(cmd)
# UDP_CMD_HUNGUP
- voiceCall.callEnd()
+ 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":
print(cmd)
# UDP_CMD_ANSWER
- voiceCall.callAnswer()
+ 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 == "04":
print(cmd)
result = check_fota()
voiceCall.startDtmf(str(parm),100) #100ms 持续时间 100-1000
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":
pass
elif cmd == "14":#
pass
+
pass
def notifyIncomingcall(self, incomming_numb):
self.clear_remain()
__head = '0C'
- self.__message = str(incomming_numb)
- self.__Socket_UDP(__head, self.__message)
+ __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'
- self.__message = str(phone_numb)
- self.__Socket_UDP(__head, self.__message)
+ __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'
- self.__message = str(phone_numb)
- self.__Socket_UDP(__head, self.__message)
+ __message = str(phone_numb)
+ self.__Socket_UDP(__head, __message)
# if self.__err == 1 or self.__value[2] != 'OK':
# return -1
return 0
# 查询网卡状态
def timesync(self,_timesync):
self.clear_remain()
- self.__message = str(_timesync)
- self.__Socket_UDP('0D', self.__message)
+ message = str(_timesync)
+ self.__Socket_UDP('0D', message)
return 0
def reply_timesync(self,_timesync):
self.clear_remain()
- self.__message = str(_timesync)
- self.__Socket_UDP_noreply('0D', self.__message)
+ message = str(_timesync)
+ self.__Socket_UDP_noreply('0D', message)
return 0
def reply_cmd(self,cmd,_timesync):
- self.clear_remain()
- self.__message = str(_timesync)
- self.__Socket_UDP_noreply(cmd, self.__message)
+ try :
+ print('reply_cmd 1')
+ self.clear_remain()
+ message = str(_timesync)
+ print('reply_cmd 2')
+ self.__Socket_UDP_noreply(cmd, message)
+ except:
+ print('reply_cmd')
return 0
def clear_remain(self):
# 封装tlv数据包
def __pack_tlv_format(self, head, content):
- self.head = head
- self.content = content
- if len(self.content) == 0 or len(self.content) > 9999 or len(self.head) != 2:
+ # self.head = head
+ # self.content = content
+ if len(content) == 0 or len(content) > 9999 or len(head) != 2:
print('illegal pack tlv content')
return -1
- len_str ='%04d' % len(self.content)
- tlv_pack = CAT1_SERVICE_HEAD+self.head+len_str+self.content
+ len_str ='%04d' % len(content)
+ tlv_pack = CAT1_SERVICE_HEAD+head+len_str+content
return tlv_pack
# 解码tlv数据包
def __unpack_tlv_format(self, msg):
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:
+ print("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])
+
+
+ print("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])
+
+ print("Socket_SEND_Thread while data:{} {}".format(data[0],data[1]))
+
+ if data:
+ print("data ok!!")
+ else:
+ print("data error!!")
+ except Exception :
+ print("sned Socket >>>")
+
+ def __Socket_UDP_write(self, head, content):
try:
- self.head = head
- self.content = content
+ ##self.head = head
+ # self.content = content
gpioWakeBT.write(1)
utime.sleep_ms(2)
gpioWakeBT.write(0)
utime.sleep_ms(20)
# 消息处理
- msg = self.__pack_tlv_format(self.head, self.content)
+ msg = self.__pack_tlv_format(head, content)
# 向服务端发送消息
server_addr = ('172.16.1.5',1000)
print("__Socket_UDP send msg {}".format(msg))
self.__err = 0
self.__sock.sendto(msg,server_addr)
+ print("__Socket_UDP send 2")
self.__wait_resp = 1
# data = self.__queue.get()
self.__wait_resp = 0
except Exception as error:
print(error)
return 0
-
+
def __Socket_UDP_noreply(self, head, content):
- self.head = head
- self.content = 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(1)
utime.sleep_ms(2)
gpioWakeBT.write(0)
utime.sleep_ms(20)
# 消息处理
- msg = self.__pack_tlv_format(self.head, self.content)
+ msg = self.__pack_tlv_format(head, content)
# 向服务端发送消息
server_addr = ('172.16.1.5',1000)
cat1service = Cat1Service()
-
+#send_data_q = Queue(100)
#voice call callback function
def voice_callback(args):
print('voicecall alerting, PhoneNO: ', args[6])
elif args[0] == 16:
print('voicecall holding, PhoneNO: ', args[6])
+ else:
+ print('voice_callback , args[0]: ', args[0])
#电话消息反馈
voiceCall.setCallback(voice_callback)
# timerCheckRevPin.start(1000,1,checkpin_cb)
+
+
+
+
# while True:
# utime.sleep(5)
UDP_MSG_SEND_DTMF_NUMBER = 0x19,//DTMF 功能
UDP_MSG_SEND_VOLTE_SWITCH = 0x1A,//VOLTE开关
+
+ UDP_MSG_WATCH_REPLY_ACK = 0xAC,//
+ // UDP_MSG_WATCH_REPLY_HANGUP = 0x21,//
};
/** 0: old format 1字节cmd, 1: new format 2字节cmd */
static uint8_t g_msg_format_type = 0;
+// void watch_replay_cat1_ANSWER(void);
static char ble_buffer[20] = {0};
void set_skip_cat1_service_udp_transfer(uint8_t skip)
#define MAX_TIME_SYNC_RETRY_TIME 5
static uint8_t g_time_sync_retry_time = 0;
-#define PY_SRV_VER_CURRENT 15
+#define PY_SRV_VER_CURRENT 16
#define PY_SRV_VER_SUPORT_PY_OTA_MINI_VER 13
#define PY_SRV_VER_4 "PY_SRV_V4"
static uint8_t g_py_ver = 4;
+
+static osTimerId_t g_timer_time_answer = NULL;
+
+static osTimerId_t g_timer_time_Dial = NULL;
+
/**如果
* g_python_updated == 0 &&
* g_py_ver >= PY_SRV_VER_SUPORT_PY_OTA_MINI_VER &&
static int decodeSMS(char* msg)
{
// FE150117ref:0@total_num:1@seq:1@data:0100240D91688139687502F200084250926172722316662F6211670B53CB621153EF80FD9700898198847EA6
-
+ uint32_t ref=0;
+ uint16_t num=0;
+ uint16_t seq=0;
+
int msglen = strlen(msg)+1;
if (msglen < 25)
{
{
char* ptmp=s+4;
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ref %s\r\n",ptmp);
+ ref=atoi(ptmp);
}else if ((strlen(s)> 10) && (strncmp(s,"total_num:",10) == 0) )
{
+
char* ptmp=s+10;
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"total_num %s\r\n",ptmp);
+ num=atoi(ptmp);
}else if ((strlen(s)> 4) && (strncmp(s,"seq:",4) == 0) )
{
char* ptmp=s+4;
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"seq %s\r\n",ptmp);
+ seq=atoi(ptmp);
}else if ((strlen(s)> 5) && (strncmp(s,"data:",5) == 0) )
{
char* ptmp=s+5;
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"data %s\r\n",ptmp);
- pdu_decode_example(ptmp);
+ pdu_decode_example(ptmp,ref,num,seq);
}
}
free(msgbuf);
int update = 0;
if (strlen(msg) < 50)
{
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"msg len is too short !\r\n");
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"msg len is too short !\r\n");
return -1;
}
char buf[200] = {0};
{
ppbuf = s+5;
char* imei = uapi_dev_runtime_get_cat1_imei();
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"=== imei %s to %s\r\n",imei,ppbuf);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"=== imei %s to %s\r\n",imei,ppbuf);
if ( strcmp(imei,ppbuf)!=0 )
{
update++;
{
ppbuf=s+4;
int simstat = atoi(ppbuf);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"=== sim = %d\r\n",simstat);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"=== sim = %d\r\n",simstat);
if ( uapi_dev_runtime_get_cat1_simstat() != simstat)
{
update++;
char* opera=uapi_dev_runtime_get_cat1_operator();
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"=== opera %s to %s\r\n",opera,ppbuf);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"=== opera %s to %s\r\n",opera,ppbuf);
if ( strcmp(opera,ppbuf)!=0 )
{
update++;
{
ppbuf=s+7;
int signals = atoi(ppbuf);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"=== signal = %d\r\n",signals);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"=== signal = %d\r\n",signals);
if ( uapi_dev_runtime_get_cat1_signal() != signals)
{
update++;
case 2:
{
int networkon = atoi(s) ;
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"=== networkon = %d , %s \n",networkon,networkon==1?"connected":networkon==5?"roaming":"unkown");
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"=== networkon = %d , %s \n",networkon,networkon==1?"connected":networkon==5?"roaming":"unkown");
switch(networkon)
{
case 1:
case 3:
{
int network_type = atoi(s);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"=== network_type = %d , %s\n",network_type,
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"=== network_type = %d , %s\n",network_type,
network_type==0?"GSM":network_type==1?"GSM COMPACT":network_type==2?"UTRAN":network_type==3?"GSM wEGPRS":network_type==4?"UTRAN wHSDPA":network_type==5?"UTRAN wHSUPA":network_type==6?"UTRAN wHSDPA HSUPA":network_type==7?"E_UTRAN":network_type==8?"UTRAN HSPAP":network_type==9?"E_UTRAN_CA":"NONE"
);
switch (network_type)
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"start cat1 python ota\n");
Cat1_OTA(CAT1_TCP_START_OTA);
}else{
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"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);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"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);
}
}
g_python_updated = 1;
-
-
-
void cat1_call_hungup(void)
{
udp_send_msg_toCat1(UDP_CMD_HUNGUP,"0");
void cat1_call_answer(void)
{
- udp_send_msg_toCat1(UDP_CMD_ANSWER,"0");
+ #if PY_SRV_VER_CURRENT >=16
+ if(osTimerIsRunning(g_timer_time_answer)==0 )
+ {
+ osStatus_t ret = osTimerStart(g_timer_time_answer,3000);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_MAIN_SERVICE,"cat1 g_timer_time_answer timer ret %d\n",ret);
+ }
+ #endif
+ udp_send_msg_toCat1(UDP_CMD_ANSWER,"0");
}
+
void cat1_ota_update(char *url)
{
udp_send_msg_toCat1(UDP_CMD_CAT1_OTA_UPDATE,url);
bool volte = OHOS::ConfigModel::GetInstance()->GetVoLTE_Call();
if (volte == true){
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"cat1_call_dial %s\n",phonenum);
+ #if PY_SRV_VER_CURRENT >=16
+ if(osTimerIsRunning(g_timer_time_Dial)==0 )
+ {
+ osStatus_t ret = osTimerStart(g_timer_time_Dial,3000);
+ WEARABLE_LOGI(WEARABLE_LOG_MODULE_MAIN_SERVICE,"cat1 g_timer_time_Dial timer ret %d\n",ret);
+ }
+ #endif
+
udp_send_msg_toCat1(UDP_CMD_DIAL_NUMB,phonenum);
}
+
}
{
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"UDP_CMD_GET_TIME\n");
udp_send_msg_toCat1(UDP_CMD_GET_TIME,"0");
-
}
+
+// void watch_replay_cat1_ANSWER(void)
+// {
+// udp_send_msg_toCat1(UDP_MSG_WATCH_REPLY_ANSWER,"0");
+// }
+
+
+// void watch_replay_cat1_HANGUP(void)
+// {
+// udp_send_msg_toCat1(UDP_MSG_WATCH_REPLY_HANGUP,"0");
+// }
+
+
void cat1_getver(void)
{
udp_send_msg_toCat1(UDP_CMD_GET_CAT1VER,"0");
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MAIN_SERVICE,"cat1 incomming call %s\n",phonenum);
incomingcall_event_sendmsg_toUI(phonenum);
- //声音
- //uapi_cat1_start_volte_voice();
- //由于incomingcall_event_sendmsg_toUI中的参数是char* 在其他地方会使用。因此要保留内存存在，只能在更新时刷新。
- // free(phonenum);
return 1;
}
}
+//电话接听超时
+static void time_answer_func(void)
+{
+ osTimerStop(g_timer_time_answer);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_MAIN_SERVICE,"time_answer_func\n");
+ cat1_handle_call_disconnected("callfail");
+}
+
+//电话接听超时
+static void time_dial_func(void)
+{
+ osTimerStop(g_timer_time_Dial);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_MAIN_SERVICE,"time_dial_func\n");
+ cat1_handle_call_disconnected("callfail");
+}
+
int cat1_handle_call_connected(char* phonenum)
{
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_MAIN_SERVICE,"cat1 call connected %s\n",phonenum);
+ // watch_replay_cat1_ANSWER();
+
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_MAIN_SERVICE,"cat1 call connected %s\n",phonenum);
//声音处理
incomedcall_event_sendmsg_toUI(phonenum);
//uapi_cat1_start_volte_voice();
-
return 1;
}
//来电挂断处理
{
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MAIN_SERVICE,"cat1 call disconnected %s\n",phonenum);
//TODO: 关闭声音
+ // watch_replay_cat1_HANGUP();
+
callend_event_sendmsg_toUI(phonenum);
return 1;
}
msg_buffer_len = msg->length;
cmd = get_int8_from_ascii_char(rx_buffer[1]);
}
- // printf("cmd %x,bufferlen %d , buffer %s \n",cmd,msg_buffer_len,msg_buffer);
+ printf("cmd %x,bufferlen %d , buffer %s \n",cmd,msg_buffer_len,msg_buffer);
+
+ udp_send_msg_toCat1(UDP_MSG_WATCH_REPLY_ACK,"0");
+
switch (cmd) {
case UDP_MSG_COMMING_CALL:
if (get_volte_switch() == false) //如果VOLTE开关没有开启则不接CAT1的来电功能
}
}
- if(strstr(msg_buffer,"callfail")!=NULL)
+ if(strstr(msg_buffer,"callanswer_success")!=NULL)
+ {
+ osTimerStop(g_timer_time_answer);
+ incomedcall_event_sendmsg_toUI("callanswer_success");
+
+ }
+ if(strstr(msg_buffer,"callcmd_fail")!=NULL)
{
- cat1_handle_call_disconnected("callfail");
+ // osTimerStop(g_timer_time_Dial);
+ // cat1_handle_call_disconnected("callfail");
+ }
+
+ if(strstr(msg_buffer,"callcmd_success")!=NULL)
+ {
+ //cat1_handle_call_disconnected("callfail");
+ osTimerStop(g_timer_time_Dial);
+
}
break;
case UDP_MSG_GET_TELECON_DMP_TIMESEC://暂时不用
restart_time_sync();
+ g_timer_time_Dial = osTimerNew((osTimerFunc_t)time_dial_func, osTimerPeriodic, NULL, NULL);
+ if (g_timer_time_Dial == NULL)
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"g_timer_time_sync create failed\n");
+
+ g_timer_time_answer = osTimerNew((osTimerFunc_t)time_answer_func, osTimerPeriodic, NULL, NULL);
+ if (g_timer_time_answer == NULL)
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"g_timer_time_sync create failed\n");
+
+
#ifdef USE_CAT1_SLEEP_TIMER
g_timer_cat1_sleep = osTimerNew((osTimerFunc_t)timeout_handler_sleep_cat1, osTimerPeriodic, NULL, NULL);
if (g_timer_cat1_sleep == NULL)
const char *inpdustr = (const char*)argv[0];
- pdu_decode_example(inpdustr);
+ pdu_decode_example(inpdustr,0,0,0);
return ERRCODE_SUCC;
}
output_sms_text_length 16, index 29
pdustr len 45,phonenumb:8615521469561 ,text:计划的好好的基金 ,txtlen:24, receive time 0124-04-28 18:20:25 offset 28800 , timestampe 1716891625
*/
+
+
static uint32_t ancs_msg_index =0;
-int pdu_decode_example(const char *inpdustr )
+// typedef struct
+// {
+// uint32_t ref;
+// uint16_t num;
+// char *phone_number;
+// char *text;
+// }pdu_data;
+
+// static pdu_data[20]={0};
+
+int pdu_decode_example(const char *inpdustr, uint32_t ref,uint16_t num, uint16_t seq)
{
int ret=0;
#define SMS_PDU_H_
#include <time.h>
+#include <stdint.h>
+#include <stdio.h>
+// #include "errcode.h"
+
+// #include "bts_def.h"
enum { SMS_MAX_PDU_LENGTH = 256 };
time_t *output_sms_timestamp,
char* output_sender_phone_number, int sender_phone_number_size,
char* output_sms_text, int sms_text_size);
-int pdu_decode_example(const char *inpdustr );
+
+int pdu_decode_example(const char *inpdustr , uint32_t ref,uint16_t num, uint16_t seq);
#endif // SMS_SMS_H_
projects / mirrors / FD230.git / commitdiff