[Feature][T8TSK-81]Merged and upload MR3.0 New Modify content,merged meta-sdk,modem
Change-Id: Idb6c80fcf349c0db72e7ca3fa5b1fd7944ec1290
diff --git a/src/lynq/lib/libautosuspend/libautosuspend.c b/src/lynq/lib/libautosuspend/libautosuspend.c
index d39bab1..58412a6 100644
--- a/src/lynq/lib/libautosuspend/libautosuspend.c
+++ b/src/lynq/lib/libautosuspend/libautosuspend.c
@@ -28,6 +28,7 @@
static bool libautosuspend_inited;
+bool feedback_flag = true; //add for after sleeping once calling lynq_wailt_wakeup_event does not return sleep time
// static bool libautosuspend_enabled;
// static pthread_mutex_t get_feedback_mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -468,7 +469,16 @@
int *socket_timeout = NULL;
struct time_info_t time_info;
int ret = 0;
-
+ /*add for after sleeping once calling lynq_wailt_wakeup_event does not return sleep time start*/
+ if(feedback_flag == true)
+ {
+ if(libautosuspend_init() != 0)
+ {
+ return -1;
+ }
+ }
+ feedback_flag = false;
+ /*add for after sleeping once calling lynq_wailt_wakeup_event does not return sleep time end*/
memset(&time_info,0,sizeof(struct time_info_t));
if(sleep_start_time == NULL || wakeup_time == NULL )
{
diff --git a/src/lynq/lib/liblynq-at-common/LICENSE b/src/lynq/lib/liblynq-at-common/LICENSE
new file mode 100755
index 0000000..382fc78
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-common/LICENSE
@@ -0,0 +1,31 @@
+Copyright Statement:
+
+This software/firmware and related documentation ("Mobiletek Software") are
+protected under relevant copyright laws. The information contained herein is
+confidential and proprietary to Mobiletek Inc. and/or its licensors. Without
+the prior written permission of Mobiletek inc. and/or its licensors, any
+reproduction, modification, use or disclosure of Mobiletek Software, and
+information contained herein, in whole or in part, shall be strictly
+prohibited.
+
+Mobiletek Inc. (C) 2015. All rights reserved.
+
+BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
+THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("Mobiletek SOFTWARE")
+RECEIVED FROM Mobiletek AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
+ON AN "AS-IS" BASIS ONLY. Mobiletek EXPRESSLY DISCLAIMS ANY AND ALL
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+NONINFRINGEMENT. NEITHER DOES Mobiletek PROVIDE ANY WARRANTY WHATSOEVER WITH
+RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
+INCORPORATED IN, OR SUPPLIED WITH THE Mobiletek SOFTWARE, AND RECEIVER AGREES
+TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
+RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
+OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN Mobiletek
+SOFTWARE. Mobiletek SHALL ALSO NOT BE RESPONSIBLE FOR ANY Mobiletek SOFTWARE
+RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
+STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND Mobiletek'S
+ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE Mobiletek SOFTWARE
+RELEASED HEREUNDER WILL BE, AT Mobiletek'S OPTION, TO REVISE OR REPLACE THE
+Mobiletek SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
+CHARGE PAID BY RECEIVER TO Mobiletek FOR SUCH Mobiletek SOFTWARE AT ISSUE.
\ No newline at end of file
diff --git a/src/lynq/lib/liblynq-at-common/atci_at_util.cpp b/src/lynq/lib/liblynq-at-common/atci_at_util.cpp
new file mode 100755
index 0000000..4c215a7
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-common/atci_at_util.cpp
@@ -0,0 +1,171 @@
+#include <string.h>
+#include <stdlib.h>
+#include <log/log.h>
+#include "atci_at_util.h"
+
+#undef LOG_TAG
+#define LOG_TAG "AT_COMMON"
+
+int atci_at_skip_space(char **p_cur) {
+ if (*p_cur == NULL) {
+ return SYS_FAIL;
+ }
+ while (**p_cur == ATCI_SPACE) {
+ (*p_cur)++;
+ }
+ return SYS_SUCC;
+}
+int atci_at_hasmore(char **p_cur) {
+ if (*p_cur == NULL || **p_cur == ATCI_END_CHAR) {
+ return SYS_FAIL;
+ }
+ return SYS_SUCC;
+}
+
+int atci_at_to_equal(char **p_cur) {
+ if (*p_cur == NULL) {
+ return SYS_FAIL;
+ }
+ *p_cur = strchr(*p_cur, ATCI_EQUAL);
+ if (*p_cur == NULL) {
+ return SYS_FAIL;
+ }
+ (*p_cur)++;
+ return SYS_SUCC;
+}
+int atci_at_to_colon(char **p_cur) {
+ if (*p_cur == NULL) {
+ return SYS_FAIL;
+ }
+ *p_cur = strchr(*p_cur, ATCI_COLON);
+ if (*p_cur == NULL) {
+ return SYS_FAIL;
+ }
+ (*p_cur)++;
+ return SYS_SUCC;
+}
+int atci_at_skip_next_comma(char **p_cur) {
+ if (*p_cur == NULL) {
+ return SYS_FAIL;
+ }
+ *p_cur = strchr(*p_cur, ATCI_COMMA);
+ if (*p_cur == NULL) {
+ return SYS_FAIL;
+ }
+ (*p_cur)++;
+ return SYS_SUCC;
+}
+int atci_at_get_next_key(char **p_cur, char **p_out) {
+ if (*p_cur == NULL) {
+ return SYS_FAIL;
+ }
+ atci_at_skip_space(p_cur);
+ if (**p_cur == ATCI_DOUBLE_QUOTE) {
+ (*p_cur)++;
+ *p_out = strsep(p_cur, "\"");
+ atci_at_skip_next_comma(p_cur);
+ } else {
+ *p_out = strsep(p_cur, ",");
+ }
+ return SYS_SUCC;
+}
+
+/**
+ * Parses the next integer in the line and places it in *p_out
+ * "uns" is indicate in unsigned or not
+ * returns SYS_SUCC on success
+ * returns SYS_FAIL on fail
+ * updates *p_cur
+ * "base" is the same as the base param in strtol
+ */
+int atci_at_get_nextint_base(char **p_cur, int *p_out, int base, int uns) {
+ char *ret;
+ if (*p_cur == NULL) {
+ return SYS_FAIL;
+ }
+ if (SYS_FAIL == atci_at_get_next_key(p_cur, &ret)) {
+ return SYS_FAIL;
+ } else {
+ long l;
+ char *end;
+ if (uns) {
+ l = strtoul(ret, &end, base);
+ } else {
+ l = strtol(ret, &end, base);
+ }
+ *p_out = (int) l;
+ if (end == ret) {
+ return SYS_FAIL;
+ }
+ }
+ return SYS_SUCC;
+}
+int atci_at_get_nextint(char **p_cur, int *p_out) {
+ return atci_at_get_nextint_base(p_cur, p_out, 10, 0);
+}
+int atci_at_get_nexthexint(char **p_cur, int *p_out) {
+ return atci_at_get_nextint_base(p_cur, p_out, 16, 1);
+}
+int atci_get_cmd_mode(char *line) {
+ int reasult = AT_WRONG_MODE;
+ char *p_cur = NULL;
+ if (NULL == line) {
+ reasult = AT_WRONG_MODE;
+ RLOGD("atci_get_cmd_mode error, input is NULL");
+ return reasult;
+ }
+ p_cur = strchr(line, ATCI_EQUAL);
+ if (NULL == p_cur) {
+ p_cur = strchr(line, ATCI_QUESTION_MARK);
+ if (NULL == p_cur) {
+ reasult = AT_ACTIVE_MODE;
+ } else {
+ reasult = AT_READ_MODE;
+ }
+ } else {
+ p_cur++;
+ atci_at_skip_space(&p_cur);
+ if (ATCI_QUESTION_MARK == *p_cur) {
+ reasult = AT_TEST_MODE;
+ } else {
+ reasult = AT_SET_MODE;
+ }
+ }
+ RLOGD("atci_get_cmd_mode success[%d]", reasult);
+ return reasult;
+}
+
+char* atci_get_cmd_prefix(char *line) {
+ int buf_len;
+ char *prefix;
+ char *end_ptr;
+ if (NULL == line) {
+ RLOGD("input is null");
+ return NULL;
+ }
+ end_ptr = line;
+ while (!ATCI_IS_CAHR(*end_ptr, ATCI_EQUAL)
+ && !ATCI_IS_CAHR(*end_ptr, ATCI_QUESTION_MARK)
+ && !ATCI_IS_CAHR(*end_ptr, ATCI_END_CHAR)
+ && !ATCI_IS_CAHR(*end_ptr, ATCI_CR) && !ATCI_IS_CAHR(*end_ptr, ATCI_LF)) {
+ end_ptr++;
+ }
+ buf_len = end_ptr - line + 1;
+ prefix = (char *) calloc(buf_len, 1);
+ if (prefix) {
+ int i;
+ char *in_ptr = line;
+ char *out_ptr = prefix;
+ for (i = 0; i < buf_len - 1; i++) {
+ if (!ATCI_IS_CAHR(*in_ptr, ATCI_SPACE)) {
+ *out_ptr = ATCI_UPPER_TO_LOWER(*in_ptr);
+ out_ptr++;
+ }
+ in_ptr++;
+ }
+ *out_ptr = ATCI_END_CHAR;
+ }
+ RLOGD("get cmd prefix [%d][%s]", buf_len, prefix);
+ return prefix;
+}
+
diff --git a/src/lynq/lib/liblynq-at-common/atci_at_util.h b/src/lynq/lib/liblynq-at-common/atci_at_util.h
new file mode 100755
index 0000000..d84fd63
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-common/atci_at_util.h
@@ -0,0 +1,128 @@
+#ifndef _ATCI_AT_UTIL_H_
+#define _ATCI_AT_UTIL_H_
+
+#define SYS_SUCC 0
+#define SYS_FAIL -1
+
+typedef enum {
+ ATCI_SPACE = ' ',
+ ATCI_EQUAL = '=',
+ ATCI_COMMA = ',',
+ ATCI_SEMICOLON = ';',
+ ATCI_COLON = ':',
+ ATCI_AT = '@',
+ ATCI_HAT = '^',
+ ATCI_MONEY = '$',
+ ATCI_DOUBLE_QUOTE = '"',
+ ATCI_QUESTION_MARK = '?',
+ ATCI_EXCLAMATION_MARK = '!',
+ ATCI_FORWARD_SLASH = '/',
+ ATCI_L_ANGLE_BRACKET = '<',
+ ATCI_R_ANGLE_BRACKET = '>',
+ ATCI_R_BRACKET = ')',
+ ATCI_L_BRACKET = '(',
+ ATCI_L_SQ_BRACKET = '[',
+ ATCI_R_SQ_BRACKET = ']',
+ ATCI_L_CURLY_BRACKET = '{',
+ ATCI_R_CURLY_BRACKET = '}',
+ ATCI_CHAR_STAR = '*',
+ ATCI_CHAR_POUND = '#',
+ ATCI_CHAR_AMPSAND = '&',
+ ATCI_CHAR_PERCENT = '%',
+ ATCI_CHAR_PLUS = '+',
+ ATCI_CHAR_MINUS = '-',
+ ATCI_CHAR_DOT = '.',
+ ATCI_CHAR_ULINE = '_',
+ ATCI_CHAR_TILDE = '~',
+ ATCI_CHAR_REVERSE_SOLIDUS = '\\',
+ ATCI_CHAR_VERTICAL_LINE = '|',
+ ATCI_END_CHAR = '\0',
+ ATCI_CR = '\r',
+ ATCI_LF = '\n',
+ ATCI_CHAR_0 = '0',
+ ATCI_CHAR_1 = '1',
+ ATCI_CHAR_2 = '2',
+ ATCI_CHAR_3 = '3',
+ ATCI_CHAR_4 = '4',
+ ATCI_CHAR_5 = '5',
+ ATCI_CHAR_6 = '6',
+ ATCI_CHAR_7 = '7',
+ ATCI_CHAR_8 = '8',
+ ATCI_CHAR_9 = '9',
+ ATCI_CHAR_A = 'A',
+ ATCI_CHAR_B = 'B',
+ ATCI_CHAR_C = 'C',
+ ATCI_CHAR_D = 'D',
+ ATCI_CHAR_E = 'E',
+ ATCI_CHAR_F = 'F',
+ ATCI_CHAR_G = 'G',
+ ATCI_CHAR_H = 'H',
+ ATCI_CHAR_I = 'I',
+ ATCI_CHAR_J = 'J',
+ ATCI_CHAR_K = 'K',
+ ATCI_CHAR_L = 'L',
+ ATCI_CHAR_M = 'M',
+ ATCI_CHAR_N = 'N',
+ ATCI_CHAR_O = 'O',
+ ATCI_CHAR_P = 'P',
+ ATCI_CHAR_Q = 'Q',
+ ATCI_CHAR_R = 'R',
+ ATCI_CHAR_S = 'S',
+ ATCI_CHAR_T = 'T',
+ ATCI_CHAR_U = 'U',
+ ATCI_CHAR_V = 'V',
+ ATCI_CHAR_W = 'W',
+ ATCI_CHAR_X = 'X',
+ ATCI_CHAR_Y = 'Y',
+ ATCI_CHAR_Z = 'Z',
+ ATCI_CHAR_a = 'a',
+ ATCI_CHAR_b = 'b',
+ ATCI_CHAR_c = 'c',
+ ATCI_CHAR_d = 'd',
+ ATCI_CHAR_e = 'e',
+ ATCI_CHAR_f = 'f',
+ ATCI_CHAR_g = 'g',
+ ATCI_CHAR_h = 'h',
+ ATCI_CHAR_i = 'i',
+ ATCI_CHAR_j = 'j',
+ ATCI_CHAR_k = 'k',
+ ATCI_CHAR_l = 'l',
+ ATCI_CHAR_m = 'm',
+ ATCI_CHAR_n = 'n',
+ ATCI_CHAR_o = 'o',
+ ATCI_CHAR_p = 'p',
+ ATCI_CHAR_q = 'q',
+ ATCI_CHAR_r = 'r',
+ ATCI_CHAR_s = 's',
+ ATCI_CHAR_t = 't',
+ ATCI_CHAR_u = 'u',
+ ATCI_CHAR_v = 'v',
+ ATCI_CHAR_w = 'w',
+ ATCI_CHAR_x = 'x',
+ ATCI_CHAR_y = 'y',
+ ATCI_CHAR_z = 'z',
+} atci_char_enum;
+
+typedef enum {
+ AT_WRONG_MODE, AT_SET_MODE, //Ex: at+eample=xxx
+ AT_READ_MODE, //Ex: at+eample?
+ AT_TEST_MODE, //Ex: at+eample=?
+ AT_ACTIVE_MODE //Ex: at+eample
+} atci_cmd_mode_e;
+
+#define ATCI_LOWER_TO_UPPER(alpha_char) (((alpha_char >= ATCI_CHAR_a)&&(alpha_char <= ATCI_CHAR_z)) ? (alpha_char-32): (alpha_char))
+#define ATCI_UPPER_TO_LOWER(alpha_char) (((alpha_char >= ATCI_CHAR_A)&&(alpha_char <= ATCI_CHAR_Z)) ? (alpha_char+32): (alpha_char))
+#define ATCI_IS_CAHR(input ,alpha_char) ((alpha_char == input)? 1 : 0)
+
+char* atci_get_cmd_prefix(char *line);
+int atci_get_cmd_mode(char *line);
+int atci_at_skip_space(char **p_cur);
+int atci_at_hasmore(char **p_cur);
+int atci_at_to_equal(char **p_cur);
+int atci_at_to_colon(char **p_cur);
+int atci_at_skip_next_comma(char **p_cur);
+int atci_at_get_nextint_base(char **p_cur, int *p_out, int base, int uns);
+int atci_at_get_nextint(char **p_cur, int *p_out);
+int atci_at_get_nexthexint(char **p_cur, int *p_out);
+int atci_at_get_next_key(char **p_cur, char **p_out);
+#endif
diff --git a/src/lynq/lib/liblynq-at-common/include/libat_common/lynq_at_common.h b/src/lynq/lib/liblynq-at-common/include/libat_common/lynq_at_common.h
new file mode 100755
index 0000000..6f68e04
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-common/include/libat_common/lynq_at_common.h
@@ -0,0 +1,23 @@
+/*=============================================================================
+# FileName: lynq_at_factory.h
+# Desc: about at of factory
+# Author: lei
+# Version: V1.0
+# LastChange: 2022-12-14
+# History:
+ copyright:Mobiletek
+=============================================================================*/
+#ifndef LYNQ_AT_COMMON_H
+#define LYNQ_AT_COMMON_H 1
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void ( *lynq_atsvc_incb )( const char *input,const int length);
+typedef void ( *lynq_atsvc_outcb )(char *output, int out_max_size, int mode);
+lynq_atsvc_incb lynq_register_at_common(lynq_atsvc_outcb out_cb);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
\ No newline at end of file
diff --git a/src/lynq/lib/liblynq-at-common/lynq_at_common.cpp b/src/lynq/lib/liblynq-at-common/lynq_at_common.cpp
new file mode 100755
index 0000000..ce8476a
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-common/lynq_at_common.cpp
@@ -0,0 +1,402 @@
+
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <log/log.h>
+#include "include/libat_common/lynq_at_common.h"
+#include "atci_at_util.h"
+
+#undef LOG_TAG
+#define LOG_TAG "AT_COMMON"
+
+int g_mnetcall_mode = 0;
+int g_gtarndis_mode = 0;
+int g_version_mode = 0;
+
+lynq_atsvc_outcb handle_output;
+
+typedef struct
+{
+ char *cmd;
+ void (*func)(char *input,int mode);
+}Command;
+
+enum
+{
+ Response = 0,
+ Urc
+};
+
+void lynq_response_ok()
+{
+ char *str = "\r\nOK\r\n";
+ handle_output(str, strlen(str), Response);
+}
+
+void lynq_response_error()
+{
+ char *str = "\r\n+CME ERROR:100\r\n";
+ handle_output(str, strlen(str), Response);
+}
+
+static void lynq_get_poepn_buf(char *cmd)
+{
+ FILE *fp;
+ char buf[128] = {0};
+ fp = popen(cmd,"r");
+ while(fgets(buf, sizeof(buf), fp) != NULL){}
+ pclose(fp);
+ RLOGD("buf is %s size %d\n", buf, sizeof(buf));
+ handle_output(buf, strlen(buf), Response);
+ return;
+}
+
+void lynq_handle_rndis(char *input,int type)
+{
+ RLOGD("lynq_handle_rndis type %d\n", type);
+ char buf[128] = {0};
+ if(type == AT_SET_MODE)//set
+ {
+ int mode;
+ if (SYS_FAIL == atci_at_to_equal(&input))
+ {
+ lynq_response_error();
+ return SYS_FAIL;
+ }
+ if (SYS_FAIL == atci_at_get_nexthexint(&input, &mode))
+ {
+ lynq_response_error();
+ return SYS_FAIL;
+ }
+ if(mode == 1)
+ {
+ g_mnetcall_mode = mode;
+ system("connmanctl enable gadget");
+ system("connmanctl tether gadget on");
+ lynq_response_ok();
+ }
+ else if (mode == 0)
+ {
+ g_mnetcall_mode = mode;
+ system("connmanctl disable gadget");
+ lynq_response_ok();
+ }
+ else
+ {
+ lynq_response_error();
+ }
+ }
+ else if(type == AT_TEST_MODE)//list
+ {
+ sprintf(buf,"+MNETCALL:(0-1)");
+ handle_output(buf, strlen(buf), Response);
+ lynq_response_ok();
+ }
+ else if(type == AT_READ_MODE)//get
+ {
+ sprintf(buf,"+MNETCALL:%d", g_mnetcall_mode);
+ handle_output(buf, strlen(buf), Response);
+ lynq_response_ok();
+ }
+ else
+ {
+ lynq_response_error();
+ }
+ return;
+}
+
+void lynq_handle_rndis_configure(char *input,int type)
+{
+ RLOGD("lynq_handle_rndis_configure type %d\n", type);
+ char buf[128] = {0};
+ if(type == AT_SET_MODE)//set
+ {
+ int mode;
+ if (SYS_FAIL == atci_at_to_equal(&input))
+ {
+ lynq_response_error();
+ return SYS_FAIL;
+ }
+ if (SYS_FAIL == atci_at_get_nexthexint(&input, &mode))
+ {
+ lynq_response_error();
+ return SYS_FAIL;
+ }
+ if(mode == 1)
+ {
+ g_gtarndis_mode = mode;
+ system("uci set lynq_uci.rndis=lynq_rndis");
+ system("uci set lynq_uci.rndis.status='1'");
+ system("uci commit");
+ lynq_response_ok();
+ }
+ else if (mode == 0)
+ {
+ g_gtarndis_mode = mode;
+ system("uci set lynq_uci.rndis=lynq_rndis");
+ system("uci set lynq_uci.rndis.status='0'");
+ system("uci commit");
+ lynq_response_ok();
+ }
+ else
+ {
+ lynq_response_error();
+ }
+ }
+ else if(type == AT_TEST_MODE)//list
+ {
+ sprintf(buf,"+GTARNDIS:(0-1)");
+ handle_output(buf, strlen(buf), Response);
+ lynq_response_ok();
+ }
+ else if(type == AT_READ_MODE)//get
+ {
+ sprintf(buf,"+GTARNDIS:%d", g_gtarndis_mode);
+ handle_output(buf, strlen(buf), Response);
+ lynq_response_ok();
+ }
+ else
+ {
+ lynq_response_error();
+ }
+ return;
+}
+
+void lynq_handle_version(char *input,int type)
+{
+ RLOGD("lynq_handle_version type %d\n", type);
+ char buf[128] = {0};
+ if(type == AT_SET_MODE)//set
+ {
+ int mode;
+ if (SYS_FAIL == atci_at_to_equal(&input))
+ {
+ lynq_response_error();
+ return SYS_FAIL;
+ }
+ if (SYS_FAIL == atci_at_get_nexthexint(&input, &mode))
+ {
+ lynq_response_error();
+ return SYS_FAIL;
+ }
+ if(mode == 1)
+ {
+ g_version_mode = mode;
+ lynq_get_poepn_buf("uci get lynq_uci_ro.lynq_version.LYNQ_SW_INSIDE_VERSION");
+ //handle_output(buf, strlen(buf), Response);
+ lynq_response_ok();
+ }
+ else if (mode == 0)
+ {
+ g_version_mode = mode;
+ lynq_get_poepn_buf("uci get lynq_uci_ro.lynq_version.LYNQ_SW_VERSION");
+ //handle_output(buf, strlen(buf), Response);
+ lynq_response_ok();
+ }
+ else
+ {
+ lynq_response_error();
+ }
+ }
+ else if(type == AT_TEST_MODE)//list
+ {
+ sprintf(buf,"+CGIR:(0-1)");
+ handle_output(buf, strlen(buf), Response);
+ lynq_response_ok();
+ }
+ else if(type == AT_READ_MODE)//get
+ {
+ sprintf(buf,"+CGIR:%d", g_version_mode);
+ handle_output(buf, strlen(buf), Response);
+ lynq_response_ok();
+ }
+ else if(type == AT_ACTIVE_MODE)//active
+ {
+ if(g_version_mode == 0)
+ {
+ lynq_get_poepn_buf("uci get lynq_uci_ro.lynq_version.LYNQ_SW_VERSION");
+ //handle_output(buf, strlen(buf), Response);
+ lynq_response_ok();
+ }
+ else if(g_version_mode == 1)
+ {
+ lynq_get_poepn_buf("uci get lynq_uci_ro.lynq_version.LYNQ_SW_INSIDE_VERSION");
+ //handle_output(buf, strlen(buf), Response);
+ lynq_response_ok();
+ }
+ }
+ return;
+}
+
+void lynq_display_modem_mode(const char *cmd)
+{
+ FILE *fp;
+ char buf[128] = {0};
+ fp = popen(cmd,"r");
+ while(fgets(buf, sizeof(buf), fp) != NULL){}
+ pclose(fp);
+ RLOGD("buf is %s size %d\n", buf, sizeof(buf));
+ char tmp[16] = {0};
+ sprintf(tmp, "+LGMDS: %c", buf[4]);
+ handle_output(tmp, strlen(tmp), Response);
+ return;
+}
+
+void lynq_handle_modem_status(char *input,int type)
+{
+ RLOGD("lynq_handle_modem_status type %d\n", type);
+ if(type == AT_ACTIVE_MODE)//active
+ {
+ lynq_display_modem_mode("cat /sys/kernel/ccci/boot");
+ lynq_response_ok();
+ }
+ return;
+}
+
+void lynq_tmp_handle_rndis(char *input,int type)
+{
+ RLOGD("lynq_tmp_handle_rndis type %d\n", type);
+ char *connman_cmd1 = NULL;
+ char *connman_cmd2 = NULL;
+ if(type == AT_SET_MODE)//set
+ {
+ if (SYS_FAIL == atci_at_to_equal(&input))
+ {
+ lynq_response_error();
+ return ;
+ }
+ if (SYS_FAIL == atci_at_get_next_key(&input, &connman_cmd1))
+ {
+ lynq_response_error();
+ return ;
+ }
+ if (SYS_FAIL == atci_at_get_next_key(&input, &connman_cmd2))
+ {
+ //lynq_response_error();
+ //return SYS_FAIL;
+ }
+ if((connman_cmd1 != NULL) && (connman_cmd2 != NULL))
+ {
+ if(!strcmp(connman_cmd1, "connmanctl enable gadget"))
+ {
+ system("connmanctl enable gadget");
+ }
+ else
+ {
+ lynq_response_error();
+ return;
+ }
+ if(!strcmp(connman_cmd2, "connmanctl tether gadget on"))
+ {
+ system("connmanctl tether gadget on");
+ }
+ else
+ {
+ lynq_response_error();
+ return;
+ }
+ lynq_response_ok();
+ }
+ if(connman_cmd2 == NULL)
+ {
+ if(!strcmp(connman_cmd1, "connmanctl disable gadget"))
+ {
+ system("connmanctl disable gadget");
+ }
+ else
+ {
+ lynq_response_error();
+ return;
+ }
+ lynq_response_ok();
+ }
+ }
+ // else if(type == AT_TEST_MODE)//list
+ // {
+ // sprintf(buf,"+MNETCALL:(0-1)");
+ // handle_output(buf, strlen(buf), Response);
+ // lynq_response_ok();
+ // }
+ // else if(type == AT_READ_MODE)//get
+ // {
+ // sprintf(buf,"+MNETCALL:%d", g_mnetcall_mode);
+ // handle_output(buf, strlen(buf), Response);
+ // lynq_response_ok();
+ // }
+ else
+ {
+ lynq_response_error();
+ }
+ return;
+}
+
+static Command commands[] =
+{
+{"at+mnetcall",lynq_handle_rndis},
+{"at+gtarndis",lynq_handle_rndis_configure},
+{"at+cgir",lynq_handle_version},
+{"at+lgmds",lynq_handle_modem_status},
+{"at+lrndishandle",lynq_tmp_handle_rndis},//tmp plan
+{NULL, NULL}
+};
+
+Command* find_command (char *input)
+{
+ RLOGD("function %s line %d input %s\n", __FUNCTION__, __LINE__, input);
+ int i;
+ int ret = -1;
+ for (i = 0; commands[i].cmd; i++)
+ {
+ ret = strcmp(input, commands[i].cmd);
+ if(ret == 0)
+ {
+ RLOGD("function %s line %d find input %s commands[i].cmd %s strlen %d ret %d\n", __FUNCTION__, __LINE__, input, commands[i].cmd, strlen(commands[i].cmd), ret);
+ return (&commands[i]);
+ }
+ }
+ RLOGD("function %s line %d not find ret %d \n", __FUNCTION__, __LINE__, ret);
+ return ((Command *)NULL);
+}
+
+void lynq_at_common_cb(char *input, int input_max_size)
+{
+ if(handle_output != NULL)
+ {
+ RLOGD("function %s line %d input %s\n", __FUNCTION__, __LINE__, input);
+ if(input != NULL)
+ {
+ char *prefix = NULL;
+ prefix = atci_get_cmd_prefix(input);
+ if (NULL == prefix) {
+ RLOGD("atci_cut_cmd_prefix error");
+ return;
+ }
+ RLOGD("find prefix [%s]", prefix);
+ Command *cmd = find_command(prefix);
+ if(cmd != NULL)
+ {
+ int cmd_mode = atci_get_cmd_mode(input);
+ RLOGD("function %s line %d\n", __FUNCTION__, __LINE__);
+ (*(cmd->func))(input,cmd_mode);
+ free(prefix);
+ return;
+ }
+ else
+ {
+ RLOGD("not find prefix in list");
+ }
+ free(prefix);
+ }
+ }
+}
+
+lynq_atsvc_incb lynq_register_at_common(lynq_atsvc_outcb out_cb)
+{
+ if(out_cb != NULL)
+ {
+ handle_output = out_cb;
+ RLOGD("function %s line %d\n", __FUNCTION__, __LINE__);
+ return lynq_at_common_cb;
+ }
+}
diff --git a/src/lynq/lib/liblynq-at-common/makefile b/src/lynq/lib/liblynq-at-common/makefile
new file mode 100755
index 0000000..3f9f757
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-common/makefile
@@ -0,0 +1,72 @@
+
+SHELL = /bin/sh
+RM = rm -f
+
+LOCAL_CFLAGS := -Wall \
+ -std=gnu++14 \
+ -g -Os \
+ -flto \
+ -DRIL_SHLIB \
+ -DATCI_PARSE \
+ -fPIC \
+ -DKEEP_ALIVE \
+ -DECALL_SUPPORT \
+ -fpermissive \
+
+$(warning ################# lynq at factory demo ROOT: $(ROOT),includedir:$(includedir))
+LOCAL_PATH = .
+
+LOCAL_C_INCLUDES = \
+ -I. \
+ -I$(LOCAL_PATH)/include/libat \
+ -I$(ROOT)$(includedir)/logger \
+ -I$(ROOT)$(includedir)/liblog \
+ -I$(ROOT)$(includedir)/vendor-ril \
+
+
+LOCAL_LIBS := \
+ -L. \
+ -ldl \
+ -lstdc++ \
+ -llog \
+ -lcutils \
+ -lutils \
+ -lbinder \
+ -lpthread \
+
+
+SOURCES = $(wildcard *.cpp)
+
+EXECUTABLE = liblynq-at-common.so
+
+OBJECTS=$(SOURCES:.cpp=.o)
+
+.PHONY: build clean install pack_rootfs
+
+all: build
+$(EXECUTABLE): $(OBJECTS)
+ $(CXX) -shared -Wl,--no-undefined $(OBJECTS) $(LOCAL_LIBS) $(LOCAL_CFLAGS) $(LOCAL_C_INCLUDES) -o $@
+
+%.o : %.cpp
+ $(CXX) $(LOCAL_C_INCLUDES) $(LOCAL_CFLAGS) $(LOCAL_LIBS) -o $@ -c $<
+
+build: $(EXECUTABLE)
+ $(warning ########## build $(EXECUTABLE) ##########)
+
+install:
+ mkdir -p $(ROOT)$(base_libdir)/
+ install $(EXECUTABLE) $(ROOT)$(base_libdir)/
+ mkdir -p $(ROOT)$(includedir)/$(NAME)/sdk
+
+pack_rootfs:
+ mkdir -p $(PACK_INITRAMFS_TO)$(base_libdir)/
+ cp -af $(EXECUTABLE) $(PACK_INITRAMFS_TO)$(base_libdir)/
+ $(CROSS)strip $(PACK_INITRAMFS_TO)$(base_libdir)/$(EXECUTABLE)
+ mkdir -p $(PACK_TO)$(base_libdir)/
+ cp -af $(EXECUTABLE) $(PACK_TO)$(base_libdir)/
+ $(CROSS)strip $(PACK_TO)$(base_libdir)/$(EXECUTABLE)
+
+.PHONY: clean
+clean:
+ $(RM) $(OBJECTS) $(EXECUTABLE)
+ -find . -name "*.o" -delete
diff --git a/src/lynq/lib/liblynq-at-extension/include/lib_at/lynq_at.h b/src/lynq/lib/liblynq-at-extension/include/lib_at/lynq_at.h
index 1a17fe9..0049eb1 100755
--- a/src/lynq/lib/liblynq-at-extension/include/lib_at/lynq_at.h
+++ b/src/lynq/lib/liblynq-at-extension/include/lib_at/lynq_at.h
@@ -10,9 +10,9 @@
#ifndef __LYNQ_AT__
#define __LYNQ_AT__
-#ifdef __cplusplus
-extern "C" {
-#endif
+//#ifdef __cplusplus
+//extern "C" {
+//#endif
/**
* @brief
@@ -31,8 +31,8 @@
*/
int lynq_reg_third_at(const char *ext_at, LYNQ_AT_CALLBACK callback);
-#ifdef __cplusplus
-}
-#endif
+//#ifdef __cplusplus
+//}
+//#endif
#endif
\ No newline at end of file
diff --git a/src/lynq/lib/liblynq-at-extension/lynq_at.cpp b/src/lynq/lib/liblynq-at-extension/lynq_at.cpp
index a7c6b2e..8785310 100755
--- a/src/lynq/lib/liblynq-at-extension/lynq_at.cpp
+++ b/src/lynq/lib/liblynq-at-extension/lynq_at.cpp
@@ -1,20 +1,25 @@
-#include<sys/types.h>
-#include<sys/socket.h>
-#include<unistd.h>
-#include<arpa/inet.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <log/log.h>
#include <pthread.h>
+#include <errno.h>
#include "liblog/lynq_deflog.h"
#include "include/lib_at/lynq_at.h"
#define LYNQ_AT_SERVICE_PORT 8087
#define OUT_MAX_SIZE 1024
#define USER_LOG_TAG "LYNQ_AT"
-
+#define AT_EXTERSION_SOCKET_NAME "/dev/socket/lynq_atsvc_socket_1"
+#define LINE __LINE__
+#define FUNC __FUNCTION__
+static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER;
typedef enum
{
A_SUCCESS = 0,
@@ -28,8 +33,15 @@
char *output = NULL;
char buffer_at[OUT_MAX_SIZE] = {0};
struct sockaddr_in addr_serv;
+struct sockaddr_un addr_server;
+
+
socklen_t len;
LYNQ_AT_CALLBACK tmp = NULL;
+bool connect_state = false;
+#define SOCKET_ZERO 0
+#define SOCKET_SUCC 1
+#define SOCKET_FAIL -1
/**
* @brief Catch exceptions and free malloc's memory
@@ -66,6 +78,84 @@
}
}
+
+int socket_local_client (char* name) {
+ //struct sockaddr_un server;
+ //int fd = 0;
+ LYINFLOG("[%d][%s] enter",LINE,FUNC);
+ sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (sockfd < 0)
+ {
+ LYDBGLOG("Can't open stream socket (%s)", name);
+ return -1;
+ }
+ addr_server.sun_family = AF_UNIX;
+ memset(addr_server.sun_path, '\0', sizeof(addr_server.sun_path));
+ strncpy(addr_server.sun_path, name, sizeof(addr_server.sun_path) - 1);
+ if (connect(sockfd, (struct sockaddr *) &addr_server, sizeof(struct sockaddr_un)) < 0)
+ {
+ close(sockfd);
+ LYDBGLOG("Can't connect to server side, path: %s, errno:%d", name, errno);
+ return -1;
+ }
+ LYINFLOG("[%d][%s] connect %s success",LINE,FUNC,name);
+ return sockfd;
+}
+bool send_msg_to_service(int fd,char *msg,int size)
+{
+ LYDBGLOG("[%d][%s] enter",LINE,FUNC);
+ if (fd < 0)
+ {
+ LYDBGLOG("fd invalid when send to atci service. errno = %d", errno);
+ return false;
+ }
+ if(NULL == msg)
+ {
+ LYDBGLOG("atcmd is null.");
+ return false;
+ }
+ int sendLen = send(fd, msg, size, 0);
+ if (sendLen != size)
+ {
+ LYDBGLOG("lose data when send to atci service. errno = %d", errno);
+ return false;
+ }
+ LYDBGLOG("send to app demo: %s", msg);
+ return true;
+}
+
+int atsvc_cmd_recv(int fd, char *buf, int len)
+{
+ int ret = 0;
+ fd_set rfds;
+ //FD_CLR(fd, &rfds);
+ FD_SET(fd, &rfds);
+ ret = select(fd + 1, &rfds, NULL, NULL, NULL);
+ if (ret <= 0)
+ {
+ LYDBGLOG("acti_cmd_recv select error, ret=%d, error=%s(%d),fd=%d", ret,strerror(errno), errno, fd);
+ return SOCKET_FAIL;
+ }
+ if (FD_ISSET(fd, &rfds))
+ {
+ ret = recv(fd, buf, len, 0);
+ if (ret < 0)
+ {
+ LYDBGLOG("acti_cmd_recv select error, ret=%d, error=%s(%d),fd=%d", ret,strerror(errno), errno, fd);
+ return SOCKET_FAIL;
+ }
+ else if(ret == 0)
+ {
+ LYDBGLOG("acti_cmd_recv recv error, ret=%d, error=%s(%d),fd=%d", ret,strerror(errno), errno, fd);
+ return SOCKET_ZERO;
+ }
+ else
+ {
+ //buf[ret] = '\0';
+ }
+ }
+ return SOCKET_SUCC;
+}
/**
* @brief send third cmd to service and receive input,then send output to service
*
@@ -74,53 +164,73 @@
*/
void *thread_recv(void *parm)
{
- signal(SIGPIPE, signal_handler);
- signal(SIGABRT, signal_handler);
- signal(SIGBUS, signal_handler);
- signal(SIGFPE, signal_handler);
- signal(SIGILL, signal_handler);
- signal(SIGSEGV, signal_handler);
+ //signal(SIGPIPE, signal_handler);
+ //signal(SIGABRT, signal_handler);
+ //signal(SIGBUS, signal_handler);
+ //signal(SIGFPE, signal_handler);
+ //signal(SIGILL, signal_handler);
+ //signal(SIGSEGV, signal_handler);
+ LYINFLOG("[%d][%s] enter",LINE,FUNC);
int recv = 0;
int send = 0;
char at_cmd[100] = {0};
- sockfd=socket(AF_INET,SOCK_DGRAM,0);
- memset(&addr_serv, 0, sizeof(addr_serv));
- addr_serv.sin_family =AF_INET;
- addr_serv.sin_port =htons(LYNQ_AT_SERVICE_PORT);
- addr_serv.sin_addr.s_addr = htonl(INADDR_ANY);
- len=sizeof(addr_serv);
- int len_buf = strlen(buffer_at);
- send = sendto(sockfd, buffer_at, len_buf,0,(struct sockaddr*)&addr_serv,len);
- if(send < 0)
+ int fd = -1;
+ int ret = 0;
+ fd = socket_local_client(AT_EXTERSION_SOCKET_NAME);
+ if(fd <= 0)
{
- LYDBGLOG("thread_recv send fail\n");
- result = send;
+ connect_state = false;
+ pthread_mutex_unlock(&s_startupMutex);
return NULL;
}
+ int len_buf = strlen(buffer_at);
+ if(!send_msg_to_service(fd,buffer_at,len_buf))
+ {
+ connect_state = false;
+ pthread_mutex_unlock(&s_startupMutex);
+ return NULL;
+ }
+ connect_state = true;
+ pthread_mutex_unlock(&s_startupMutex);
char *input = NULL;
output = (char *)malloc(sizeof(char)*OUT_MAX_SIZE);
if(NULL == output)
{
LYDBGLOG("thread_recv malloc fail\n");
- result = A_ERROR;
return NULL;
}
+ TryNewLink:
+ if(connect_state == false)
+ {
+ if (connect(fd, (struct sockaddr *) &addr_server, sizeof(struct sockaddr_un)) < 0)
+ {
+ close(fd);
+ LYDBGLOG("Can't connect to server side, path: %s, errno:%d", AT_EXTERSION_SOCKET_NAME, errno);
+ return NULL;
+ }
+ connect_state = true;
+ }
while (1)
{
/*receive at cmd*/
- LYDBGLOG("lynq_reg_third_at receive at cmd\n");
- recv = recvfrom(sockfd,at_cmd,sizeof(at_cmd),0,(struct sockaddr*)&addr_serv,&len);
- if(recv < 0)
+ memset(at_cmd, 0, sizeof(at_cmd));
+ ret = atsvc_cmd_recv(fd, at_cmd,sizeof(at_cmd));
+ if (ret < 0)
{
- LYDBGLOG("thread_recv recv fail\n");
+ LYDBGLOG("[%d][%s]receive CMD error",LINE,FUNC);
continue;
}
+ else if(ret == SOCKET_ZERO)
+ {
+ ALOGE("maybe client socket closed 1. retry new link!");
+ connect_state = false;
+ goto TryNewLink;
+ }
input = at_cmd;
//begin deal with callback
tmp(input, output, OUT_MAX_SIZE);
LYDBGLOG("lynq_reg_third_at send output to service\n");
- send = sendto(sockfd, output, strlen(output),0,(struct sockaddr*)&addr_serv,len);
- if(send < 0)
+ if(!send_msg_to_service(fd,output, strlen(output)))
{
LYDBGLOG("thread_recv send fail\n");
continue;
@@ -128,9 +238,9 @@
}
free(output);
output = NULL;
- if(sockfd != 0)
+ if(fd != 0)
{
- close(sockfd);
+ close(fd);
}
return NULL;
}
@@ -142,11 +252,15 @@
*/
int lynq_connect_service_start(void)
{
+ LYINFLOG("[%d][%s] enter",LINE,FUNC);
pthread_t lynq_at_tid = -1;
int rt = pthread_create(&lynq_at_tid, NULL, thread_recv, NULL);
- if(rt < 0)
+ pthread_mutex_lock(&s_startupMutex);
+ LYINFLOG("[%d][%s] pthread mutex unlock",LINE,FUNC);
+ LYINFLOG(",rt:%d,connect state:%d\n",rt,connect_state);
+ if((connect_state != true) && rt < 0)
{
- LYERRLOG("urc loop failure!!!\n");
+ LYERRLOG("connect fail,rt:%d,connect state:%d\n",rt,connect_state);
return -1;
}
return 0;
@@ -166,15 +280,17 @@
}
memcpy(buffer_at, ext_at, strlen(ext_at));
tmp = callback;
- LYLOGSET(LOG_INFO);
+ LYLOGSET(LOG_DEBUG);
LYLOGEINIT(USER_LOG_TAG);
LYDBGLOG("lynq_reg_third_at start\n");
int ret = lynq_connect_service_start();
+
if(ret != 0)
{
LYDBGLOG("lynq_connect_service_start start failed\n");
return A_ERROR;
}
- return result;
+ LYDBGLOG("lynq_connect_service_start success ret:%d\n",ret);
+ return A_SUCCESS;
}
diff --git a/src/lynq/lib/liblynq-at-extension/makefile b/src/lynq/lib/liblynq-at-extension/makefile
index 0a6c2d3..257de29 100755
--- a/src/lynq/lib/liblynq-at-extension/makefile
+++ b/src/lynq/lib/liblynq-at-extension/makefile
@@ -6,10 +6,7 @@
-g -Os \
-flto \
-DRIL_SHLIB \
- -DATCI_PARSE \
-fPIC \
- -DKEEP_ALIVE \
- -DECALL_SUPPORT \
-fpermissive \
@@ -19,6 +16,7 @@
LOCAL_C_INCLUDES = \
-I. \
+ -I$(ROOT)/usr/include/binder \
-I$(LOCAL_PATH)/include/lib_at \
-I$(ROOT)$(includedir)/logger \
-I$(ROOT)$(includedir)/liblog \
@@ -31,6 +29,7 @@
-llog \
-lpthread \
-llynq-log \
+ -lbinder \
SOURCES = $(wildcard *.cpp)
diff --git a/src/lynq/lib/liblynq-at-factory/LICENSE b/src/lynq/lib/liblynq-at-factory/LICENSE
new file mode 100755
index 0000000..382fc78
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-factory/LICENSE
@@ -0,0 +1,31 @@
+Copyright Statement:
+
+This software/firmware and related documentation ("Mobiletek Software") are
+protected under relevant copyright laws. The information contained herein is
+confidential and proprietary to Mobiletek Inc. and/or its licensors. Without
+the prior written permission of Mobiletek inc. and/or its licensors, any
+reproduction, modification, use or disclosure of Mobiletek Software, and
+information contained herein, in whole or in part, shall be strictly
+prohibited.
+
+Mobiletek Inc. (C) 2015. All rights reserved.
+
+BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
+THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("Mobiletek SOFTWARE")
+RECEIVED FROM Mobiletek AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
+ON AN "AS-IS" BASIS ONLY. Mobiletek EXPRESSLY DISCLAIMS ANY AND ALL
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+NONINFRINGEMENT. NEITHER DOES Mobiletek PROVIDE ANY WARRANTY WHATSOEVER WITH
+RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
+INCORPORATED IN, OR SUPPLIED WITH THE Mobiletek SOFTWARE, AND RECEIVER AGREES
+TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
+RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
+OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN Mobiletek
+SOFTWARE. Mobiletek SHALL ALSO NOT BE RESPONSIBLE FOR ANY Mobiletek SOFTWARE
+RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
+STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND Mobiletek'S
+ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE Mobiletek SOFTWARE
+RELEASED HEREUNDER WILL BE, AT Mobiletek'S OPTION, TO REVISE OR REPLACE THE
+Mobiletek SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
+CHARGE PAID BY RECEIVER TO Mobiletek FOR SUCH Mobiletek SOFTWARE AT ISSUE.
\ No newline at end of file
diff --git a/src/lynq/lib/liblynq-at-factory/include/libat/lynq_at_factory.h b/src/lynq/lib/liblynq-at-factory/include/libat/lynq_at_factory.h
new file mode 100755
index 0000000..b90270c
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-factory/include/libat/lynq_at_factory.h
@@ -0,0 +1,23 @@
+/*=============================================================================
+# FileName: lynq_at_factory.h
+# Desc: about at of factory
+# Author: lei
+# Version: V1.0
+# LastChange: 2022-12-14
+# History:
+ copyright:Mobiletek
+=============================================================================*/
+#ifndef LYNQ_AT_FACTORY_H
+#define LYNQ_AT_FACTORY_H 1
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void ( *lynq_atsvc_incb )( const char *input,const int length);
+typedef void ( *lynq_atsvc_outcb )(char *output, int out_max_size, int mode);
+lynq_atsvc_incb lynq_register_at_factory(lynq_atsvc_outcb out_cb);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
\ No newline at end of file
diff --git a/src/lynq/lib/liblynq-at-factory/lynq_at_factory.cpp b/src/lynq/lib/liblynq-at-factory/lynq_at_factory.cpp
new file mode 100755
index 0000000..3f1bfa9
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-factory/lynq_at_factory.cpp
@@ -0,0 +1,489 @@
+
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <log/log.h>
+#include <liblog/lynq_deflog.h>
+#include "include/libat/lynq_at_factory.h"
+
+#define FACTORY_STRING "AT+LYNQFACTORY="
+#define USER_LOG_TAG "AT_FACTORY"
+
+#undef LOG_TAG
+#define LOG_TAG "AT_FACTORY"
+
+static const char *usb3_speed = "super-speed";
+static const char *usb2_speed = "high-speed";
+
+lynq_atsvc_outcb handle_output;
+
+typedef struct
+{
+ char *cmd;
+ void (*func)(char *input);
+}Command;
+
+enum
+{
+ Response = 0,
+ Urc
+};
+
+void lynq_handle_adc(char *input)
+{
+ FILE *fp;
+ char lynq_adc_dev[126] = {0};
+ char lynq_adc_buf[32] = {0};
+ int lynq_adc_num = atoi(input+4);
+ char flag[64] = {0};
+ if(lynq_adc_num == 0)
+ {
+ sprintf(lynq_adc_dev,"cat /sys/bus/iio/devices/iio:device1/in_voltage0_input 2>&1");
+ }
+ else if(lynq_adc_num == 1)
+ {
+ sprintf(lynq_adc_dev,"cat /sys/bus/iio/devices/iio:device1/in_voltage1_input 2>&1");
+ }
+ else if(lynq_adc_num == 2)
+ {
+ sprintf(lynq_adc_dev,"cat /sys/bus/iio/devices/iio:device1/in_voltage2_input 2>&1");
+ }
+ else if(lynq_adc_num == 3)
+ {
+ sprintf(lynq_adc_dev,"cat /sys/bus/iio/devices/iio:device1/in_voltage3_input 2>&1");
+ }
+ fp=popen(lynq_adc_dev, "r");
+ fgets(lynq_adc_buf,sizeof(lynq_adc_buf),fp);
+ sprintf(flag,"%s %s", "ADC:", lynq_adc_buf);
+ if(handle_output != NULL)
+ {
+ handle_output(flag, strlen(flag), Response);
+ }
+ pclose(fp);
+}
+
+void lynq_handle_sink(char *input)
+{
+ FILE *fp;
+ char lynq_usb_dev[512] = {0};
+ char lynq_usb_buf[512] = {0};
+ char buf[512] = {0};
+ int sink[3][3] = {{255,0,0},{0,255,0},{0,0,255}};
+ char dev_buf[][40]={{"green:cellular-radio/brightness"},{"green:cellular-quality/brightness"},{"red:system/brightness"}};
+ int i;
+ int j;
+ int k = 15;
+ char flag_buf[64] = {0};
+ for(i = 0;i < 3;i++){
+ bzero(flag_buf, 64);
+ bzero(lynq_usb_buf, 512);
+ bzero(buf, 512);
+ k = 15;
+ for(j = 0;j < 3;j++){
+ bzero(lynq_usb_dev, 512);
+ sprintf(lynq_usb_dev,"echo %d > /sys/class/leds/led95%d:%s 2>&1", sink[i][j], k++, dev_buf[j]);
+ fp=popen(lynq_usb_dev, "r");
+ }
+ usleep(10000);
+ sprintf(lynq_usb_buf,"cat /sys/bus/iio/devices/iio:device1/in_voltage4_input 2>&1");
+ fp=popen(lynq_usb_buf, "r");
+
+ fgets(buf, sizeof(buf), fp);
+ sprintf(flag_buf, "%s%d%s%s%s", "SINK[", i+1, "]: ", buf, "\n");
+ handle_output(flag_buf, strlen(flag_buf), Response);
+ }
+ pclose(fp);
+}
+
+void lynq_handle_emmc(char *input)
+{
+ FILE *fp;
+ char emmc_buf[100] = {0};
+ char buf[100] = {0};
+ sprintf(emmc_buf, "ls /dev | grep mmcblk0 2>&1");
+ fp=popen(emmc_buf, "r");
+ if(!fp){
+ char *str = "\n+CME: POPEN ERROR\n";
+ handle_output(str, strlen(str), Response);
+ return;
+ }
+ while(fgets(buf, sizeof(buf), fp) != NULL){
+ char *str = "+EMMC: OK \n";
+ handle_output(str, strlen(str), Response);
+ pclose(fp);
+ return;
+ }
+ char *str = "\033[47;31m+EMMC: ERROR\033[0m\n";
+ handle_output(str, strlen(str), Response);
+ pclose(fp);
+}
+
+void lynq_handle_gpio(char *input)
+{
+ FILE *fp;
+ int lynq_gpio_arr[85] = {230,231,232,233,234,102,104,103,101,186 ,188 ,187 ,185 ,194 ,196 ,195 ,193 ,205 ,204 ,203 ,202, 201 ,190 ,192 ,191 ,189 ,173 ,174 ,175 ,176 ,170 ,169 ,184 ,183 ,182 ,181 ,24 ,25 ,157 ,158 ,155 ,156 ,143 ,144 ,140 ,141 ,153 ,154 ,180 ,179 ,29 ,30 ,178, 177, 7 ,5 ,4 ,113 ,112, 116 ,115 ,114, 107, 108, 105, 106, 100 ,99 ,98, 97, 94, 93, 92, 91, 1 ,130 ,41 ,67 ,69, 68, 63, 22, 23, 199, 200};
+ char lynq_set_gpio_arr[256] = {0};
+ char lynq_get_gpio_state[512] = {0};
+ char lynq_show_gpio_state[64] = {0};
+ int lynq_gpio_low = 0;
+ int lynq_gpio_hig = 0;
+ int i = 0,m = 0;
+ int lynq_gpio_beta_state = 1;
+
+ for(m = 0; m < 85; m++)
+ {
+ bzero(lynq_set_gpio_arr, 256);
+ sprintf(lynq_set_gpio_arr,"echo mode %d 0 > /sys/devices/platform/10005000.pinctrl/mt_gpio",(char*)lynq_gpio_arr[m]);
+ system(lynq_set_gpio_arr);
+ bzero(lynq_set_gpio_arr, 256);
+ sprintf(lynq_set_gpio_arr,"echo out %d 0 > /sys/devices/platform/10005000.pinctrl/mt_gpio",(char*)lynq_gpio_arr[m]);
+ system(lynq_set_gpio_arr);
+ }
+
+ for(i = 0; i < 85; i++)
+ {
+ lynq_gpio_low = 0;
+ lynq_gpio_hig = 0;
+
+ bzero(lynq_set_gpio_arr, 256);
+ sprintf(lynq_set_gpio_arr,"echo mode %d 0 > /sys/devices/platform/10005000.pinctrl/mt_gpio",(char*)lynq_gpio_arr[i]);
+ system(lynq_set_gpio_arr);
+
+ bzero(lynq_set_gpio_arr, 256);
+ sprintf(lynq_set_gpio_arr,"echo out %d 1 > /sys/devices/platform/10005000.pinctrl/mt_gpio",(char*)lynq_gpio_arr[i]);
+ system(lynq_set_gpio_arr);
+
+ bzero(lynq_set_gpio_arr, 256);
+ sprintf(lynq_set_gpio_arr,"cat /sys/devices/platform/10005000.pinctrl/mt_gpio | grep 006");
+ fp=popen(lynq_set_gpio_arr, "r");
+ bzero(lynq_get_gpio_state, 512);
+ fgets(lynq_get_gpio_state,sizeof(lynq_get_gpio_state),fp);
+ pclose(fp);
+ if(lynq_get_gpio_state[7] == '1')
+ {
+ lynq_gpio_hig = 1;
+ }
+
+ bzero(lynq_set_gpio_arr, 256);
+ sprintf(lynq_set_gpio_arr,"echo out %d 0 > /sys/devices/platform/10005000.pinctrl/mt_gpio",(char*)lynq_gpio_arr[i]);
+ system(lynq_set_gpio_arr);
+
+ bzero(lynq_set_gpio_arr, 256);
+ sprintf(lynq_set_gpio_arr,"cat /sys/devices/platform/10005000.pinctrl/mt_gpio | grep 006");
+ fp=popen(lynq_set_gpio_arr, "r");
+ bzero(lynq_get_gpio_state, 512);
+ fgets(lynq_get_gpio_state,sizeof(lynq_get_gpio_state),fp);
+ pclose(fp);
+ if(lynq_get_gpio_state[7] == '0')
+ {
+ lynq_gpio_low = 1;
+ }
+ bzero(lynq_show_gpio_state, 64);
+ if((lynq_gpio_low != 1) || (lynq_gpio_hig != 1))
+ {
+ lynq_gpio_beta_state = 0;
+ sprintf(lynq_show_gpio_state,"[gpio%d][result]:FAIL \n",(char *)lynq_gpio_arr[i]);
+ handle_output(lynq_show_gpio_state, strlen(lynq_show_gpio_state), Response);
+ }
+ else
+ {
+ sprintf(lynq_show_gpio_state,"gpio%d\n",(char *)lynq_gpio_arr[i]);
+ handle_output(lynq_show_gpio_state, strlen(lynq_show_gpio_state), Response);
+ }
+ }
+ if(lynq_gpio_beta_state == 1)
+ {
+ sprintf(lynq_show_gpio_state,"[gpio][result]:PASS \n");
+ handle_output(lynq_show_gpio_state, strlen(lynq_show_gpio_state), Response);
+ }
+}
+
+void lynq_handle_pcie(char *input)
+{
+ FILE *fp;
+ char lynq_usb_dev[128] = {0};
+ char lynq_get_gpio_state[512] = {0};
+ sprintf(lynq_usb_dev,"cat sys/devices/platform/10005000.pinctrl/mt_gpio |grep 097 2>&1");
+ fp=popen(lynq_usb_dev, "r");
+ fgets(lynq_get_gpio_state,sizeof(lynq_get_gpio_state),fp);
+ pclose(fp);
+ if(lynq_get_gpio_state[6] == '1')
+ {
+ char *str = "+PCIE: OK\n";
+ handle_output(str, strlen(str), Response);
+ }
+ else
+ {
+ char *str = "+PCIE: ERROR\n";
+ handle_output(str, strlen(str), Response);
+ }
+}
+
+void lynq_handle_rgmii(char *input)
+{
+ char *ipv4 = input+6;
+ char cmd[128] = {0};
+ FILE *fp;
+ sprintf(cmd, "%s %s %s %s", "ping -I eth2", ipv4, "-c4", "2>&1");
+ fp=popen(cmd, "r");
+ if(NULL == fp){
+ char *str = "popen errorn\n";
+ handle_output(str, strlen(str), Response);
+ }
+ char lynq_factory_buf[1024] = {0};
+ while (NULL != fgets(lynq_factory_buf,sizeof(lynq_factory_buf),fp))
+ {
+ if(strstr(lynq_factory_buf, "Usage"))
+ {
+ char *str = "RGMII cannot recognize IP addresses\nERROR\n";
+ handle_output(str, strlen(str), Response);
+ pclose(fp);
+ }
+ handle_output(lynq_factory_buf, strlen(lynq_factory_buf), Response);
+ }
+ char *str = "OK\n";
+ handle_output(str, strlen(str), Response);
+ pclose(fp);
+}
+
+void lynq_handle_sgmii(char *input)
+{
+ char *ipv4 = input+6;
+ char cmd[128] = {0};
+ FILE *fp;
+ sprintf(cmd, "%s %s %s %s", "ping -I eth1", ipv4, "-c4", "2>&1");
+ fp=popen(cmd, "r");
+ if(NULL == fp){
+ char *str = "popen errorn\n";
+ handle_output(str, strlen(str), Response);
+ }
+ char lynq_factory_buf[1024] = {0};
+ while (NULL != fgets(lynq_factory_buf,sizeof(lynq_factory_buf),fp))
+ {
+ if(strstr(lynq_factory_buf, "Usage"))
+ {
+ char *str = "RGMII cannot recognize IP addresses\nERROR\n";
+ handle_output(str, strlen(str), Response);
+ pclose(fp);
+ }
+ handle_output(lynq_factory_buf, strlen(lynq_factory_buf), Response);
+ }
+ char *str = "OK\n";
+ handle_output(str, strlen(str), Response);
+ pclose(fp);
+}
+
+void lynq_handle_inside_version(char *input)
+{
+ FILE *fp;
+ char buf[64] = {0};
+ fp=popen("uci get lynq_uci_ro.lynq_version.LYNQ_SW_INSIDE_VERSION 2>&1", "r");
+ if(NULL == fp){
+ char *str = "popen errorn\n";
+ handle_output(str, strlen(str), Response);
+ }
+ fgets(buf, sizeof(buf), fp);
+ handle_output(buf, strlen(buf), Response);
+ char *str = "OK\n";
+ handle_output(str, strlen(str), Response);
+ pclose(fp);
+}
+
+void lynq_handle_usb(char *input)
+{
+ FILE *fp;
+ char lynq_usb_dev[512] = {0};
+ char lynq_usb_buf[512];
+ bzero(lynq_usb_buf, 512);
+ bzero(lynq_usb_dev,512);
+ sprintf(lynq_usb_dev,"cat /sys/devices/platform/11201000.usb/udc/11201000.usb/current_speed 2>&1");
+ fp=popen(lynq_usb_dev, "r");
+ fgets(lynq_usb_buf,sizeof(lynq_usb_buf),fp);
+ if(!strncmp(lynq_usb_buf,usb3_speed,strlen(usb3_speed)))
+ {
+ char *res = "[usb][result],3.0";
+ handle_output(res, strlen(res), Response);
+ char *str = "OK\n";
+ handle_output(str, strlen(str), Response);
+ }
+ else if(!strncmp(lynq_usb_buf,usb2_speed,strlen(usb2_speed)))
+ {
+ char *res = "[usb][result],2.0";
+ handle_output(res, strlen(res), Response);
+ char *str = "OK\n";
+ handle_output(str, strlen(str), Response);
+ }
+ pclose(fp);
+ return 1;
+}
+
+
+static Command commands[] =
+{
+{"adc",lynq_handle_adc},
+{"sink",lynq_handle_sink},
+{"emmc",lynq_handle_emmc},
+{"gpio",lynq_handle_gpio},
+{"pcie",lynq_handle_pcie},
+{"rgmii",lynq_handle_rgmii},
+{"sgmii",lynq_handle_sgmii},
+{"usb",lynq_handle_usb},
+{NULL, NULL}
+};
+
+Command* find_command (char *input)
+{
+ RLOGD("function %s line %d input %s\n", __FUNCTION__, __LINE__, input);
+ int i;
+ int ret = -1;
+ for (i = 0; commands[i].cmd; i++)
+ {
+ ret = strncmp(input, commands[i].cmd, strlen(commands[i].cmd));
+ if(ret == 0)
+ {
+ RLOGD("function %s line %d find input %s commands[i].cmd %s strlen %d ret %d\n", __FUNCTION__, __LINE__, input, commands[i].cmd, strlen(commands[i].cmd), ret);
+ return (&commands[i]);
+ }
+ }
+ RLOGD("function %s line %d not find ret %d \n", __FUNCTION__, __LINE__, ret);
+ return ((Command *)NULL);
+}
+
+/*
+int g_number(const char *p){
+ int cnt = 0;
+ while(*p != '\0'){
+ if(*p == ','){
+ cnt++;
+ }
+ *p++;
+ }
+ return cnt+4;//for count character string
+
+}
+
+void lynqSetArgv(char **argv, char** Point,const char* value)
+{
+ *argv=*Point;
+ sprintf(*argv, "%s", value);
+ (*Point) += (strlen(value)+1);
+}
+
+int lynqParseUsbCommand(const char* cmd,char *argv[],char test[],char* parser_buf,int maxArgc)
+{
+ char *token;
+ char *str = test;
+ char *string;
+ char *parameter;
+ char* Point=parser_buf;
+ int cnt = g_number(cmd);
+ memcpy(test, cmd, strlen(cmd));
+ test[strlen(cmd)] = '\0';
+ argv[1] = (char *)cmd;
+ if(strstr(cmd,"=?"))
+ {
+ token = strtok(str, "=?");
+ //argv[0] = token;
+ argv[0] = strstr(token, "+")+1;
+ lynqSetArgv(&(argv[2]),&Point,"1");
+ while (token != NULL)
+ {
+ string = token;
+ token = strtok(NULL, "=?");
+ }
+ parameter = strtok(string, ",");
+ int i = 3;
+ while (parameter != NULL)
+ {
+ argv[i++] = parameter;
+ parameter = strtok(NULL, ",");
+ }
+ }
+ else if(strstr(cmd,"="))
+ {
+ lynqSetArgv(&(argv[2]),&Point,"0");
+ token = strtok(str, "=");
+ //argv[0] = token;
+ if(strstr(token, "+"))
+ {
+ argv[0] = strstr(token, "+")+1;
+ while (token != NULL)
+ {
+ string = token;
+ token = strtok(NULL, "=");
+ }
+ parameter = strtok(string, ",");
+ int i = 3;
+ while (parameter != NULL)
+ {
+ argv[i++] = parameter;
+ parameter = strtok(NULL, ",");
+ }
+ }
+ else
+ {
+ argv[0] = token;
+ }
+ }
+ else if(strstr(cmd,"?"))
+ {
+ lynqSetArgv(&(argv[2]),&Point,"2");
+ token = strtok(str, "?");
+ //argv[0] = token;
+ argv[0] = strstr(token, "+")+1;
+ while (token != NULL)
+ {
+ string = token;
+ token = strtok(NULL, "?");
+ }
+ parameter = strtok(string, ",");
+ int i = 3;
+ while (parameter != NULL)
+ {
+ argv[i++] = parameter;
+ parameter = strtok(NULL, ",");
+ }
+ }
+ if(cnt > maxArgc)
+ return -1;
+ return cnt;
+}
+*/
+
+
+
+void lynq_at_factory_cb(char *input, int input_max_size)
+{
+ if(handle_output != NULL)
+ {
+ RLOGD("function %s line %d input %s\n", __FUNCTION__, __LINE__, input);
+ if(input != NULL)
+ {
+ char *handle_string = input + strlen(FACTORY_STRING);
+ if(!strlen(handle_string))
+ {
+ RLOGD("function %s line %d strlen %d\n", __FUNCTION__, __LINE__, strlen(handle_string));
+ return;
+ }
+ RLOGD("function %s line %d handle_string %s\n", __FUNCTION__, __LINE__, handle_string);
+ Command *cmd = find_command(handle_string);
+ if(cmd != NULL)
+ {
+ RLOGD("function %s line %d\n", __FUNCTION__, __LINE__);
+ (*(cmd->func))(handle_string);
+ return;
+ }
+ }
+ }
+}
+
+lynq_atsvc_incb lynq_register_at_factory(lynq_atsvc_outcb out_cb)
+{
+ if(out_cb != NULL)
+ {
+ handle_output = out_cb;
+ RLOGD("function %s line %d\n", __FUNCTION__, __LINE__);
+ return lynq_at_factory_cb;
+ }
+}
diff --git a/src/lynq/lib/liblynq-at-factory/makefile b/src/lynq/lib/liblynq-at-factory/makefile
new file mode 100755
index 0000000..f621678
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-factory/makefile
@@ -0,0 +1,73 @@
+
+SHELL = /bin/sh
+RM = rm -f
+
+LOCAL_CFLAGS := -Wall \
+ -std=gnu++14 \
+ -g -Os \
+ -flto \
+ -DRIL_SHLIB \
+ -DATCI_PARSE \
+ -fPIC \
+ -DKEEP_ALIVE \
+ -DECALL_SUPPORT \
+ -fpermissive \
+
+$(warning ################# lynq at factory demo ROOT: $(ROOT),includedir:$(includedir))
+LOCAL_PATH = .
+
+LOCAL_C_INCLUDES = \
+ -I. \
+ -I$(LOCAL_PATH)/include/libat \
+ -I$(ROOT)$(includedir)/logger \
+ -I$(ROOT)$(includedir)/liblog \
+ -I$(ROOT)$(includedir)/vendor-ril \
+
+
+LOCAL_LIBS := \
+ -L. \
+ -ldl \
+ -lstdc++ \
+ -llog \
+ -lcutils \
+ -lutils \
+ -lbinder \
+ -lpthread \
+ -llynq-log \
+
+
+SOURCES = $(wildcard *.cpp)
+
+EXECUTABLE = liblynq-at-factory.so
+
+OBJECTS=$(SOURCES:.cpp=.o)
+
+.PHONY: build clean install pack_rootfs
+
+all: build
+$(EXECUTABLE): $(OBJECTS)
+ $(CXX) -shared -Wl,--no-undefined $(OBJECTS) $(LOCAL_LIBS) $(LOCAL_CFLAGS) $(LOCAL_C_INCLUDES) -o $@
+
+%.o : %.cpp
+ $(CXX) $(LOCAL_C_INCLUDES) $(LOCAL_CFLAGS) $(LOCAL_LIBS) -o $@ -c $<
+
+build: $(EXECUTABLE)
+ $(warning ########## build $(EXECUTABLE) ##########)
+
+install:
+ mkdir -p $(ROOT)$(base_libdir)/
+ install $(EXECUTABLE) $(ROOT)$(base_libdir)/
+ mkdir -p $(ROOT)$(includedir)/$(NAME)/sdk
+
+pack_rootfs:
+ mkdir -p $(PACK_INITRAMFS_TO)$(base_libdir)/
+ cp -af $(EXECUTABLE) $(PACK_INITRAMFS_TO)$(base_libdir)/
+ $(CROSS)strip $(PACK_INITRAMFS_TO)$(base_libdir)/$(EXECUTABLE)
+ mkdir -p $(PACK_TO)$(base_libdir)/
+ cp -af $(EXECUTABLE) $(PACK_TO)$(base_libdir)/
+ $(CROSS)strip $(PACK_TO)$(base_libdir)/$(EXECUTABLE)
+
+.PHONY: clean
+clean:
+ $(RM) $(OBJECTS) $(EXECUTABLE)
+ -find . -name "*.o" -delete
diff --git a/src/lynq/lib/liblynq-at-fota/LICENSE b/src/lynq/lib/liblynq-at-fota/LICENSE
new file mode 100755
index 0000000..382fc78
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-fota/LICENSE
@@ -0,0 +1,31 @@
+Copyright Statement:
+
+This software/firmware and related documentation ("Mobiletek Software") are
+protected under relevant copyright laws. The information contained herein is
+confidential and proprietary to Mobiletek Inc. and/or its licensors. Without
+the prior written permission of Mobiletek inc. and/or its licensors, any
+reproduction, modification, use or disclosure of Mobiletek Software, and
+information contained herein, in whole or in part, shall be strictly
+prohibited.
+
+Mobiletek Inc. (C) 2015. All rights reserved.
+
+BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
+THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("Mobiletek SOFTWARE")
+RECEIVED FROM Mobiletek AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
+ON AN "AS-IS" BASIS ONLY. Mobiletek EXPRESSLY DISCLAIMS ANY AND ALL
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+NONINFRINGEMENT. NEITHER DOES Mobiletek PROVIDE ANY WARRANTY WHATSOEVER WITH
+RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
+INCORPORATED IN, OR SUPPLIED WITH THE Mobiletek SOFTWARE, AND RECEIVER AGREES
+TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
+RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
+OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN Mobiletek
+SOFTWARE. Mobiletek SHALL ALSO NOT BE RESPONSIBLE FOR ANY Mobiletek SOFTWARE
+RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
+STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND Mobiletek'S
+ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE Mobiletek SOFTWARE
+RELEASED HEREUNDER WILL BE, AT Mobiletek'S OPTION, TO REVISE OR REPLACE THE
+Mobiletek SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
+CHARGE PAID BY RECEIVER TO Mobiletek FOR SUCH Mobiletek SOFTWARE AT ISSUE.
\ No newline at end of file
diff --git a/src/lynq/lib/liblynq-at-fota/include/libat/lynq_at_fota.h b/src/lynq/lib/liblynq-at-fota/include/libat/lynq_at_fota.h
new file mode 100755
index 0000000..dd32d26
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-fota/include/libat/lynq_at_fota.h
@@ -0,0 +1,31 @@
+/*=============================================================================
+# FileName: lynq_at_fota.h
+# Desc: about at of fota
+# Author: jb.qi
+# Version: V1.0
+# LastChange: 2023-01-09
+# History:
+ copyright:Mobiletek
+=============================================================================*/
+#ifndef __LYNQ_FOTA_H__
+#define __LYNQ_FOTA_H__ 1
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define LYNQ_E_FTP_LOGIN_FAIL 9002 /*Ftp login fail*/
+#define LYNQ_E_FTP_SEND_FAIL 9003 /*Ftp send log fail*/
+#define LYNQ_E_GET_LOG_FAIL 9004 /*Get log fail*/
+#define LYNQ_E_LOG_CMD_ERROR 9005 /*cmd error*/
+
+typedef void ( *lynq_atsvc_incb )( const char *input,const int length);
+typedef void ( *lynq_atsvc_outcb )(char *output, int out_max_size, int mode);
+lynq_atsvc_incb lynq_register_fota(lynq_atsvc_outcb out_cb);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //__LYNQ_LOGSEND_TEST_H__
+
diff --git a/src/lynq/lib/liblynq-at-fota/lynq_at_fota.cpp b/src/lynq/lib/liblynq-at-fota/lynq_at_fota.cpp
new file mode 100755
index 0000000..148214c
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-fota/lynq_at_fota.cpp
@@ -0,0 +1,300 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "include/libat/lynq_at_fota.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <log/log.h>
+#include "mtk_device_wrap.h"
+#include "include/iot_rock.h"
+
+#define UPDATA_ADDR "/tmp/fota.delta"
+#define READ_BLOCK_SIZE 0x40000
+#define FLASH_DEV_DELTA "/dev/mtd41"
+#define LOG_TAG "AT-FOTA"
+
+lynq_atsvc_outcb g_handle_output;
+char str[128];
+char g_buffer[128] = {0};
+int Response = 0;
+int g_lynq_fota_md5_flag = -1;
+char g_put_addr[64];
+char g_put_path[35];
+char g_cmd[128];
+
+void *deal_download()
+{
+ int ret;
+ RLOGD("start deal_download !!!\n");
+ ret = system(g_cmd);
+ RLOGD("ret:%d \n", ret);
+ if(ret != 0)
+ {
+ strcpy(str, "+FOTA: fota download fail\n");
+ g_handle_output(str, strlen(str), Response);
+ return NULL;
+ }
+ else
+ {
+ strcpy(str, "+FOTA: fota download success\n");
+ g_handle_output(str, strlen(str), Response);
+ }
+ return NULL;
+}
+
+
+int lynq_download_package(char (*string)[35])
+{
+ int ret = 0;
+ int str_num = -1;
+ pthread_t tid;
+
+ RLOGD("function %s start\n", __FUNCTION__);
+ for(int i = 0; i < 9; i++)
+ {
+ if(string[i] == NULL)
+ {
+ strcpy(str, "+FOTA: download data null\n");
+ g_handle_output(str, strlen(str), Response);
+ return 1;
+ }
+ }
+
+ if(strlen(string[9]) == 0)
+ {
+ ret = chdir("/tmp/");
+ if( 0 != ret)
+ {
+ RLOGD("/tmp/ is error\n");
+ strcpy(str, "+FOTA: the tmp is error\n");
+ g_handle_output(str, strlen(str), Response);
+ return ret;
+ }
+ strcpy(g_put_path, "/tmp/");
+ }
+ else
+ {
+ ret = chdir(string[9]);
+ if( 0 != ret)
+ {
+ RLOGD("%s is error directory \n", string[9]);
+ strcpy(str, "+FOTA: NO such directory\n");
+ g_handle_output(str, strlen(str), Response);
+ return ret;
+ }
+ strcpy(g_put_path, string[9]);
+ }
+
+ sprintf(g_cmd,"wget ftp://%s:%s@%s:%s%s%s",string[2],string[3],string[0],string[1],string[7],string[8]);
+ RLOGD("g_cmd:%s\n", g_cmd);
+ str_num = strlen(g_put_path);
+
+ if(g_put_path[str_num - 1] == '/')
+ {
+ sprintf(g_put_addr,"%s%s", g_put_path, string[8]);
+ }
+ else
+ {
+ sprintf(g_put_addr,"%s/%s", g_put_path, string[8]);
+ }
+ RLOGD("g_put_addr: %s\n", g_put_addr);
+ if(lynq_fota_set_addr_value(g_put_addr,strlen(g_put_addr)))
+ {
+ strcpy(str, "+FOTA: set fota addr fail\n");
+ g_handle_output(str, strlen(str), Response);
+ }
+
+ pthread_create(&tid,NULL,deal_download,NULL);
+ pthread_detach(tid);
+
+ return ret;
+}
+
+/*
+ * @brief Differential subcontracting MD5 check
+ *
+ * @param string:MD5 value,Subcontracting address,Refer to the fota documentation
+ */
+
+int lynq_md5_package(char (*string)[35])
+{
+ char input_md5_data[64] = {0};
+ RLOGD("function %s start\n", __FUNCTION__);
+ for(int i = 0; i < 2; i++)
+ {
+ if(string[i] == NULL)
+ {
+ strcpy(str, "+FOTA: md5 value null\n");
+ g_handle_output(str, strlen(str), Response);
+ return 1;
+ }
+ }
+
+ sprintf(input_md5_data,"%s",string[0]);
+ RLOGD("input_md5_data: %s\n", string[0]);
+ g_lynq_fota_md5_flag = lynq_md5_file_verfy(g_put_addr, input_md5_data);
+ if(g_lynq_fota_md5_flag != 0)
+ {
+ strcpy(str, "+FOTA: md5 fail\n");
+ g_handle_output(str, strlen(str), Response);
+ return 1;
+ }
+ return 0;
+}
+
+/**
+ * @brief fota
+ *
+ * @param void
+ */
+int lynq_fota_try(void)
+{
+ RLOGD("function %s start\n", __FUNCTION__);
+ if(g_lynq_fota_md5_flag == 0) //upgrade success ,device reboot ,lynq_fota_md5_flag no need to reset
+ {
+ if(0 != lynq_rock_main(1))
+ {
+ g_lynq_fota_md5_flag = -1;
+ strcpy(str, "+FOTA: update fail\n");
+ g_handle_output(str, strlen(str), Response);
+ return 1;
+ }
+ }
+ else
+ {
+ strcpy(str, "+FOTA: md5 verify fail\n");
+ g_handle_output(str, strlen(str), Response);
+ return 1;
+ }
+
+ return 0;
+}
+
+void lynq_at_fota(char (*argv)[35])
+{
+ int result;
+ RLOGD("function %s start\n", __FUNCTION__);
+ RLOGD("buffer: %s",g_buffer);
+ if(!(strcmp(argv[0], "AT+FOTA?")))
+ {
+ if(strlen(g_buffer) == 0)
+ {
+ strcpy(str, "+FOTA: OK\n");
+ }
+ else
+ {
+ sprintf(str, "+FOTA: %s\n",g_buffer);
+
+ }
+ g_handle_output(str, strlen(str), Response);
+ return ;
+ }
+ else if(!(strcmp(argv[0], "AT+FOTA=?")))
+ {
+ strcpy(str, "+FOTA:(0-2),""\n");
+ g_handle_output(str, strlen(str), Response);
+ return ;
+
+ }
+ if(!(strcmp(argv[0], "AT+FOTA=0")) || !(strcmp(argv[0], "AT+LYNQFOTA=download")))
+ {
+ RLOGD("argv[0]: %s\n", argv[0]);
+ if(!(strcmp(argv[1], "ftp")))
+ {
+ result = lynq_download_package(&argv[2]);
+ if(result != 0)
+ {
+ strcpy(str, "+FOTA: DOWNLOAD FAIL\n");
+ }
+ else
+ {
+ strcpy(str, "+FOTA: DOWNLOAD START\n");
+ }
+ }
+ else
+ {
+ strcpy(str, "+FOTA: NO FTP DOWNLOAD\n");
+ }
+ }
+
+ else if(!(strcmp(argv[0], "AT+FOTA=1")) || !(strcmp(argv[0], "AT+LYNQFOTA=md5")))
+ {
+ RLOGD("argv[0]: %s\n", argv[0]);
+ result = lynq_md5_package(&argv[1]);
+ if(result != 0)
+ {
+ strcpy(str, "+FOTA: MD5 FAIL\n");
+ }
+ else
+ {
+ strcpy(str, "+FOTA: MD5 SUCCESS\n");
+ }
+ }
+ else if(!(strcmp(argv[0], "AT+FOTA=2")) || !(strcmp(argv[0], "AT+LYNQFOTA=upgrade")))
+ {
+ RLOGD("argv[0]: %s\n", argv[0]);
+ result = lynq_fota_try();
+ if(result == 0)
+ {
+ strcpy(str, "+FOTA: UPDATE SUCCESS\n");
+ }
+ else
+ {
+ strcpy(str, "+FOTA: UPDATE FAIL\n");
+ }
+ }
+ else
+ {
+ strcpy(str, "+CME: ERROR: 100\n");
+
+ }
+ g_handle_output(str, strlen(str), Response);
+
+}
+
+void lynq_at_fota_cb(char *input, int input_max_size)
+{
+ char arry[20][35]={};
+ char *p = NULL;
+ int i = 0;
+
+ if(input[8] == '0')
+ {
+ strcpy(g_buffer, input);
+ }
+ if(g_handle_output != NULL)
+ {
+ RLOGD("function %s start,input: %s \n", __FUNCTION__, input);
+ if(input != NULL)
+ {
+ while(( p = strsep(&input,",")) != NULL)
+ {
+ strcpy(arry[i],p);
+ i++;
+ }
+ lynq_at_fota(arry);
+ }
+ }
+
+}
+
+
+lynq_atsvc_incb lynq_register_fota(lynq_atsvc_outcb out_cb)
+{
+ if(out_cb != NULL)
+ {
+ g_handle_output = out_cb;
+ RLOGD("function %s start\n", __FUNCTION__);
+ return lynq_at_fota_cb;
+ }
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+
diff --git a/src/lynq/lib/liblynq-at-fota/makefile b/src/lynq/lib/liblynq-at-fota/makefile
new file mode 100755
index 0000000..4368444
--- /dev/null
+++ b/src/lynq/lib/liblynq-at-fota/makefile
@@ -0,0 +1,87 @@
+
+SHELL = /bin/sh
+RM = rm -f
+
+LOCAL_CFLAGS := -Wall \
+ -std=gnu++14 \
+ -g -Os \
+ -flto \
+ -DRIL_SHLIB \
+ -DATCI_PARSE \
+ -fPIC \
+ -DKEEP_ALIVE \
+ -DECALL_SUPPORT \
+ -fpermissive \
+
+$(warning ################# lynq at factory demo ROOT: $(ROOT),includedir:$(includedir))
+
+ifeq ($(strip $(MOBILETEK_FOTA_CFG)), PLATFORM)
+ LOCAL_CFLAGS += -DMOBILETEK_FOTA_CFG
+endif
+
+ifeq ($(strip $(MOBILETEK_FOTA_CFG)), GSW)
+ LOCAL_CFLAGS += -DGSW_FOTA_CFG
+endif
+
+
+LOCAL_PATH = .
+
+LOCAL_C_INCLUDES = \
+ -I. \
+ -I$(LOCAL_PATH)/include/libat \
+ -I$(ROOT)$(includedir)/logger \
+ -I$(ROOT)$(includedir)/liblog \
+ -I$(ROOT)$(includedir)/vendor-ril \
+ -I$(ROOT)$(includedir)/ftp \
+
+
+
+LOCAL_LIBS := \
+ -L. \
+ -ldl \
+ -lstdc++ \
+ -llog \
+ -lcutils \
+ -lutils \
+ -lbinder \
+ -lpthread \
+ -llynq-log \
+ -llynq-fota \
+ -llynq-protcl \
+
+
+SOURCES = $(wildcard *.cpp)
+
+EXECUTABLE = liblynq-at-fota.so
+
+OBJECTS=$(SOURCES:.cpp=.o)
+
+.PHONY: build clean install pack_rootfs
+
+all: build
+$(EXECUTABLE): $(OBJECTS)
+ $(CXX) -shared -Wl,--no-undefined $(OBJECTS) $(LOCAL_LIBS) $(LOCAL_CFLAGS) $(LOCAL_C_INCLUDES) -o $@
+
+%.o : %.cpp
+ $(CXX) $(LOCAL_C_INCLUDES) $(LOCAL_CFLAGS) $(LOCAL_LIBS) -o $@ -c $<
+
+build: $(EXECUTABLE)
+ $(warning ########## build $(EXECUTABLE) ##########)
+
+install:
+ mkdir -p $(ROOT)$(base_libdir)/
+ install $(EXECUTABLE) $(ROOT)$(base_libdir)/
+ mkdir -p $(ROOT)$(includedir)/$(NAME)/sdk
+
+pack_rootfs:
+ mkdir -p $(PACK_INITRAMFS_TO)$(base_libdir)/
+ cp -af $(EXECUTABLE) $(PACK_INITRAMFS_TO)$(base_libdir)/
+ $(CROSS)strip $(PACK_INITRAMFS_TO)$(base_libdir)/$(EXECUTABLE)
+ mkdir -p $(PACK_TO)$(base_libdir)/
+ cp -af $(EXECUTABLE) $(PACK_TO)$(base_libdir)/
+ $(CROSS)strip $(PACK_TO)$(base_libdir)/$(EXECUTABLE)
+
+.PHONY: clean
+clean:
+ $(RM) $(OBJECTS) $(EXECUTABLE)
+ -find . -name "*.o" -delete
diff --git a/src/lynq/lib/liblynq-call/LICENSE b/src/lynq/lib/liblynq-call/LICENSE
index 77f59ed..605b7ea 100755
--- a/src/lynq/lib/liblynq-call/LICENSE
+++ b/src/lynq/lib/liblynq-call/LICENSE
@@ -1,31 +1,31 @@
Copyright Statement:
-This software/firmware and related documentation ("MediaTek Software") are
+This software/firmware and related documentation ("MobileTek Software") are
protected under relevant copyright laws. The information contained herein is
-confidential and proprietary to MediaTek Inc. and/or its licensors. Without
-the prior written permission of MediaTek inc. and/or its licensors, any
-reproduction, modification, use or disclosure of MediaTek Software, and
+confidential and proprietary to MobileTek Inc. and/or its licensors. Without
+the prior written permission of MobileTek inc. and/or its licensors, any
+reproduction, modification, use or disclosure of MobileTek Software, and
information contained herein, in whole or in part, shall be strictly
prohibited.
-MediaTek Inc. (C) 2015. All rights reserved.
+MobileTek Inc. (C) 2015. All rights reserved.
BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
-THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
-RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
-ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
+THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MobileTek SOFTWARE")
+RECEIVED FROM MobileTek AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
+ON AN "AS-IS" BASIS ONLY. MobileTek EXPRESSLY DISCLAIMS ANY AND ALL
WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
-NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
+NONINFRINGEMENT. NEITHER DOES MobileTek PROVIDE ANY WARRANTY WHATSOEVER WITH
RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
-INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
+INCORPORATED IN, OR SUPPLIED WITH THE MobileTek SOFTWARE, AND RECEIVER AGREES
TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
-OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
-SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
+OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MobileTek
+SOFTWARE. MobileTek SHALL ALSO NOT BE RESPONSIBLE FOR ANY MobileTek SOFTWARE
RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
-STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
-ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
-RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
-MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
-CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
+STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MobileTek'S
+ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MobileTek SOFTWARE
+RELEASED HEREUNDER WILL BE, AT MobileTek'S OPTION, TO REVISE OR REPLACE THE
+MobileTek SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
+CHARGE PAID BY RECEIVER TO MobileTek FOR SUCH MobileTek SOFTWARE AT ISSUE.
diff --git a/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h b/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h
index b9efae9..0b1b86e 100755
--- a/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h
+++ b/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h
@@ -6,7 +6,7 @@
#define LYNQ_PHONE_NUMBER_MAX 32
#define INDEX_IS_NUMBER( alpha_char ) \
( ( (alpha_char >= '0') && (alpha_char <= '9') ) ? 1 : 0 )
-#define LYNQ_CALL_MAX 10
+#define LYNQ_CALL_MAX 3
#define LYNQ_CALL_FAIL_VENDOR_CAUSE 64
#define MAX_IP_LENGTH 128
#define MAX_VLAN_INFO_LENGTH 128
@@ -48,7 +48,6 @@
int lynq_call_answer();
int lynq_call_hungup(int*handle);
int lynq_call_hungup_all();
-int lynq_wait_incoming_call(int *handle);
int lynq_set_auto_answercall(const int mode);
int lynq_get_mute_mic(int *status);
int lynq_set_mute_mic(const int enable);
@@ -63,6 +62,16 @@
int lynq_switch_waiting_or_holding_and_active(void);
int lynq_hangup_waiting_or_background(void);
int lynq_hangup_foreground_resume_background(void);
+
+/*lei add for API-163/API-164 2023/1/3*/
+/**
+ * @brief wait_call_state_change
+ *
+ * @param handle call_id
+ * @return int
+ */
+int lynq_wait_call_state_change(int *handle);
+/*lei add for API-163/API-164 2023/1/3*/
/*lei add for T8TSK-17 2022/7/20*/
#ifdef ECALL_SUPPORT
diff --git a/src/lynq/lib/liblynq-call/lynq_call.cpp b/src/lynq/lib/liblynq-call/lynq_call.cpp
index 0270aa1..d1e2293 100755
--- a/src/lynq/lib/liblynq-call/lynq_call.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_call.cpp
@@ -74,9 +74,9 @@
static int s_module_isDial = 0;
static pthread_mutex_t call_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t call_state_change_cond = PTHREAD_COND_INITIALIZER;
-static int s_IncomingCallId = 0;
-static pthread_mutex_t s_incoming_call_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t s_incoming_call_cond = PTHREAD_COND_INITIALIZER;
+static int s_CallId = 0;
+static pthread_mutex_t s_call_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_call_state_change_cond = PTHREAD_COND_INITIALIZER;
static int s_module_call_state =CALL_OFF;
static int s_call_auto_answer = 0;
@@ -299,6 +299,8 @@
s_call_lists[lynq_call_id].used = 0;
memset(s_call_lists[lynq_call_id].addr,0,sizeof(s_call_lists[lynq_call_id].addr));
}
+
+
int getUnusedElement()
{
for(int i=0;i < LYNQ_CALL_MAX; i++)
@@ -329,15 +331,15 @@
callList->direction = direction;
return;
}
-int waitIncomingCall()
+
+void wait_call_state()
{
- LYINFLOG("wait incming call");
- int ret = 0;
- pthread_mutex_lock(&s_incoming_call_mutex);
- ret = pthread_cond_wait(&s_incoming_call_cond,&s_incoming_call_mutex);
- pthread_mutex_unlock(&s_incoming_call_mutex);
- return ret;
+ LYINFLOG("call state changed");
+ pthread_mutex_lock(&s_call_state_change_mutex);
+ pthread_cond_wait(&s_call_state_change_cond,&s_call_state_change_mutex);
+ pthread_mutex_unlock(&s_call_state_change_mutex);
}
+
int checkHasCall(char addr[])
{
for(int i = 0;i<LYNQ_CALL_MAX;i++)
@@ -384,18 +386,25 @@
pthread_cond_signal(&call_state_change_cond);
pthread_mutex_unlock(&call_state_change_mutex);
}
-void sendSignalIncomingCall()
+void send_call_state_change()
{
- LYINFLOG("send incoming call signal");
- pthread_mutex_lock(&s_incoming_call_mutex);
- pthread_cond_signal(&s_incoming_call_cond);
- pthread_mutex_unlock(&s_incoming_call_mutex);
+ LYINFLOG("send call state change");
+ pthread_mutex_lock(&s_call_state_change_mutex);
+ pthread_cond_signal(&s_call_state_change_cond);
+ pthread_mutex_unlock(&s_call_state_change_mutex);
}
void cleanup_call_list_mutex(void *arg)
{
pthread_mutex_unlock(&s_notice_get_call_list_mutex);
}
+
+void update_end_state(int lynq_call_id)
+{
+ LYINFLOG("update_end_state local idx is %d, id is %d",lynq_call_id,s_call_lists[lynq_call_id].call_id);
+ s_call_lists[lynq_call_id].call_state = (int)LYNQ_CALL_END;
+}
+
void *triggerGetCallList(void *parg)
{
int ret=0;
@@ -447,8 +456,11 @@
}
if(call_end == 0)
{
- LYINFLOG("MT hungup,then clean call info local idx is %d id is %d",i, s_call_lists[i].call_id);
- cleanCallList(i);
+ LYINFLOG("MT/MO hungup,then clean call info local idx is %d id is %d",i, s_call_lists[i].call_id);
+ //update_end_state(i);//lei modify for:update end state for this call
+ cleanCallList(i);
+ send_call_state_change();//means mt/mo call is end
+ //cleanCallList(i);
}
} //fix bug API-54
else
@@ -494,8 +506,8 @@
{
n = addAddr(call_list[i].addr,call_list[i].call_id);
updateCallList(&s_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
- s_IncomingCallId = call_list[i].call_id;
- sendSignalIncomingCall();
+ s_CallId = call_list[i].call_id;
+ send_call_state_change();
}
else if(s_call_lists[n].call_state == call_list[i].call_state)
{
@@ -507,15 +519,16 @@
**fix bug API-54
*/
LYINFLOG("resend incoming call signal");
- sendSignalIncomingCall();
+ send_call_state_change();
}
}
else
{
LYINFLOG("state changed from %d to %d",s_call_lists[n].call_state,call_list[i].call_state);
- updateCallList(&s_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
- }
+ updateCallList(&s_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);//update mt call
+ send_call_state_change();
+ }
}
else
{
@@ -527,17 +540,18 @@
{
if(s_call_lists[n].call_id==0)
{
- LYINFLOG("add a call id");
- update=1;
+ LYINFLOG("add a call id");
+ update=1;//for send sigal
+ s_CallId = call_list[i].call_id;
}
LYINFLOG("local idx %d updated, original call id is %d origial addr is %s original state is %d",n,s_call_lists[n].call_id,s_call_lists[n].addr,s_call_lists[n].call_state);
updateCallList(&s_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
call_end = 1;
+ send_call_state_change();//means mo call is success
break;
}
}
-
- if(call_end == 0)
+ if(call_end == 0)//1.there is no space to use 2.can't find addr in buffer 3.call_id not equal eg:when call is error return 8004/handle <= 0 will into this
{
LYINFLOG("need to hangup id %d", call_list[i].call_id);
#ifdef ECALL_SUPPORT
@@ -550,6 +564,7 @@
LYINFLOG("hang up service call id %d",call_list[i].call_id);
lynq_call_hungup(&(call_list[i].call_id));
}
+
}
LYDBGLOG("servie idx %d end",i);
}
@@ -751,7 +766,7 @@
g_module_Global_uToken = utoken;
- int ret = lynq_urc_socket_start();
+ int ret = lynq_start_all_urc_socket_thread();
if(ret != RESULT_OK)
{
LYERRLOG("init socket urc fail!!!");
@@ -759,11 +774,11 @@
return LYNQ_E_INNER_ERROR;
}
- ret = lynq_server_socket_start();
+ ret = lynq_start_all_rc_socket_thread();
if(ret !=RESULT_OK)
{
LYERRLOG("init socket client fail!!!");
- lynq_close_urc_thread();
+ lynq_close_all_urc_socket_thread();
g_module_init_flag = MODULE_CLOSED;
return LYNQ_E_INNER_ERROR;
}
@@ -773,8 +788,8 @@
if(ret != RESULT_OK)
{
LYERRLOG("lynq_start_call_list_loop fail!!!");
- lynq_close_urc_thread();
- lynq_close_rc_thread();
+ lynq_close_all_urc_socket_thread();
+ lynq_close_all_rc_socket_thread();
g_module_init_flag = MODULE_CLOSED;
return LYNQ_E_INNER_ERROR;
}
@@ -795,8 +810,8 @@
lynq_call_hungup_all();
lynq_set_voice_audio_mode(AUDIO_MODE_CODEC);
g_module_init_flag = MODULE_SWITCHING;
- lynq_close_urc_thread();
- lynq_close_rc_thread();
+ lynq_close_all_urc_socket_thread();
+ lynq_close_all_rc_socket_thread();
lynq_stop_call_list_loop();
g_module_init_flag = MODULE_CLOSED;
return 0;
@@ -891,6 +906,7 @@
return s_module_isDial;
}
+
int lynq_call(int* handle,char addr[])
{
if(g_module_init_flag != MODULE_RUNNING)
@@ -921,25 +937,23 @@
return LYNQ_E_ECALL_BEING_RUNNING;
}
#endif
-
Parcel* p=NULL;
lynq_call_id = addAddr(addr,0);
int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_DIAL,2,"%s %d",addr, 0);
if(ret!=0)
{
- cleanCallList(lynq_call_id);
+ cleanCallList(lynq_call_id);
return ret;
- }
-
- delete p;
-
+ }
+ delete p;
s_module_isDial = 1;
if(waitCallstateChange(6000)==ETIMEDOUT)//6000ms
{
//if timeout,this call need destroy.
s_module_isDial = 0;
LYERRLOG("lynq_call timeout:wait Call state fail!!! clear local idx %d",lynq_call_id);
- cleanCallList(lynq_call_id);
+ cleanCallList(lynq_call_id);
+ send_call_state_change();
return LYNQ_E_TIME_OUT;
}
s_module_isDial = 0;
@@ -952,10 +966,12 @@
else
{
LYERRLOG("lynq_call dial addr %s fail, invalid id",addr);
- cleanCallList(lynq_call_id);
+ cleanCallList(lynq_call_id);
+ send_call_state_change();
return LYNQ_E_INVALID_ID_ANONALY;
- }
+ }
}
+
int lynq_call_answer()
{
if(g_module_init_flag != MODULE_RUNNING)
@@ -972,6 +988,7 @@
}
return ret;
}
+
int lynq_call_hungup(int* handle)
{
if(g_module_init_flag != MODULE_RUNNING)
@@ -1018,17 +1035,18 @@
}
return ret;
}
-int lynq_wait_incoming_call(int *handle)
+
+int lynq_wait_call_state_change(int *handle)
{
if(g_module_init_flag != MODULE_RUNNING)
{
LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
return LYNQ_E_CONFLICT;
}
- waitIncomingCall();
- *handle = s_IncomingCallId;
- LYINFLOG("lynq incoming call id:%d",s_IncomingCallId);
- return RESULT_OK;
+ wait_call_state();
+ *handle = s_CallId;
+ LYINFLOG("lynq mo/mt call id:%d",s_CallId);
+ return RESULT_OK;
}
int lynq_set_auto_answercall(const int mode)
@@ -1042,6 +1060,19 @@
LYINFLOG("auto answer call mode =%d",mode);
return RESULT_OK;
}
+
+int lynq_find_already_end()
+{
+ for(int i=0;i < LYNQ_CALL_MAX; i++)
+ {
+ if(s_call_lists[i].call_state == 6)
+ {
+ return 0;
+ }
+ }
+ return INVALID_ID;
+}
+
int lynq_get_current_call_state(int *handle, int *call_state,int *toa,int *direction,char addr[])
{
if(g_module_init_flag != MODULE_RUNNING)
@@ -1056,16 +1087,26 @@
LYERRLOG("handle is NULL");
return LYNQ_E_PARAMETER_ANONALY;
}
+ LYINFLOG("lynq_get_current_call_state %d\n ", *handle);
lynq_call_id = find_call_id_with_call_id(*handle);
if(lynq_call_id==INVALID_ID)
{
- return LYNQ_E_INVALID_ID_ANONALY;
+ //find end state
+ if((*handle) >= 0)
+ {
+ *call_state = (int)LYNQ_CALL_END;
+ return RESULT_OK;
+ }
+ else
+ {
+ return LYNQ_E_INVALID_ID_ANONALY;
+ }
}
*call_state = s_call_lists[lynq_call_id].call_state;
*toa = s_call_lists[lynq_call_id].toa;
*direction = s_call_lists[lynq_call_id].direction;
memcpy(addr,s_call_lists[lynq_call_id].addr,strlen(s_call_lists[lynq_call_id].addr)+1);
- return RESULT_OK;
+ return RESULT_OK;
}
int lynq_get_current_call_number()
@@ -1389,16 +1430,36 @@
}
/*audio end*/
+
+
+bool is_support_urc(int urc_id)
+{
+ switch(urc_id)
+ {
+ case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED:
+ case RIL_UNSOL_CALL_RING:
+ case RIL_UNSOL_RINGBACK_TONE:
+ case RIL_UNSOL_CALL_INFO_INDICATION:
+#ifdef ECALL_SUPPORT
+ case RIL_UNSOL_ECALL_INDICATIONS://9502
+#endif
+ return true;
+ default:
+ return false;
+ }
+}
+
void urc_msg_process(Parcel *p)
{
int resp_type;
int urcid;
int slot_id;
-
+
+ int size=p->dataSize();
p->readInt32(&resp_type);
p->readInt32(&urcid);
p->readInt32(&slot_id);
- LYINFLOG("urc id = %d, slot_id = %d",urcid,slot_id);
+ LYINFLOG("%s urc id = %d, slot_id = %d, size is %d, msg is %s",__func__, urcid,slot_id,size,requestToString(urcid));
switch (urcid)
{
case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED://1001
diff --git a/src/lynq/lib/liblynq-call/lynq_call_ecall.cpp b/src/lynq/lib/liblynq-call/lynq_call_ecall.cpp
index 0c76262..d25675a 100755
--- a/src/lynq/lib/liblynq-call/lynq_call_ecall.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_call_ecall.cpp
@@ -479,7 +479,7 @@
}
if(enable<0)
{
- if(enable >-100)
+ if(enable >-200)
{
goto set_ivs_end;
// lynq_set_common_request(RIL_REQUEST_ECALL_SET_IVS,1,"%d",enable);
@@ -490,7 +490,7 @@
}
else
{
- s_ecall_whether_preempt= ((-100-enable) & 0x11);
+ s_ecall_whether_preempt= ((-200-enable) & 0x11);
}
return RESULT_OK;
}
diff --git a/src/lynq/lib/liblynq-call/lynq_call_rtp.cpp b/src/lynq/lib/liblynq-call/lynq_call_rtp.cpp
index f217c25..e22b016 100755
--- a/src/lynq/lib/liblynq-call/lynq_call_rtp.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_call_rtp.cpp
@@ -84,9 +84,7 @@
system(cmd);
}
else
- {
- sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on\" %d", 1);
- system(cmd);
+ {
sprintf(cmd, "amixer -D mtk_phonecall cset name=\"M2M_Speech_on\" %d", 0);
system(cmd);
sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH1 DL2_CH1\" %d", 0);
@@ -97,6 +95,8 @@
system(cmd);
sprintf(cmd, "amixer -c0 cset name=\"UL2_CH2 PCM_2_CAP_CH1\" %d", 0);
system(cmd);
+ sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on\" %d", 1);
+ system(cmd);
}
}
diff --git a/src/lynq/lib/liblynq-call/lynq_module_common.h b/src/lynq/lib/liblynq-call/lynq_module_common.h
index 9e70d6c..590971a 100755
--- a/src/lynq/lib/liblynq-call/lynq_module_common.h
+++ b/src/lynq/lib/liblynq-call/lynq_module_common.h
@@ -5,29 +5,31 @@
#define RESULT_ERROR (-1)
/*the same with lynq_interface.h begin*/
-#define LYNQ_REQUEST_VENDOR_BASE 8000
-#define LYNQ_URC_VENDOR_BASE 9000
-#define LYNQ_AT_SNED (LYNQ_REQUEST_VENDOR_BASE +1)
-#define LYNQ_URC_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+1)
-#define LYNQ_URC_DATA_STATUS_IND (LYNQ_URC_VENDOR_BASE+2)
-#define LYNQ_URC_DATA_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+3)
-#define LYNQ_AUTO_ANSWER_CALL (LYNQ_REQUEST_VENDOR_BASE +2)
-#define LYNQ_REQUEST_SET_DTMF_VOLUME (LYNQ_REQUEST_VENDOR_BASE +3)
-#define LYNQ_URC_MODIFY_APNDB (LYNQ_URC_VENDOR_BASE+4)
-#define LYNQ_URC_RESET_APNDB (LYNQ_URC_VENDOR_BASE+5)
-
-
-#define LYNQ_REQUEST_WRITE_SMS_TO_MEMORY (LYNQ_REQUEST_VENDOR_BASE +4)
-#define LYNQ_REQUEST_READ_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 5)
-#define LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 6)
-#define LYNQ_REQUEST_LIST_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 7)
-#define LYNQ_REQUEST_SET_DEFAULT_SIM_ALL (LYNQ_REQUEST_VENDOR_BASE + 8)
-
-#define LYNQ_REQUEST_SET_SPEECH_VOLUME (LYNQ_REQUEST_VENDOR_BASE +9)
-#define LYNQ_REQUEST_GET_SPEECH_VOLUME (LYNQ_REQUEST_VENDOR_BASE +10)
-#define LYNQ_REQUEST_RECORD (LYNQ_REQUEST_VENDOR_BASE +11)
-#define LYNQ_REQUEST_OOS_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +12)
+#define LYNQ_REQUEST_VENDOR_BASE 8000
+#define LYNQ_URC_VENDOR_BASE 9000
+#define LYNQ_AT_SNED (LYNQ_REQUEST_VENDOR_BASE +1)
+#define LYNQ_URC_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+1)
+#define LYNQ_URC_DATA_STATUS_IND (LYNQ_URC_VENDOR_BASE+2)
+#define LYNQ_URC_DATA_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+3)
+#define LYNQ_AUTO_ANSWER_CALL (LYNQ_REQUEST_VENDOR_BASE +2)
+#define LYNQ_REQUEST_SET_DTMF_VOLUME (LYNQ_REQUEST_VENDOR_BASE +3)
+#define LYNQ_URC_MODIFY_APNDB (LYNQ_URC_VENDOR_BASE+4)
+#define LYNQ_URC_RESET_APNDB (LYNQ_URC_VENDOR_BASE+5)
+
+
+#define LYNQ_REQUEST_WRITE_SMS_TO_MEMORY (LYNQ_REQUEST_VENDOR_BASE +4)
+#define LYNQ_REQUEST_READ_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 5)
+#define LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 6)
+#define LYNQ_REQUEST_LIST_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 7)
+#define LYNQ_REQUEST_SET_DEFAULT_SIM_ALL (LYNQ_REQUEST_VENDOR_BASE + 8)
+
+#define LYNQ_REQUEST_SET_SPEECH_VOLUME (LYNQ_REQUEST_VENDOR_BASE +9)
+#define LYNQ_REQUEST_GET_SPEECH_VOLUME (LYNQ_REQUEST_VENDOR_BASE +10)
+#define LYNQ_REQUEST_RECORD (LYNQ_REQUEST_VENDOR_BASE +11)
+#define LYNQ_REQUEST_OOS_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +12)
#define LYNQ_REQUEST_OOS_DEEP_SLEEP_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +13)
+#define LYNQ_REQUEST_CHANGE_SCREEN_STATE (LYNQ_REQUEST_VENDOR_BASE + 14)/*jb.qi add for two sim suspend 2022/9/19*/
+#define LYNQ_REQUEST_CHANGE_RADIO (LYNQ_REQUEST_VENDOR_BASE + 15)
/*the same with lynq_interface.h end*/
typedef enum{
diff --git a/src/lynq/lib/liblynq-call/lynq_module_socket.cpp b/src/lynq/lib/liblynq-call/lynq_module_socket.cpp
index 71862a8..ff45c02 100755
--- a/src/lynq/lib/liblynq-call/lynq_module_socket.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_module_socket.cpp
@@ -15,6 +15,7 @@
#include "lynq_module_common.h"
#include "lynq_module_socket.h"
#include "liblog/lynq_deflog.h"
+#include "lynq_shm.h"
#define LYNQ_SERVICE_PORT 8088
#define LYNQ_ADDRESS "127.0.0.1"
@@ -40,6 +41,11 @@
int error;
}lynq_resp_t;
+typedef struct{
+ int resp_type;
+ int urcid;
+}lynq_head_t;
+
lynq_client_t client_t;
lynq_resp_t response;
@@ -67,6 +73,21 @@
const int waitResponse(int token,int time_out);
/*hq add for set waiting time 2022/09/13 end*/
+/*hq add for urc process asynchronous 2022/12/26 begin*/
+static pthread_mutex_t s_ProcessUrcMsgBlockMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_WaitProcessUrcMsgCond = PTHREAD_COND_INITIALIZER;
+
+#define BLOCK_PROCESS_URC_MSG_INIT() pthread_mutex_init(&s_ProcessUrcMsgBlockMutex,NULL)
+#define BLOCK_PROCESS_URC_MSG_LOCK() pthread_mutex_lock(&s_ProcessUrcMsgBlockMutex)
+#define BLOCK_PROCESS_URC_MSG_UNLOCK() pthread_mutex_unlock(&s_ProcessUrcMsgBlockMutex)
+#define BLOCK_WAIT_PROCESS_URC_MSG() pthread_cond_wait(&s_WaitProcessUrcMsgCond, &s_ProcessUrcMsgBlockMutex)
+#define BLOCK_WAKEUP_PROCESS_URC_MSG() pthread_cond_broadcast(&s_WaitProcessUrcMsgCond)
+static std::list<Parcel*> s_recv_urc_parcel_list;
+void *thread_urc_process(void *p);
+pthread_t module_urc_process_tid = -1;
+int module_urc_process_status = 1;
+/*hq add for urc process asynchronous 2022/12/26 end*/
+
int g_module_Global_uToken = 0;
int g_wait_time=5;
@@ -118,7 +139,7 @@
std::list<Parcel*>::iterator iter;
int cnt=0;
- gettimeofday(&now,NULL);
+ gettimeofday(&now,NULL);
timeout.tv_sec = now.tv_sec+time_out; //timeout is 1min
timeout.tv_nsec = now.tv_usec*1000;
@@ -268,6 +289,295 @@
return ret;
}
+/*hq add for urc broadcase optimisson 2023/01/03 begin*/
+#define SHM_BUFFER_INDEX_OFFSET 1
+#define SHM_BUFFER_SIZE_OFFSET 16
+#define SHM_BUFFER_INDEX_MASK 0x0000007F
+#define SHM_BUFFER_SIZE_MASK 0x0000FFFF
+
+bool urc_data_is_in_shm_data(int responseType,int& level, int& index, int& size)
+{
+ int shm_index=((responseType>>SHM_BUFFER_INDEX_OFFSET)&SHM_BUFFER_INDEX_MASK);
+ if (shm_index>0)
+ {
+ index=shm_index-1;
+ size=((responseType>>SHM_BUFFER_SIZE_OFFSET)&SHM_BUFFER_SIZE_MASK);
+ if(size>=sizeof(int32_t)*3 && get_shem_buffer_level(size,&level))
+ {
+ LYINFLOG("urc_data_is_in_shm_data level is %d, index is %d size is %d",level,index,size);
+ return true;
+ }
+ }
+ LYINFLOG("urc_data_is_in_shm_data return false, responseType is %d",responseType);
+ return false;
+}
+/*hq add for urc broadcase optimisson 2023/01/03 end*/
+
+void *thread_urc_recv(void *p)
+{
+ Parcel *urc_p =NULL;
+ char urc_data[LYNQ_REC_BUF];
+ int res = 0;
+ lynq_head_t* phead;
+ int level,index,size;
+ uint8_t * shm_buffer;
+
+ LYINFLOG("urc recv thread is running");
+ while(module_urc_status)
+ {
+ bzero(urc_data,LYNQ_REC_BUF);
+ res = recvfrom(module_urc_sock_fd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&module_urc_addr_serv,(socklen_t*)&module_len_urc_addr_serv);
+ if(res<sizeof(int32_t)*2)
+ {
+ LYERRLOG("thread_urc_recv step2 fail: res is %d",res);
+ continue;
+ }
+
+ phead=(lynq_head_t*) urc_data;
+ if(is_support_urc(phead->urcid)==false)
+ {
+ continue;
+ }
+ urc_p = new Parcel();
+ if(urc_p == NULL)
+ {
+ LYERRLOG("new parcel failure!!!");
+ continue;
+ }
+ if(urc_data_is_in_shm_data(phead->resp_type,level,index,size))
+ {
+ shm_buffer = (uint8_t *) get_shem_buffer(level,index);
+ LYINFLOG("shm pointer is %p", shm_buffer);
+ urc_p->setData(shm_buffer,size); // p.setData((uint8_t *) buffer, buflen);
+ }
+ else if(res>=sizeof(int32_t)*3)
+ {
+ urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
+ }
+ else
+ {
+ LYERRLOG("res %d error!!!", res);
+ delete urc_p;
+ urc_p = NULL;
+ continue;
+ }
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ BLOCK_PROCESS_URC_MSG_LOCK();
+ s_recv_urc_parcel_list.push_back(urc_p);
+ BLOCK_WAKEUP_PROCESS_URC_MSG();
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+ }
+ else
+ {
+ delete urc_p;
+ urc_p = NULL;
+ }
+ }
+ LYINFLOG("urc recv thread ended");
+ return NULL;
+}
+
+void cleanup_urc_process_mutex(void *arg)
+{
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+}
+
+void *thread_urc_process(void *p)
+{
+ Parcel *urc_p =NULL;
+ std::list<Parcel*>::iterator iter;
+
+ LYINFLOG("urc process thread is running");
+ pthread_cleanup_push(cleanup_urc_process_mutex, NULL); // thread cleanup handler
+ while(module_urc_process_status)
+ {
+ BLOCK_PROCESS_URC_MSG_LOCK();
+ while(s_recv_urc_parcel_list.empty())
+ {
+ BLOCK_WAIT_PROCESS_URC_MSG();
+ }
+ iter=s_recv_urc_parcel_list.begin();
+ urc_p=(*iter);
+ s_recv_urc_parcel_list.erase(iter);
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ pthread_mutex_lock(&s_urc_mutex);
+ urc_msg_process(urc_p);
+ pthread_mutex_unlock(&s_urc_mutex);
+ }
+ delete urc_p;
+ urc_p = NULL;
+ }
+ pthread_cleanup_pop(0);
+ LYINFLOG("urc process thread ended");
+ return NULL;
+}
+
+void lynq_close_urc_rev_thread()
+{
+ int ret;
+
+ BLOCK_PROCESS_URC_MSG_LOCK(); //just cancel urc process tid when recv from
+ module_urc_status = 0;
+ if(module_urc_tid!=-1)
+ {
+ ret = pthread_cancel(module_urc_tid);
+ LYINFLOG("pthread cancel urc rev ret = %d",ret);
+ }
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+ if(module_urc_tid != -1)
+ {
+ ret = pthread_join(module_urc_tid,NULL);
+ LYINFLOG("pthread join urc tid ret = %d",ret);
+ module_urc_tid =-1;
+ }
+}
+
+void lynq_close_urc_process_thread()
+{
+ int ret;
+ BLOCK_PROCESS_URC_MSG_LOCK(); //just cancel urc process tid when not process urc msg in list
+ pthread_mutex_lock(&s_urc_mutex); //just cancel urc process tid when not process urg msg avoid mutual lock for tid may call pthread_cond_wait
+ module_urc_process_status = 0;
+ if(module_urc_process_tid!=-1)
+ {
+ ret = pthread_cancel(module_urc_process_tid);
+ LYINFLOG("pthread cancel urc process ret = %d",ret);
+ }
+ pthread_mutex_unlock(&s_urc_mutex);
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+ if(module_urc_process_tid != -1)
+ {
+ ret = pthread_join(module_urc_process_tid,NULL);
+ LYINFLOG("pthread join urc process tid ret = %d",ret);
+ module_urc_process_tid =-1;
+ }
+}
+
+int lynq_setup_urc_socket()
+{
+ int on = 1;
+ int ret = 0;
+ module_len_urc_addr_serv = sizeof(sockaddr_in);
+ module_urc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if (module_urc_sock_fd <0){
+ LYERRLOG("urc socket error");
+ return RESULT_ERROR;
+ }
+ module_urc_addr_serv.sin_family = AF_INET;
+ module_urc_addr_serv.sin_port = htons(LYNQ_URC_SERVICE_PORT);
+ module_urc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_URC_ADDRESS);
+ /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
+ ret = setsockopt(module_urc_sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
+ if(ret <0)
+ {
+ LYERRLOG("urc socket set error");
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ return RESULT_ERROR;
+ }
+ ret = bind(module_urc_sock_fd ,(struct sockaddr*)&module_urc_addr_serv, sizeof(module_urc_addr_serv));
+ if(ret <0)
+ {
+ LYERRLOG("urc socket bind error");
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ return RESULT_ERROR;
+ }
+ return RESULT_OK;
+}
+
+void lynq_close_urc_socket()
+{
+ if (module_urc_sock_fd >= 0)
+ {
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ }
+}
+
+int lynq_start_all_urc_socket_thread()
+{
+
+ if(ril_init_mem()!=0)
+ {
+ LYERRLOG("ril_init_mem fail");
+ return RESULT_ERROR;
+ }
+
+ int ret= lynq_setup_urc_socket();
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("call lynq_setup_urc_socket fail");
+ ril_deinit_mem();
+ return RESULT_ERROR;
+ }
+
+ BLOCK_PROCESS_URC_MSG_INIT();
+ BLOCK_PROCESS_URC_MSG_LOCK();
+ std::list<Parcel*>::iterator iter;
+ for(iter=s_recv_urc_parcel_list.begin();iter!=s_recv_urc_parcel_list.end();++iter)
+ {
+ delete (*iter);
+ }
+ s_recv_urc_parcel_list.clear();
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+
+ pthread_mutex_init(&s_urc_mutex, NULL);
+
+ module_urc_status = 1;
+ // pthread_attr_init(&attr);
+ // pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ ret = pthread_create(&module_urc_tid,/*&attr*/NULL,thread_urc_recv,NULL);
+ if(ret <0)
+ {
+ LYERRLOG("urc recv pthread create error");
+ module_urc_status = 0;
+ lynq_close_urc_socket();
+ ril_deinit_mem();
+ return RESULT_ERROR;
+ }
+
+ module_urc_process_status = 1;
+ ret = pthread_create(&module_urc_process_tid,/*&attr*/NULL,thread_urc_process,NULL);
+ if(ret <0)
+ {
+ LYERRLOG("urc process pthread create error");
+ module_urc_process_status = 0;
+ lynq_close_urc_socket();
+ lynq_close_urc_rev_thread();
+ ril_deinit_mem();
+ return RESULT_ERROR;
+ }
+
+ LYINFLOG("urc start success");
+
+ return RESULT_OK;
+}
+
+void lynq_close_all_urc_socket_thread()
+{
+
+ lynq_close_urc_rev_thread();
+ lynq_close_urc_socket();
+ lynq_close_urc_process_thread();
+
+ BLOCK_PROCESS_URC_MSG_LOCK();
+ std::list<Parcel*>::iterator iter;
+ for(iter=s_recv_urc_parcel_list.begin();iter!=s_recv_urc_parcel_list.end();++iter)
+ {
+ delete (*iter);
+ }
+ s_recv_urc_parcel_list.clear();
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+
+ ril_deinit_mem();
+}
+
/**@ a thread just for recv\buffer solicited msg's response and notice waiting thread
* @param p [IN]: no meaning
* @return
@@ -347,44 +657,7 @@
return NULL;
}
-void *thread_urc_recv(void *p)
-{
- Parcel *urc_p =NULL;
- char urc_data[LYNQ_REC_BUF];
- int res = 0;
-
- LYINFLOG("urc thread is running");
- while(module_urc_status)
- {
- bzero(urc_data,LYNQ_REC_BUF);
- res = recvfrom(module_urc_sock_fd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&module_urc_addr_serv,(socklen_t*)&module_len_urc_addr_serv);
- if(res<=0)
- {
- LYERRLOG("thread_urc_recv step2 fail:");
- break;
- }
- urc_p = new Parcel();
- if(urc_p == NULL)
- {
- LYERRLOG("new parcel failure!!!");
- break;
- }
- urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
- urc_p->setDataPosition(0);
- if(urc_p->dataAvail()>0)
- {
- pthread_mutex_lock(&s_urc_mutex);
- urc_msg_process(urc_p);
- pthread_mutex_unlock(&s_urc_mutex);
- }
- delete urc_p;
- urc_p = NULL;
- }
- LYINFLOG("urc thread ended");
- return NULL;
-}
-
-int lynq_server_socket_start()
+int lynq_start_all_rc_socket_thread()
{
module_rc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
if(module_rc_sock_fd < 0)
@@ -434,87 +707,12 @@
return RESULT_OK;
}
-int lynq_urc_socket_start()
-{
-// pthread_t tid;
-// pthread_attr_t attr;
- int on = 1;
- int ret = 0;
- module_len_urc_addr_serv = sizeof(sockaddr_in);
- module_urc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
- if (module_urc_sock_fd <0){
- LYERRLOG("urc socket error");
- return RESULT_ERROR;
- }
- module_urc_addr_serv.sin_family = AF_INET;
- module_urc_addr_serv.sin_port = htons(LYNQ_URC_SERVICE_PORT);
- module_urc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_URC_ADDRESS);
- /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
- ret = setsockopt(module_urc_sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
- if(ret <0)
- {
- LYERRLOG("urc socket set error");
- close(module_urc_sock_fd);
- module_urc_sock_fd =-1;
- return RESULT_ERROR;
- }
- ret = bind(module_urc_sock_fd ,(struct sockaddr*)&module_urc_addr_serv, sizeof(module_urc_addr_serv));
- if(ret <0)
- {
- LYERRLOG("urc socket bind error");
- close(module_urc_sock_fd);
- module_urc_sock_fd =-1;
- return RESULT_ERROR;
- }
-
- module_urc_status = 1;
- // pthread_attr_init(&attr);
- // pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- ret = pthread_create(&module_urc_tid,/*&attr*/NULL,thread_urc_recv,NULL);
- if(ret <0)
- {
- LYERRLOG("urc pthread create error");
- module_urc_status = 0;
- close(module_urc_sock_fd);
- module_urc_sock_fd =-1;
- return RESULT_ERROR;
- }
- LYINFLOG("urc start success");
-
- return RESULT_OK;
-}
-
-void lynq_close_urc_thread()
-{
- int ret;
-
- pthread_mutex_lock(&s_urc_mutex); //just cancel urc tid when recvfrom avoid mutual lock for tid may call pthread_cond_wait
- module_urc_status = 0;
- if(module_urc_tid!=-1)
- {
- ret = pthread_cancel(module_urc_tid);
- LYINFLOG("pthread cancel urc ret = %d",ret);
- }
- pthread_mutex_unlock(&s_urc_mutex);
- if(module_urc_tid != -1)
- {
- ret = pthread_join(module_urc_tid,NULL);
- LYINFLOG("pthread join urc tid ret = %d",ret);
- module_urc_tid =-1;
- }
- if (module_urc_sock_fd > 0)
- {
- close(module_urc_sock_fd);
- module_urc_sock_fd =-1;
- }
-}
-
-void lynq_close_rc_thread()
+void lynq_close_all_rc_socket_thread()
{
int ret;
BLOCK_RECV_MSG_LOCK();
- module_rc_status = 0;
- BLOCK_WAKEUP_RECV_MSG();
+ module_rc_status = 0;
+ BLOCK_WAKEUP_RECV_MSG();
if(module_rc_tid != -1)
{
ret = pthread_cancel(module_rc_tid);
@@ -523,11 +721,11 @@
BLOCK_RECV_MSG_UNLOCK();
if(module_rc_tid != -1)
{
- ret = pthread_join(module_rc_tid,NULL);
+ ret = pthread_join(module_rc_tid,NULL);
module_rc_tid =-1;
- LYINFLOG("pthread join rc tid ret = %d",ret);
- }
-
+ LYINFLOG("pthread join rc tid ret = %d",ret);
+
+ }
if (module_rc_sock_fd > 0)
{
@@ -545,3 +743,273 @@
BLOCK_RECV_MSG_UNLOCK();
}
+const char * requestToString(int request)
+{
+ /*
+ cat libs/telephony/ril_commands.h \
+ | egrep "^ *{RIL_" \
+ | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/'
+
+
+ cat libs/telephony/ril_unsol_commands.h \
+ | egrep "^ *{RIL_" \
+ | sed -re 's/\{RIL_([^,]+),([^}]+).+/case RIL_\1: return "\1";/'
+
+ */
+ switch(request) {
+ case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS";
+ case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN";
+ case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK";
+ case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2";
+ case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2";
+ case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN";
+ case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2";
+ case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION";
+ case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS";
+ case RIL_REQUEST_DIAL: return "DIAL";
+ case RIL_REQUEST_GET_IMSI: return "GET_IMSI";
+ case RIL_REQUEST_HANGUP: return "HANGUP";
+ case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND";
+ case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND";
+ case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "SWITCH_WAITING_OR_HOLDING_AND_ACTIVE";
+ case RIL_REQUEST_CONFERENCE: return "CONFERENCE";
+ case RIL_REQUEST_UDUB: return "UDUB";
+ case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE";
+ case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH";
+ case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE";
+ case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE";
+ case RIL_REQUEST_OPERATOR: return "OPERATOR";
+ case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER";
+ case RIL_REQUEST_DTMF: return "DTMF";
+ case RIL_REQUEST_SEND_SMS: return "SEND_SMS";
+ case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE";
+ case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL";
+ case RIL_REQUEST_SIM_IO: return "SIM_IO";
+ case RIL_REQUEST_SEND_USSD: return "SEND_USSD";
+ case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD";
+ case RIL_REQUEST_GET_CLIR: return "GET_CLIR";
+ case RIL_REQUEST_SET_CLIR: return "SET_CLIR";
+ case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS";
+ case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD";
+ case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING";
+ case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING";
+ case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE";
+ case RIL_REQUEST_GET_IMEI: return "GET_IMEI";
+ case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV";
+ case RIL_REQUEST_ANSWER: return "ANSWER";
+ case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL";
+ case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK";
+ case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK";
+ case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD";
+ case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE";
+ case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC";
+ case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL";
+ case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS ";
+ case RIL_REQUEST_DTMF_START: return "DTMF_START";
+ case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP";
+ case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION";
+ case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION";
+ case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "SET_PREFERRED_NETWORK_TYPE";
+ case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "GET_PREFERRED_NETWORK_TYPE";
+ case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "GET_NEIGHBORING_CELL_IDS";
+ case RIL_REQUEST_SET_MUTE: return "SET_MUTE";
+ case RIL_REQUEST_GET_MUTE: return "GET_MUTE";
+ case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP";
+ case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE";
+ case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST";
+ case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO";
+ case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW";
+ case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS";
+ case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE";
+ case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE";
+ case RIL_REQUEST_STK_GET_PROFILE: return "STK_GET_PROFILE";
+ case RIL_REQUEST_STK_SET_PROFILE: return "STK_SET_PROFILE";
+ case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "STK_SEND_ENVELOPE_COMMAND";
+ case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "STK_SEND_TERMINAL_RESPONSE";
+ case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
+ case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE";
+ case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "EXPLICIT_CALL_TRANSFER";
+ case RIL_REQUEST_SET_LOCATION_UPDATES: return "SET_LOCATION_UPDATES";
+ case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:return"CDMA_SET_SUBSCRIPTION_SOURCE";
+ case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:return"CDMA_SET_ROAMING_PREFERENCE";
+ case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:return"CDMA_QUERY_ROAMING_PREFERENCE";
+ case RIL_REQUEST_SET_TTY_MODE:return"SET_TTY_MODE";
+ case RIL_REQUEST_QUERY_TTY_MODE:return"QUERY_TTY_MODE";
+ case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE";
+ case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE";
+ case RIL_REQUEST_CDMA_FLASH:return"CDMA_FLASH";
+ case RIL_REQUEST_CDMA_BURST_DTMF:return"CDMA_BURST_DTMF";
+ case RIL_REQUEST_CDMA_SEND_SMS:return"CDMA_SEND_SMS";
+ case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE:return"CDMA_SMS_ACKNOWLEDGE";
+ case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:return"GSM_GET_BROADCAST_SMS_CONFIG";
+ case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:return"GSM_SET_BROADCAST_SMS_CONFIG";
+ case RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION:return "GSM_SMS_BROADCAST_ACTIVATION";
+ case RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG:return "CDMA_GET_BROADCAST_SMS_CONFIG";
+ case RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG:return "CDMA_SET_BROADCAST_SMS_CONFIG";
+ case RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION:return "CDMA_SMS_BROADCAST_ACTIVATION";
+ case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return"CDMA_VALIDATE_AND_WRITE_AKEY";
+ case RIL_REQUEST_CDMA_SUBSCRIPTION: return"CDMA_SUBSCRIPTION";
+ case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "CDMA_WRITE_SMS_TO_RUIM";
+ case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "CDMA_DELETE_SMS_ON_RUIM";
+ case RIL_REQUEST_DEVICE_IDENTITY: return "DEVICE_IDENTITY";
+ case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "EXIT_EMERGENCY_CALLBACK_MODE";
+ case RIL_REQUEST_GET_SMSC_ADDRESS: return "GET_SMSC_ADDRESS";
+ case RIL_REQUEST_SET_SMSC_ADDRESS: return "SET_SMSC_ADDRESS";
+ case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "REPORT_SMS_MEMORY_STATUS";
+ case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "REPORT_STK_SERVICE_IS_RUNNING";
+ case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "CDMA_GET_SUBSCRIPTION_SOURCE";
+ case RIL_REQUEST_ISIM_AUTHENTICATION: return "ISIM_AUTHENTICATION";
+ case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU";
+ case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS";
+ case RIL_REQUEST_VOICE_RADIO_TECH: return "VOICE_RADIO_TECH";
+ case RIL_REQUEST_GET_CELL_INFO_LIST: return"GET_CELL_INFO_LIST";
+ case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: return"SET_UNSOL_CELL_INFO_LIST_RATE";
+ case RIL_REQUEST_SET_INITIAL_ATTACH_APN: return "RIL_REQUEST_SET_INITIAL_ATTACH_APN";
+ case RIL_REQUEST_IMS_REGISTRATION_STATE: return "IMS_REGISTRATION_STATE";
+ case RIL_REQUEST_IMS_SEND_SMS: return "IMS_SEND_SMS";
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: return "SIM_TRANSMIT_APDU_BASIC";
+ case RIL_REQUEST_SIM_OPEN_CHANNEL: return "SIM_OPEN_CHANNEL";
+ case RIL_REQUEST_SIM_CLOSE_CHANNEL: return "SIM_CLOSE_CHANNEL";
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: return "SIM_TRANSMIT_APDU_CHANNEL";
+ case RIL_REQUEST_GET_RADIO_CAPABILITY: return "RIL_REQUEST_GET_RADIO_CAPABILITY";
+ case RIL_REQUEST_SET_RADIO_CAPABILITY: return "RIL_REQUEST_SET_RADIO_CAPABILITY";
+ case RIL_REQUEST_SET_UICC_SUBSCRIPTION: return "SET_UICC_SUBSCRIPTION";
+ case RIL_REQUEST_ALLOW_DATA: return "ALLOW_DATA";
+ case RIL_REQUEST_GET_HARDWARE_CONFIG: return "GET_HARDWARE_CONFIG";
+ case RIL_REQUEST_SIM_AUTHENTICATION: return "SIM_AUTHENTICATION";
+ case RIL_REQUEST_GET_DC_RT_INFO: return "GET_DC_RT_INFO";
+ case RIL_REQUEST_SET_DC_RT_INFO_RATE: return "SET_DC_RT_INFO_RATE";
+ case RIL_REQUEST_SET_DATA_PROFILE: return "SET_DATA_PROFILE";
+ case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
+ case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
+ case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
+ case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
+ case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS";
+ case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
+ case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
+ case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD";
+ case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
+ case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
+ case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
+ case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
+ case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
+ case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
+ case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
+ case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL";
+ case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
+ case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
+ case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
+ case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
+ case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS";
+ case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_NEW_BROADCAST_SMS";
+ case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL";
+ case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED";
+ case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE";
+ case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING";
+ case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS";
+ case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC";
+ case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW";
+ case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE";
+ case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE";
+ case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED";
+ case RIL_UNSOL_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED";
+ case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE";
+ case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED";
+ case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED";
+ case RIL_UNSOL_CELL_INFO_LIST: return "UNSOL_CELL_INFO_LIST";
+ case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: return "RESPONSE_IMS_NETWORK_STATE_CHANGED";
+ case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: return "UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED";
+ case RIL_UNSOL_SRVCC_STATE_NOTIFY: return "UNSOL_SRVCC_STATE_NOTIFY";
+ case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "HARDWARE_CONFIG_CHANGED";
+ case RIL_UNSOL_DC_RT_INFO_CHANGED: return "UNSOL_DC_RT_INFO_CHANGED";
+ case RIL_REQUEST_SHUTDOWN: return "SHUTDOWN";
+ case RIL_UNSOL_RADIO_CAPABILITY: return "RIL_UNSOL_RADIO_CAPABILITY";
+ case RIL_REQUEST_SET_TRM: return "RIL_REQUEST_SET_TRM";
+ case RIL_REQUEST_SET_IMS_ENABLE:return "RIL_REQUEST_SET_IMS_ENABLE";
+ case RIL_REQUEST_SET_AUDIO_PATH: return "SET_AUDIO_PATH";
+ case RIL_REQUEST_HANGUP_ALL: return "HANGUP_ALL";
+ case RIL_REQUEST_FORCE_RELEASE_CALL: return "FORCE_RELEASE_CALL";
+ case RIL_REQUEST_EMERGENCY_DIAL: return "RIL_REQUEST_EMERGENCY_DIAL";
+ case RIL_REQUEST_SET_ECC_SERVICE_CATEGORY: return "RIL_REQUEST_SET_ECC_SERVICE_CATEGORY";
+ case RIL_REQUEST_SET_ECC_LIST: return "RIL_REQUEST_SET_ECC_LIST";
+ case RIL_REQUEST_AT_COMMAND_WITH_PROXY: return "AT_COMMAND_WITH_PROXY";
+ case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION: return "RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION";
+ case RIL_REQUEST_SET_CLIP: return "RIL_REQUEST_SET_CLIP";
+ case RIL_REQUEST_GET_COLP: return "RIL_REQUEST_GET_COLP";
+ case RIL_REQUEST_SET_COLP: return "RIL_REQUEST_SET_COLP";
+ case RIL_REQUEST_GET_COLR: return "RIL_REQUEST_GET_COLR";
+ case RIL_REQUEST_ADD_IMS_CONFERENCE_CALL_MEMBER: return "ADD_IMS_CONFERENCE_CALL_MEMBER";
+ case RIL_REQUEST_REMOVE_IMS_CONFERENCE_CALL_MEMBER: return "REMOVE_IMS_CONFERENCE_CALL_MEMBER";
+ case RIL_REQUEST_CONFERENCE_DIAL: return "CONFERENCE_DIAL";
+ case RIL_REQUEST_DIAL_WITH_SIP_URI: return "DIAL_WITH_SIP_URI";
+ case RIL_REQUEST_HOLD_CALL: return "HOLD_CALL";
+ case RIL_REQUEST_RESUME_CALL: return "RESUME_CALL";
+ case RIL_UNSOL_ECONF_SRVCC_INDICATION : return "ECONF_SRVCC_INDICATION";
+ case RIL_UNSOL_ECONF_RESULT_INDICATION : return "ECONF_RESULT_INDICATION";
+ case RIL_UNSOL_MAL_AT_INFO : return "UNSOL_MAL_AT_INFO";
+ case RIL_REQUEST_MODEM_POWEROFF: return "MODEM_POWEROFF";
+ case RIL_REQUEST_MODEM_POWERON: return "MODEM_POWERON";
+ case RIL_REQUEST_WRITE_SMS_TO_SIM: return "WRITE_SMS_TO_SIM";
+ case RIL_REQUEST_QUERY_ICCID: return "RIL_REQUEST_QUERY_ICCID";
+ case RIL_UNSOL_TX_POWER: return "RIL_UNSOL_TX_POWER";
+ case RIL_UNSOL_NETWORK_INFO: return "RIL_UNSOL_NETWORK_INFO";
+ case RIL_REQUEST_DELETE_SMS_ON_SIM: return "DELETE_SMS_ON_SIM";
+ case RIL_REQUEST_SET_IMSCFG: return "RIL_REQUEST_SET_IMSCFG";
+#ifdef ECALL_SUPPORT
+ case RIL_REQUEST_ECALL_FAST_MAKE_ECALL: return "ECALL_FAST_MAKE_ECALL";
+ case RIL_REQUEST_ECALL_SET_IVS: return "RIL_REQUEST_ECALL_SET_IVS";
+ case RIL_REQUEST_ECALL_SET_PSAP: return "RIL_REQUEST_ECALL_SET_PSAP";
+ case RIL_REQUEST_ECALL_MAKE_ECALL: return "RIL_REQUEST_ECALL_MAKE_ECALL";
+ case RIL_REQUEST_ECALL_IVS_PUSH_MSD: return "RIL_REQUEST_ECALL_IVS_PUSH_MSD";
+ case RIL_REQUEST_ECALL_PSAP_PULL_MSD: return "RIL_REQUEST_ECALL_PSAP_PULL_MSD";
+ case RIL_UNSOL_ECALL_MSDHACK : return "ECALL_MSDHACK";
+ case RIL_REQUEST_ECALL_SET_MSD: return "RIL_REQUEST_ECALL_SET_MSD";
+ case RIL_REQUEST_ECALL_CTRL_SEQUENCE: return "ECALL_SET_CTRL_SEQUENCE";
+ case RIL_UNSOL_ECALL_INDICATIONS : return "ECALL_INDICATIONS";
+ case RIL_REQUEST_ECALL_RESET_IVS: return "RIL_REQUEST_ECALL_RESET_IVS";
+ case RIL_REQUEST_ECALL_SET_PRI: return "RIL_REQUEST_ECALL_SET_PRI";
+ case RIL_REQUEST_ECALL_SET_TEST_NUM: return "RIL_REQUEST_ECALL_SET_TEST_NUM";
+ case RIL_REQUEST_ECALL_SET_RECONF_NUM: return "RIL_REQUEST_ECALL_SET_RECONF_NUM";
+ case RIL_REQUEST_SYNC_DATA_SETTINGS_TO_MD: return "RIL_REQUEST_SYNC_DATA_SETTINGS_TO_MD";
+ case RIL_REQUEST_ECALL_SET_NAD_DEREGISTRATION_TIME: return "RIL_REQUEST_ECALL_SET_NAD_DEREGISTRATION_TIME";
+ case RIL_REQUEST_ECALL_SET_REGISTRATION_STATE: return "RIL_REQUEST_ECALL_SET_REGISTRATION_STATE";
+#endif /*ECALL_SUPPORT*/
+#ifdef KEEP_ALIVE
+ case RIL_REQUEST_START_KEEPALIVE_PRO: return "RIL_REQUEST_START_KEEPALIVE_PRO";
+ case RIL_REQUEST_STOP_KEEPALIVE_PRO: return "RIL_REQUEST_STOP_KEEPALIVE_PRO";
+ case RIL_UNSOL_KEEPALIVE_STATUS_PRO: return "RIL_UNSOL_KEEPALIVE_STATUS_PRO";
+#endif /*KEEP_ALIVE*/
+ case RIL_REQUEST_SEND_USSI: return "SEND_USSI";
+ case RIL_REQUEST_CANCEL_USSI: return "CANCEL_USSI";
+ case RIL_REQUEST_GET_SMS_SIM_MEM_STATUS: return "GET_SMS_SIM_MEM_STATUS";
+ case RIL_UNSOL_SIP_CALL_PROGRESS_INDICATOR: return "RIL_UNSOL_SIP_CALL_PROGRESS_INDICATOR";
+ case RIL_REQUEST_REPORT_AIRPLANE_MODE: return "RIL_REQUEST_REPORT_AIRPLANE_MODE";
+ case RIL_REQUEST_SET_ECC_NUM: return "RIL_REQUEST_SET_ECC_NUM";
+ case RIL_REQUEST_GET_ECC_NUM: return "RIL_REQUEST_GET_ECC_NUM";
+ case RIL_UNSOL_ECC_NUM: return "RIL_UNSOL_ECC_NUM";
+ case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS_WITH_ACT: return "RIL_REQUEST_QUERY_AVAILABLE_NETWORKS_WITH_ACT";
+ case RIL_REQUEST_GSM_GET_BROADCAST_LANGUAGE: return "RIL_REQUEST_GSM_GET_BROADCAST_LANGUAGE";
+ case RIL_REQUEST_GSM_SET_BROADCAST_LANGUAGE: return "RIL_REQUEST_GSM_SET_BROADCAST_LANGUAGE";
+ case RIL_UNSOL_CALL_INFO_INDICATION: return "RIL_UNSOL_CALL_INFO_INDICATION";
+ case RIL_REQUEST_MODIFY_APN: return "RIL_REQUEST_MODIFY_APN";
+ case RIL_REQUEST_RESET_APN: return "RIL_REQUEST_RESET_APN";
+ case RIL_REQUEST_QUERY_SIM_RETRY_COUNT: return "RIL_REQUEST_QUERY_SIM_RETRY_COUNT";
+ case RIL_REQUEST_QUERY_EID: return "RIL_REQUEST_QUERY_EID";
+ case LYNQ_REQUEST_SET_DTMF_VOLUME: return "RIL_REQUEST_SET_DTMF_VOLUME";
+ case LYNQ_REQUEST_SET_SPEECH_VOLUME: return "RIL_REQUEST_SET_SPEECH_VOLUME";
+ case LYNQ_REQUEST_GET_SPEECH_VOLUME: return "RIL_REQUEST_GET_SPEECH_VOLUME";
+ case LYNQ_REQUEST_RECORD: return "RIL_REQUEST_RECORD";
+ /*warren add for t800 ril service 2022/1/22 start*/
+ case LYNQ_REQUEST_WRITE_SMS_TO_MEMORY: return "LYNQ_REQUEST_WRITE_SMS_TO_MEMORY";
+ case LYNQ_REQUEST_READ_SMS_FROM_MEMORY: return "LYNQ_REQUEST_READ_SMS_FROM_MEMORY";
+ case LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY: return "LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY";
+ case LYNQ_REQUEST_LIST_SMS_FROM_MEMORY: return "LYNQ_REQUEST_LIST_SMS_FROM_MEMORY";
+ case LYNQ_REQUEST_SET_DEFAULT_SIM_ALL:return "SET_DEFAULT_SIM_ALL";
+ case LYNQ_REQUEST_CHANGE_SCREEN_STATE:return "LYNQ_REQUEST_CHANGE_SCREEN_STATE";/*jb.qi add for two sim sleep 2022/9/19*/
+ case LYNQ_REQUEST_CHANGE_RADIO:return "LYNQ_REQUEST_CHANGE_RADIO";/*lei add for factory test of sleep 2022/9/19*/
+ /*warren add for t800 ril service 2022/1/22 end*/
+ default: return "<unknown request>";
+ }
+}
+
+
diff --git a/src/lynq/lib/liblynq-call/lynq_module_socket.h b/src/lynq/lib/liblynq-call/lynq_module_socket.h
index 57466f6..41c0d1c 100755
--- a/src/lynq/lib/liblynq-call/lynq_module_socket.h
+++ b/src/lynq/lib/liblynq-call/lynq_module_socket.h
@@ -4,15 +4,18 @@
using ::android::Parcel;
int lynq_set_test_network(const int test_mode);
-int lynq_send_common_request(Parcel*& p, int time_out, int request_id, int argc, const char* format,...);
-int lynq_server_socket_start();
-int lynq_urc_socket_start();
-void lynq_close_urc_thread();
-void lynq_close_rc_thread();
extern int g_module_Global_uToken;
extern int g_wait_time;
+int lynq_send_common_request(Parcel*& p, int time_out, int request_id, int argc, const char* format,...);
+int lynq_start_all_urc_socket_thread();
+void lynq_close_all_urc_socket_thread();
+int lynq_start_all_rc_socket_thread();
+void lynq_close_all_rc_socket_thread();
+
+const char * requestToString(int request);
void urc_msg_process(Parcel *p);
+bool is_support_urc(int urc_id);
#endif
diff --git a/src/lynq/lib/liblynq-call/makefile b/src/lynq/lib/liblynq-call/makefile
index 0e021c5..40415dc 100755
--- a/src/lynq/lib/liblynq-call/makefile
+++ b/src/lynq/lib/liblynq-call/makefile
@@ -23,6 +23,7 @@
-I$(ROOT)$(includedir)/logger \
-I$(ROOT)$(includedir)/liblog \
-I$(ROOT)$(includedir)/vendor-ril \
+ -I$(ROOT)$(includedir)/lynq_shm \
LOCAL_LIBS := \
@@ -35,7 +36,7 @@
-lbinder \
-lpthread \
-llynq-log \
-
+ -llynq-shm \
SOURCES = $(wildcard *.cpp)
diff --git a/src/lynq/lib/liblynq-data/lynq_data.cpp b/src/lynq/lib/liblynq-data/lynq_data.cpp
index 5473fb2..fbd120d 100755
--- a/src/lynq/lib/liblynq-data/lynq_data.cpp
+++ b/src/lynq/lib/liblynq-data/lynq_data.cpp
@@ -15,8 +15,10 @@
#include <sys/time.h>
#include <include/lynq_uci.h>
#include <errno.h>
+#include <vector>
+#include "lynq_data_urc.h"
+
#define LYNQ_SERVICE_PORT 8088
-#define LYNQ_URC_SERVICE_PORT 8086
#define LYNQ_REC_BUF 8192
#define LYNQ_REQUEST_PARAM_BUF 8192
#define LYQN_SEDN_BUF 1024*8+sizeof(int)*3
@@ -24,9 +26,6 @@
#define LYNQ_DATA_UCI_BUF 258
-
-
-
using ::android::Parcel;
typedef struct{
int uToken;
@@ -56,16 +55,19 @@
int lynq_client_sockfd = 0;
int Global_uToken = 0;
-bool data_urc_recive_status = 1;
+
int lynq_data_call_change_id = -1;
pthread_t lynq_data_tid =-1;
static pthread_mutex_t s_data_call_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_data_call_state_change_cond = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t s_pdn_change_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t s_pdn_change_cond = PTHREAD_COND_INITIALIZER;
+
static pthread_mutex_t s_lynq_apn_change_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_lynq_apn_change_cond = PTHREAD_COND_INITIALIZER;
+pthread_t data_list_urc_vector_tid = -1;
+int data_urc_vector_status = 0;
+static pthread_mutex_t s_lynq_urc_vector_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_lynq_urc_vector_cond = PTHREAD_COND_INITIALIZER;
/**g_lynq_data_sendto_mutex
* @brief mark data send request mutex
*/
@@ -82,6 +84,8 @@
*/
char g_lynq_apn_result[1024] = {};
+static std::vector<int> s_data_urc_wait_list;
+
typedef struct
{
char apn[LYNQ_APN_MAX_LEN];
@@ -93,16 +97,7 @@
lynq_apn_t lynq_apn_table[LYNQ_APN_CHANNEL_MAX] = {};
lynq_data_call_response_v11_t lynq_data_call_lists[LYNQ_APN_CHANNEL_MAX] = {};
int lynq_data_call = 0;
-int millli_sleep_with_restart(int millisecond)
-{
- int left = millisecond*1000;
- while (left > 0)
- {
- left = usleep(left);
- }
- return 0;
-}
int getLynqApnID(char apnType[])
{
int ret = 0;
@@ -115,6 +110,7 @@
}
return -1;
}
+
void updateApnTable(lynq_apn_t *apn_table,char apn[],char apntype[],char ifaceName[])
{
LYDBGLOG("[updateApnTable] apn:%s,apntype:%s,ifaceName:%s",apn,apntype,ifaceName);
@@ -130,6 +126,7 @@
apn_table->hasUsed = 1;
return;
}
+
void cleanOnceApnTable(int apnId)
{
LYDBGLOG("apn id:%d",apnId);
@@ -207,9 +204,9 @@
int waitPdnChange()
{
int ret = 0;
- pthread_mutex_lock(&s_pdn_change_mutex);
- ret = pthread_cond_wait(&s_pdn_change_cond,&s_pdn_change_mutex);
- pthread_mutex_unlock(&s_pdn_change_mutex);
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ ret = pthread_cond_wait(&s_lynq_urc_vector_cond,&s_lynq_urc_vector_mutex);
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
return ret;
}
int waitDataCallstateChange(int mtime)
@@ -238,9 +235,9 @@
}
void sendSignalPdnChange()
{
- pthread_mutex_lock(&s_pdn_change_mutex);
- pthread_cond_signal(&s_pdn_change_cond);
- pthread_mutex_unlock(&s_pdn_change_mutex);
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ pthread_cond_signal(&s_lynq_urc_vector_cond);
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
return;
}
@@ -301,7 +298,6 @@
return strndup16to8(s16, stringlen);
}
-
/*Warren add for T800 platform 2021/11/19 start*/
int lynq_socket_client_start()
{
@@ -335,144 +331,146 @@
}
return 0;
}
-void *thread_urc_recv(void *parg)
+
+bool is_support_urc(int urc_id)
{
- int socket_fd = (int64_t)parg;
- int len=0;
- socklen_t addr_len=0;
- uint8_t *dataLength = NULL;
- char urc_data[LYNQ_REC_BUF];
+ switch(urc_id)
+ {
+ case LYNQ_URC_DATA_CALL_STATUS_IND:
+
+ case LYNQ_URC_MODIFY_APNDB:
+ case LYNQ_URC_RESET_APNDB:
+ return true;
+ default:
+ return false;
+ }
+}
+
+void urc_msg_process(Parcel *p)
+{
+ int len;
+ int resp_type;
+ int urcid;
+ int slot_id;
+
+ int pdnState = 0;
char apn[LYNQ_APN_MAX_LEN];
char apnType[LYNQ_APN_TYPE_MAX_LEN];
- int pdnState = 0;
char ifaceName[LYNQ_IFACE_NAME_MAX_LEN];
- int slot_id = -1;
- int resp_type = -1;
- int urcid = -1;
char *urc_msg = NULL;
- Parcel *p = NULL;
- struct sockaddr_in dest_addr;
- LYINFLOG("thread_urc_recv in running....\n");
- while(data_urc_recive_status)
+
+ int size = p->dataSize();
+ p->readInt32(&resp_type);
+ p->readInt32(&urcid);
+ p->readInt32(&slot_id);
+ LYINFLOG("data lib recv urc:resp_type=%d,urcid=%d,slot_id=%d,size=%d\n",resp_type,urcid,slot_id,size);
+ switch(urcid)
{
- bzero(urc_data,LYNQ_REC_BUF);
- //get data msg
- len = recvfrom(socket_fd,urc_data,LYNQ_REC_BUF,0,(struct sockaddr *)&dest_addr,&addr_len);
- if(len <= 0)
- {
- perror("thread_urc_recv step2 fail:");
- millli_sleep_with_restart(1);
- break;
- }
- LYDBGLOG("=====>urc data len<=====:%d\n",len);
- p = new Parcel();
- if(p==NULL)
- {
- RLOGD("new parcel failure!!!");
- break;
- }
- p->setData((uint8_t *)urc_data,len); // p.setData((uint8_t *) buffer, buflen);
- p->setDataPosition(0);
- if(p->dataAvail() > 0)
- {
- p->readInt32(&resp_type);
- p->readInt32(&urcid);
- p->readInt32(&slot_id);
- //LYDBGLOG("*******Warren test*******:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
- switch (urcid)
+ case LYNQ_URC_DATA_CALL_STATUS_IND:
+ p->readInt32(&pdnState);
+ bzero(apn,LYNQ_APN_MAX_LEN);
+ bzero(apnType,LYNQ_APN_TYPE_MAX_LEN);
+ bzero(ifaceName,LYNQ_IFACE_NAME_MAX_LEN);
+ if(pdnState!=4)//PDN_DISCONNECTED
{
- case 9003://LYNQ_URC_DATA_CALL_STATUS_IND
- {
- LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
- p->readInt32(&pdnState);
- bzero(apn,LYNQ_APN_MAX_LEN);
- bzero(apnType,LYNQ_APN_TYPE_MAX_LEN);
- bzero(ifaceName,LYNQ_IFACE_NAME_MAX_LEN);
- if(pdnState!=4)//PDN_DISCONNECTED
- {
- urc_msg = strdupReadString_p(p);
- int len = strlen(urc_msg);
- if(len < LYNQ_APN_MAX_LEN-1)
- {
- memcpy(apn,urc_msg,len+1);
- }
- urc_msg = strdupReadString_p(p);
- len = strlen(urc_msg);
- if(len < LYNQ_APN_TYPE_MAX_LEN-1)
- {
- memcpy(apnType,urc_msg,len+1);
- }
- urc_msg = strdupReadString_p(p);
- len = strlen(urc_msg);
- if(len < LYNQ_IFACE_NAME_MAX_LEN-1)
- {
- memcpy(ifaceName,urc_msg,strlen(urc_msg)+1);
- }
- //sendSignalDataCallStateChange();
- int apnId = getLynqApnID(apnType);
- if(apnId >= 0)
- {
- if(lynq_apn_table[apnId].hasTimeout==1)
- {
- LYERRLOG("apn:%s has time out",lynq_apn_table[apnId].apn);
- lynq_deactive_data_call(&apnId);
- continue;
- }
- updateApnTable(&lynq_apn_table[apnId], apn,apnType,ifaceName);
- }
- lynq_data_call_change_id = apnId;
- sendSignalPdnChange();
- LYDBGLOG("data call state:%d",lynq_data_call);
- if(lynq_data_call==1)
- {
- sendSignalDataCallStateChange();
- lynq_data_call = 0;
- }
- }
- else
- {
- urc_msg = strdupReadString_p(p);
- len = strlen(urc_msg);
- if(len < LYNQ_APN_TYPE_MAX_LEN-1)
- {
- memcpy(apnType,urc_msg,len+1);
- }
- LYDBGLOG("[data thread_urc_recv] apntype:%s",apnType);
- int apnId = getLynqApnID(apnType);
- if(apnId >= 0)
- {
- lynq_data_call_change_id = apnId;
- bzero(lynq_apn_table[apnId].apnType,LYNQ_APN_TYPE_MAX_LEN);//async clean
- }
- sendSignalPdnChange();
- LYDBGLOG("data call state:%d",lynq_data_call);
- if(lynq_data_call==1)
- {
- sendSignalDataCallStateChange();
- lynq_data_call = 0;
- }
- }
- break;
- }
- case 9004:
- {
- LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
urc_msg = strdupReadString_p(p);
- if (NULL == urc_msg)
+ int len = strlen(urc_msg);
+ if(len < LYNQ_APN_MAX_LEN-1)
{
- LYERRLOG("error apn msg");
+ memcpy(apn,urc_msg,len+1);
}
+ urc_msg = strdupReadString_p(p);
+ len = strlen(urc_msg);
+ if(len < LYNQ_APN_TYPE_MAX_LEN-1)
+ {
+ memcpy(apnType,urc_msg,len+1);
+ }
+ urc_msg = strdupReadString_p(p);
+ len = strlen(urc_msg);
+ if(len < LYNQ_IFACE_NAME_MAX_LEN-1)
+ {
+ memcpy(ifaceName,urc_msg,strlen(urc_msg)+1);
+ }
+ //sendSignalDataCallStateChange();
+ int apnId = getLynqApnID(apnType);
+ if(apnId >= 0)
+ {
+ if(lynq_apn_table[apnId].hasTimeout==1)
+ {
+ LYERRLOG("apn:%s has time out,deacive this apn",lynq_apn_table[apnId].apn);
+ if (NULL != lynq_apn_table[apnId].apn && NULL != NULL != lynq_apn_table[apnId].apnType)
+ {
+ LYERRLOG("deactive this time out APN");
+ lynq_deactive_data_call(&apnId);
+ }
+ else
+ {
+ LYERRLOG("this table is invalid");
+ }
+ break;
+ }
+ updateApnTable(&lynq_apn_table[apnId],apn,apnType,ifaceName);
+ }
+ /*To be completed*/
else
{
- bzero(g_lynq_apn_result, 1024);
- strcpy(g_lynq_apn_result, urc_msg);
- sendSignalApnChange();
+ LYERRLOG("invalid apnId");
+ break;
}
- break;
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ s_data_urc_wait_list.push_back(apnId);
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+ lynq_data_call_change_id = apnId;
+ //sendSignalPdnChange();
+ LYDBGLOG("data call state:%d",lynq_data_call);
+ if(lynq_data_call==1)
+ {
+ sendSignalDataCallStateChange();
+ lynq_data_call = 0;
+ }
}
- case 9005:
+ else
{
- LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
+ urc_msg = strdupReadString_p(p);
+ len = strlen(urc_msg);
+ if(len < LYNQ_APN_TYPE_MAX_LEN-1)
+ {
+ memcpy(apnType,urc_msg,len+1);
+ }
+ LYDBGLOG("[data thread_urc_recv] apntype:%s",apnType);
+ int apnId = getLynqApnID(apnType);
+ if(apnId >= 0)
+ {
+ lynq_data_call_change_id = apnId;
+ bzero(lynq_apn_table[apnId].apnType,LYNQ_APN_TYPE_MAX_LEN);//async clean
+ }
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ s_data_urc_wait_list.push_back(apnId);
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+ //sendSignalPdnChange();
+ LYDBGLOG("data call state:%d",lynq_data_call);
+ if(lynq_data_call==1)
+ {
+ sendSignalDataCallStateChange();
+ lynq_data_call = 0;
+ }
+ }
+ break;
+ case LYNQ_URC_MODIFY_APNDB:
+ urc_msg = strdupReadString_p(p);
+ if (NULL == urc_msg)
+ {
+ LYERRLOG("error apn msg");
+ }
+ else
+ {
+ bzero(g_lynq_apn_result, 1024);
+ strcpy(g_lynq_apn_result, urc_msg);
+ sendSignalApnChange();
+ }
+ break;
+ case LYNQ_URC_RESET_APNDB:
+ {
urc_msg = strdupReadString_p(p);
if (NULL == urc_msg)
{
@@ -485,56 +483,76 @@
sendSignalApnChange();
}
}
- default:
- break;
- }
- }
- delete p;
- p = NULL;
+ default:
+ break;
}
- close(socket_fd);
+
}
-int lynq_socket_urc_start()
+
+void cleanup_urc_vector_mutex(void *arg)
{
- int socket_fd=0;
- int rt=0;
- int len=0;
- int on=1;
- struct sockaddr_in urc_local_addr;
- pthread_attr_t attr;
- socket_fd = socket(AF_INET,SOCK_DGRAM,0);
- if(socket_fd < 0)
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+}
+
+void *thread_urc_vector()
+{
+ pthread_cleanup_push(cleanup_urc_vector_mutex, NULL);
+ while (data_urc_vector_status)
{
- perror("creaet socket for udp fail");
+ while (!s_data_urc_wait_list.empty())
+ {
+ sendSignalPdnChange();
+ usleep(10);
+ }
+ usleep(1);
+ }
+ pthread_cleanup_pop(0);
+}
+
+void cancel_urc_vector_signal_thread()
+{
+ int ret;
+
+ data_urc_vector_status = 0;
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ if (data_list_urc_vector_tid != -1)
+ {
+ ret = pthread_cancel(data_list_urc_vector_tid);
+ LYDBGLOG("pthread cancel ret = %d",ret);
+ }
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+
+ if (data_list_urc_vector_tid != -1)
+ {
+ ret = pthread_join(data_list_urc_vector_tid,NULL);
+ LYDBGLOG("pthread join ret = %d",ret);
+ data_list_urc_vector_tid = -1;
+ }
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ s_data_urc_wait_list.clear();
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+}
+
+int create_urc_vector_signal_thread()
+{
+ int ret;
+
+ data_urc_vector_status = 1;
+ pthread_mutex_init(&s_lynq_urc_vector_mutex,NULL);
+ ret = pthread_create(&data_list_urc_vector_tid,NULL,thread_urc_vector,NULL);
+ if (ret < 0)
+ {
+ LYERRLOG("urc vector signal pthread create error");
+ lynq_deinit_data_urc_thread();
+ data_urc_vector_status = 0;
return -1;
}
- urc_local_addr.sin_family = AF_INET;
- urc_local_addr.sin_port = htons(LYNQ_URC_SERVICE_PORT);
- urc_local_addr.sin_addr.s_addr = htons(INADDR_ANY);
- /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
- rt = setsockopt(socket_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
- if(rt<0)
- {
- perror("SO_REUSEADDR fail\n");
- return -1;
- }
- rt = bind(socket_fd ,(struct sockaddr*)&urc_local_addr, sizeof(urc_local_addr));
- if (rt == -1)
- {
- perror("bind failed");
- return -1;
- }
- pthread_attr_init(&attr);
- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- rt = pthread_create(&lynq_data_tid,&attr,thread_urc_recv,(void *)socket_fd);
- if(rt < 0)
- {
- LYERRLOG("urc loop failure!!!\n");
- return -1;
- }
- LYDBGLOG("urc loop success!!!\n");
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ s_data_urc_wait_list.clear();
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
return 0;
}
+
int lynq_init_data(int uToken)
{
if (g_lynq_data_init_flag == 1)
@@ -545,7 +563,6 @@
g_lynq_data_init_flag = 1;
int result = 0;
Global_uToken = uToken;
- data_urc_recive_status = 1;
LYLOGSET(LOG_INFO);
LYLOGEINIT(USER_LOG_TAG);
result = lynq_socket_client_start();
@@ -555,7 +572,14 @@
LYERRLOG("init socket client fail!!!");
return -1;
}
- result = lynq_socket_urc_start();
+ result = lynq_init_data_urc_thread();
+ if(result!=0)
+ {
+ LYERRLOG("init socket urc fail!!!");
+ return -1;
+ }
+
+ result = create_urc_vector_signal_thread();
if(result!=0)
{
LYERRLOG("init socket urc fail!!!");
@@ -586,14 +610,13 @@
{
close(lynq_client_sockfd);
}
- data_urc_recive_status = 0;
- if (lynq_data_tid > 0)
+ ret = lynq_deinit_data_urc_thread();
+ if (ret != 0)
{
- ret = pthread_cancel(lynq_data_tid);
- LYDBGLOG("pthread cancel ret = %d",ret);
- ret = pthread_join(lynq_data_tid,NULL);
- LYDBGLOG("pthread join ret = %d",ret);
+ LYERRLOG("lynq_deinit_data_urc_thread fail");
+ return ret;
}
+ cancel_urc_vector_signal_thread();
return 0;
}
int lynq_setup_data_call(int *handle)
@@ -604,7 +627,6 @@
int request = -1;
int slot_id = -1;
int error = -1;
- char iface = NULL;
int lynq_data_call_id = 0;
if(handle==NULL)
{
@@ -642,6 +664,7 @@
}
return error;
}
+
int lynq_deactive_data_call(int *handle)
{
Parcel p;
@@ -700,7 +723,6 @@
int request = -1;
int slot_id = -1;
int error = -1;
- char iface = NULL;
int lynq_data_call_id = -1;
char *argv[10] = {};
if(handle==NULL||apn==NULL||apnType==NULL)
@@ -769,7 +791,7 @@
lynq_data_call = 1;
if(error==0)
{
- if(waitDataCallstateChange(20000)==ETIMEDOUT)//20s
+ if(waitDataCallstateChange(60000)==ETIMEDOUT)//60s
{
error = LYNQ_E_TIME_OUT;
LYERRLOG("timeout:wait data Call state fail!!!");
@@ -823,7 +845,6 @@
int error = -1;
int version =0;
int num = 0;
- int temp_int =0;
char *temp_char = NULL;
if(dataCallList==NULL)
{
@@ -924,8 +945,16 @@
}
int lynq_wait_data_call_state_change(int *handle)
{
+
+ std::vector<int>::iterator iter;
waitPdnChange();
- *handle = lynq_data_call_change_id;
+
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ iter = s_data_urc_wait_list.begin();
+ handle = (*iter);
+ s_data_urc_wait_list.erase(iter);
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+
LYINFLOG("lynq data call id:%d",lynq_data_call_change_id);
return 0;
}
@@ -1214,7 +1243,6 @@
}
lynq_client_t client;
char argc[512];
- char recvline[LYNQ_REC_BUF];
int res = 0;
Parcel p;
if (cmd == 0) // insert apn db
diff --git a/src/lynq/lib/liblynq-data/lynq_data_urc.cpp b/src/lynq/lib/liblynq-data/lynq_data_urc.cpp
new file mode 100755
index 0000000..9f211eb
--- /dev/null
+++ b/src/lynq/lib/liblynq-data/lynq_data_urc.cpp
@@ -0,0 +1,331 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <unistd.h>
+#include <binder/Parcel.h>
+#include <log/log.h>
+#include <cutils/jstring.h>
+#include <pthread.h>
+#include <list>
+#include "lynq_data.h"
+#include "lynq_data_urc.h"
+#include "liblog/lynq_deflog.h"
+#include "lynq_shm.h"
+
+#define LYNQ_REC_BUF 8192
+
+static std::list<Parcel*> s_urc_recv_parcel_list;
+
+int lynq_len_urc_addr_serv;
+struct sockaddr_in urc_local_addr;
+static int lynq_urc_sockfd = -1;
+bool data_urc_recive_status = 1;
+static pthread_mutex_t s_lynq_urc_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_lynq_urc_cond = PTHREAD_COND_INITIALIZER;
+
+/*recv*/
+pthread_t data_urc_recv_tid = -1;
+static pthread_mutex_t s_lynq_urc_recv_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_lynq_urc_recv_cond = PTHREAD_COND_INITIALIZER;
+
+/*process*/
+pthread_t data_urc_process_tid = -1;
+bool data_urc_process_status = 1;
+static pthread_mutex_t s_lynq_urc_process_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_lynq_urc_process_cond = PTHREAD_COND_INITIALIZER;
+
+#define SHM_BUFFER_INDEX_OFFSET 1
+#define SHM_BUFFER_SIZE_OFFSET 16
+#define SHM_BUFFER_INDEX_MASK 0x0000007F
+#define SHM_BUFFER_SIZE_MASK 0x0000FFFF
+
+bool urc_data_is_in_shm_data(int responseType,int& level, int& index, int& size)
+{
+ int shm_index=((responseType>>SHM_BUFFER_INDEX_OFFSET)&SHM_BUFFER_INDEX_MASK);
+ if (shm_index>0)
+ {
+ index=shm_index-1;
+ size=((responseType>>SHM_BUFFER_SIZE_OFFSET)&SHM_BUFFER_SIZE_MASK);
+ if(size>=sizeof(int32_t)*3 && get_shem_buffer_level(size,&level))
+ {
+ LYINFLOG("urc_data_is_in_shm_data level is %d, index is %d size is %d",level,index,size);
+ return true;
+ }
+ }
+ LYINFLOG("urc_data_is_in_shm_data return false, responseType is %d",responseType);
+ return false;
+}
+
+void cleanup_urc_process_mutex(void *arg)
+{
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+}
+
+void *thread_urc_recv()
+{
+ Parcel *urc_p =NULL;
+ char urc_data[LYNQ_REC_BUF];
+ int res = 0;
+ lynq_head_t* phead;
+ int level,index,size;
+ uint8_t * shm_buffer;
+
+ LYINFLOG("urc recv thread is running");
+ while(data_urc_recive_status)
+ {
+ bzero(urc_data,LYNQ_REC_BUF);
+ res = recvfrom(lynq_urc_sockfd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&urc_local_addr,(socklen_t*)&lynq_len_urc_addr_serv);
+
+ if(res<sizeof(int32_t)*2)
+ {
+ LYERRLOG("thread_urc_recv step2 fail: res is %d",res);
+ continue;
+ }
+
+ phead=(lynq_head_t*) urc_data;
+ if(is_support_urc(phead->urcid)==false)
+ {
+ continue;
+ }
+ urc_p = new Parcel();
+ if(urc_p == NULL)
+ {
+ LYERRLOG("new parcel failure!!!");
+ continue;
+ }
+ if(urc_data_is_in_shm_data(phead->resp_type,level,index,size))
+ {
+ shm_buffer = (uint8_t *)get_shem_buffer(level,index); // p.setData((uint8_t *) buffer, buflen);
+ LYINFLOG("shm pointer is %p", shm_buffer);
+ urc_p->setData(shm_buffer,size);
+ }
+ else if(res>=sizeof(int32_t)*3)
+ {
+ urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
+ }
+ else
+ {
+ LYERRLOG("res %d error!!!", res);
+ delete urc_p;
+ urc_p = NULL;
+ continue;
+ }
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ pthread_mutex_lock(&s_lynq_urc_process_mutex);
+ s_urc_recv_parcel_list.push_back(urc_p);
+ pthread_cond_broadcast(&s_lynq_urc_process_cond);
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+ }
+ else
+ {
+ delete urc_p;
+ urc_p = NULL;
+ }
+ }
+ LYINFLOG("urc recv thread ended");
+ return NULL;
+}
+
+void *thread_urc_process()
+{
+ Parcel *urc_p =NULL;
+ std::list<Parcel*>::iterator iter;
+
+ LYINFLOG("urc process thread is running");
+ pthread_cleanup_push(cleanup_urc_process_mutex, NULL); // thread cleanup handler
+ while (data_urc_process_status)
+ {
+ pthread_mutex_lock(&s_lynq_urc_process_mutex);
+ while(s_urc_recv_parcel_list.empty())
+ {
+ pthread_cond_wait(&s_lynq_urc_process_cond,&s_lynq_urc_process_mutex);
+ }
+ iter=s_urc_recv_parcel_list.begin();
+ urc_p = (*iter);
+ s_urc_recv_parcel_list.erase(iter);
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ pthread_mutex_lock(&s_lynq_urc_mutex);
+ urc_msg_process(urc_p);
+ pthread_mutex_unlock(&s_lynq_urc_mutex);
+ }
+ delete urc_p;
+ urc_p = NULL;
+ }
+ pthread_cleanup_pop(0);
+ LYINFLOG("urc process thread ended");
+ return NULL;
+}
+
+int lynq_socket_recv_start()
+{
+ int rt=0;
+ int on=1;
+ struct sockaddr_in urc_local_addr;
+ pthread_attr_t attr;
+ lynq_urc_sockfd = socket(AF_INET,SOCK_DGRAM,0);
+ if(lynq_urc_sockfd < 0)
+ {
+ LYERRLOG("create socket for udp fail");
+ return -1;
+ }
+ urc_local_addr.sin_family = AF_INET;
+ urc_local_addr.sin_port = htons(LYNQ_URC_SERVICE_PORT);
+ urc_local_addr.sin_addr.s_addr = htons(INADDR_ANY);
+ /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
+ rt = setsockopt(lynq_urc_sockfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
+ if(rt<0)
+ {
+ LYERRLOG("SO_REUSEADDR fail");
+ close(lynq_urc_sockfd);
+ lynq_urc_sockfd = -1;
+ return -1;
+ }
+ rt = bind(lynq_urc_sockfd ,(struct sockaddr*)&urc_local_addr, sizeof(urc_local_addr));
+ if (rt == -1)
+ {
+ LYERRLOG("bind failed");
+ close(lynq_urc_sockfd);
+ lynq_urc_sockfd = -1;
+ return -1;
+ }
+ return 0;
+}
+
+int lynq_socket_recv_stop()
+{
+ if (lynq_urc_sockfd >=0)
+ {
+ close(lynq_urc_sockfd);
+ lynq_urc_sockfd = -1;
+ }
+ return 0;
+}
+
+void lynq_urc_recv_thread_stop()
+{
+ int ret;
+
+ pthread_mutex_lock(&s_lynq_urc_process_mutex);
+ data_urc_recive_status = 0;
+ if (data_urc_recv_tid != -1)
+ {
+ ret = pthread_cancel(data_urc_recv_tid);
+ LYDBGLOG("pthread cancel ret = %d",ret);
+ }
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+
+ if (data_urc_recv_tid != -1)
+ {
+ ret = pthread_join(data_urc_recv_tid,NULL);
+ LYDBGLOG("pthread join ret = %d",ret);
+ data_urc_recv_tid = -1;
+ }
+}
+
+void lynq_urc_process_thread_stop()
+{
+ int ret;
+
+ pthread_mutex_lock(&s_lynq_urc_process_mutex);
+ pthread_mutex_lock(&s_lynq_urc_mutex);
+
+ data_urc_process_status = 0;
+ if (data_urc_process_tid != -1)
+ {
+ ret = pthread_cancel(data_urc_process_tid);
+ LYDBGLOG("pthread cancel ret = %d",ret);
+ }
+ pthread_mutex_unlock(&s_lynq_urc_mutex);
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+
+ if (data_urc_process_tid != -1)
+ {
+ ret = pthread_join(data_urc_process_tid,NULL);
+ LYDBGLOG("pthread join ret = %d",ret);
+ data_urc_process_tid = -1;
+ }
+}
+
+
+int lynq_init_data_urc_thread()
+{
+ int ret = 0;
+ if(ril_init_mem()!=0)
+ {
+ LYERRLOG("ril_init_mem fail");
+ return -1;
+ }
+
+ ret = lynq_socket_recv_start();
+ if (ret != 0)
+ {
+ LYERRLOG("lynq_socket_recv_start fail");
+ ril_deinit_mem();
+ return -1;
+ }
+
+ pthread_mutex_init(&s_lynq_urc_process_mutex,NULL);
+ pthread_mutex_init(&s_lynq_urc_recv_mutex,NULL);
+
+ pthread_mutex_lock(&s_lynq_urc_process_mutex);
+ std::list<Parcel*>::iterator iter;
+ for (iter=s_urc_recv_parcel_list.begin();iter!=s_urc_recv_parcel_list.end();++iter)
+ {
+ delete(*iter);
+ }
+ s_urc_recv_parcel_list.clear();
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+
+ pthread_mutex_init(&s_lynq_urc_mutex,NULL);
+ data_urc_recive_status = 1;
+
+ ret = pthread_create(&data_urc_recv_tid,NULL,thread_urc_recv,NULL);
+ if (ret < 0)
+ {
+ LYERRLOG("urc recv pthread create error");
+ data_urc_recive_status = 0;
+ lynq_socket_recv_stop();
+ ril_deinit_mem();
+ return -1;
+ }
+
+ data_urc_process_status = 1;
+ ret = pthread_create(&data_urc_process_tid,NULL,thread_urc_process,NULL);
+ if (ret < 0)
+ {
+ LYERRLOG("urc recv pthread create error");
+
+ data_urc_process_status = 0;
+ lynq_socket_recv_stop();
+ lynq_urc_recv_thread_stop();
+
+ return -1;
+ }
+ return 0;
+}
+
+int lynq_deinit_data_urc_thread()
+{
+ lynq_socket_recv_stop();
+ lynq_urc_recv_thread_stop();
+ lynq_urc_process_thread_stop();
+
+ pthread_mutex_lock(&s_lynq_urc_process_mutex);
+ std::list<Parcel*>::iterator iter;
+ for (iter=s_urc_recv_parcel_list.begin();iter!=s_urc_recv_parcel_list.end();++iter)
+ {
+ delete(*iter);
+ }
+ s_urc_recv_parcel_list.clear();
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+
+ ril_deinit_mem();
+ return 0;
+}
diff --git a/src/lynq/lib/liblynq-data/lynq_data_urc.h b/src/lynq/lib/liblynq-data/lynq_data_urc.h
new file mode 100755
index 0000000..7ac4f75
--- /dev/null
+++ b/src/lynq/lib/liblynq-data/lynq_data_urc.h
@@ -0,0 +1,30 @@
+#ifndef LYNQ_DATA_URC_H
+#define LYNQ_DATA_URC_H
+
+using ::android::Parcel;
+
+#define LYNQ_URC_SERVICE_PORT 8086
+
+/*the same with lynq_interface.h begin*/
+#define LYNQ_REQUEST_VENDOR_BASE 8000
+#define LYNQ_URC_VENDOR_BASE 9000
+#define LYNQ_AT_SNED (LYNQ_REQUEST_VENDOR_BASE +1)
+#define LYNQ_URC_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+1)
+#define LYNQ_URC_DATA_STATUS_IND (LYNQ_URC_VENDOR_BASE+2)
+#define LYNQ_URC_DATA_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+3)
+#define LYNQ_AUTO_ANSWER_CALL (LYNQ_REQUEST_VENDOR_BASE +2)
+#define LYNQ_REQUEST_SET_DTMF_VOLUME (LYNQ_REQUEST_VENDOR_BASE +3)
+#define LYNQ_URC_MODIFY_APNDB (LYNQ_URC_VENDOR_BASE+4)
+#define LYNQ_URC_RESET_APNDB (LYNQ_URC_VENDOR_BASE+5)
+
+typedef struct{
+ int resp_type;
+ int urcid;
+}lynq_head_t;
+
+int lynq_init_data_urc_thread();
+int lynq_deinit_data_urc_thread();
+bool is_support_urc(int urc_id);
+void urc_msg_process(Parcel *p);
+
+#endif
\ No newline at end of file
diff --git a/src/lynq/lib/liblynq-data/makefile b/src/lynq/lib/liblynq-data/makefile
index 183ebaa..53ed1d4 100755
--- a/src/lynq/lib/liblynq-data/makefile
+++ b/src/lynq/lib/liblynq-data/makefile
@@ -20,6 +20,7 @@
LOCAL_C_INCLUDES = \
-I. \
-I$(LOCAL_PATH)/include/libdata \
+ -I$(ROOT)$(includedir)/lynq_shm \
-I$(ROOT)$(includedir)/logger \
-I$(ROOT)$(includedir)/liblog \
@@ -35,6 +36,7 @@
-lpthread \
-llynq-log \
-llynq-uci \
+ -llynq-shm \
SOURCES = $(wildcard *.cpp)
diff --git a/src/lynq/lib/liblynq-fota/include/iot_rock.h b/src/lynq/lib/liblynq-fota/include/iot_rock.h
index b9915c1..36d37a8 100755
--- a/src/lynq/lib/liblynq-fota/include/iot_rock.h
+++ b/src/lynq/lib/liblynq-fota/include/iot_rock.h
@@ -26,6 +26,7 @@
#define PATCH_MD1IMG (4)
#define PATCH_MD1DSP (5)
#define PATCH_VBMETA (6)
+
#ifdef MOBILETEK_FOTA_CFG
#define PATCH_BL33 (7)
#define FULL_SYSTEM (8)
@@ -125,9 +126,10 @@
char fota_flag[32]; //fota 标志保留
int update_result; //升级结果
- int ota_run; //
- char cid[32];
- char did[32];
+ int ota_run; //
+ char cid[32];
+ char did[32];
+ char addr[64];
} UPDATE_INFO;
diff --git a/src/lynq/lib/liblynq-fota/rock_ua/rock_ua.c b/src/lynq/lib/liblynq-fota/rock_ua/rock_ua.c
index c68e9c2..8ef06e7 100755
--- a/src/lynq/lib/liblynq-fota/rock_ua/rock_ua.c
+++ b/src/lynq/lib/liblynq-fota/rock_ua/rock_ua.c
@@ -9,7 +9,7 @@
#include "iot_rock.h"
#include "iot_rock_ipl.h"
#include "sha.h"
-
+#include <log/log.h>
#include <stdarg.h>
#include <errno.h>
#include <fcntl.h>
@@ -22,7 +22,6 @@
//#define off64_t __off64_t
-
#include <hardware/boot_control.h>
#include <hardware/hardware.h>
#include <sys/reboot.h>
@@ -36,8 +35,11 @@
#define ROCK_DEFAULT_BLOCK_SIZE 0x40000
#define ROCK_RAM_LEN (1024*1024)
-
+#define LOG_TAG "LYNQ_FOTA"
#define ROCK_BACKUP_LEN ROCK_DEFAULT_BLOCK_SIZE
+#ifdef GSW_FOTA_CFG
+#define READ_BLOCK_SIZE 0x40000
+#endif
#define DEV_SYSTEM_A "/dev/disk/by-partlabel/system_a"
@@ -115,6 +117,9 @@
OTA_STATUS fota_status;
+#ifdef MOBILETEK_FOTA_CFG
+UPDATE_INFO up_info;
+#endif
extern const hw_module_t HAL_MODULE_INFO_SYM;
boot_control_module_t* module;
@@ -123,6 +128,13 @@
static void lynq_fota_grab_artial_wake_lock(void);
static void lynq_fota_release_wake_lock(void);
+#ifdef MOBILETEK_FOTA_CFG
+int matchString(char* buf, char* sub);
+int reset_fota_flag(void);
+int get_fota_flag(void);
+void check_ril_service(void);
+#endif
+
int rock_mismatch(void* ctx, unsigned char* buf, unsigned int start, unsigned int size,
unsigned int source_hash,unsigned int target_hash) {
@@ -136,84 +148,71 @@
void rock_trace(void* ctx, const char* fmt, ...) {
va_list ap;
- memset(rock_debug_buffer,0x0,sizeof(rock_debug_buffer));
+ memset(rock_debug_buffer,0x0,sizeof(rock_debug_buffer));
va_start (ap, fmt);
-
-
vsnprintf(rock_debug_buffer,sizeof(rock_debug_buffer),fmt,ap);
- LYDBGLOG("+[UA]: %s",rock_debug_buffer);
-
-
+ LYDBGLOG("+[UA]: %s",rock_debug_buffer);
va_end (ap);
}
static int save_fota_status()
{
- int err;
+ int err;
fd_fota_status = open(FILE_FOTA_STATE,O_RDWR | O_CREAT,0777);
- //fd_update_status = open(FILE_UPDATE_STATE,O_RDWR);
if (fd_fota_status < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: save_fota_status: Error opening metadata file: %s\n",strerror(errno));
return -err;
}
-
- write(fd_fota_status, &fota_status,sizeof(fota_status));
- sync();
-
- close(fd_fota_status);
+
+ write(fd_fota_status, &fota_status,sizeof(fota_status));
+ sync();
+ close(fd_fota_status);
}
void rock_progress(void* ctx, int percent) {
- int i = 0;
+ int i = 0;
rock_trace(ctx, "rock update progress %d\n", percent);
- if (percent > 20) {
+ if (percent > 20) {
i = fota_status.ota_run;
- if (fota_status.update_status[i-1].check_delta != PASS) {
- fota_status.update_status[i-1].check_delta = PASS;
- fota_status.update_status[i-1].check_rom= PASS;
- save_fota_status();
- }
- }
+ if (fota_status.update_status[i-1].check_delta != PASS) {
+ fota_status.update_status[i-1].check_delta = PASS;
+ fota_status.update_status[i-1].check_rom= PASS;
+ save_fota_status();
+ }
+ }
}
int rock_process_block(void* ctx, unsigned char* data, unsigned int start, unsigned int size){
//rock_trace(ctx, "rock update progress block %d\n", size);
int writen = 0;
- int ret,err;
-
-
- if (start == BACKUP_ADDR_FLAG) {
- int fd_backup = open(FILE_BACKUP,O_RDWR | O_CREAT,0777);
- while (writen < size) {
- write(fd_backup,data,ROCK_DEFAULT_BLOCK_SIZE);
- sync();
- writen += ROCK_DEFAULT_BLOCK_SIZE;
- }
- close(fd_backup);
- return size;
- }
-
-
-
- writen = 0;
-
+ int err,ret;
+
+ if (start == BACKUP_ADDR_FLAG) {
+ int fd_backup = open(FILE_BACKUP,O_RDWR | O_CREAT,0777);
+ while (writen < size) {
+ write(fd_backup,data,ROCK_DEFAULT_BLOCK_SIZE);
+ sync();
+ writen += ROCK_DEFAULT_BLOCK_SIZE;
+ }
+ close(fd_backup);
+ return size;
+ }
+ writen = 0;
if (mtk_device_wrap_seek(fd_write, start, SEEK_SET) < 0) {
err = errno;
rock_trace(ctx, "mtk_device_wrap_seek write\n");
- return err;
- }
+ return err;
+ }
while (writen < size) {
ret = mtk_device_wrap_write(fd_write,data+writen, ROCK_DEFAULT_BLOCK_SIZE);
writen += ROCK_DEFAULT_BLOCK_SIZE;
- }
-
-
+ }
return size;
}
@@ -308,7 +307,7 @@
int rock_read_delta(void* ctx, unsigned char* dest, unsigned int offset, unsigned int size){
int ret = 0,err = 0;
-
+
if (lseek(fd_delta, offset + delta_offset, SEEK_SET) < 0) {
err = -errno;
@@ -351,7 +350,7 @@
/* ROCK IPL end */
-
+#ifdef GSW_FOTA_CFG
static int init_dev_fd()
{
@@ -361,77 +360,119 @@
{
return E_ROCK_FOTA_ADDR;
}
- LYERRLOG("+[UA]: get fota pack addr: %s\n",lynq_fota_addr);
- //fd_delta = mtk_device_wrap_open(DEV_DELTA,O_RDONLY);
+ RLOGD("+[UA]: get fota pack addr: %s\n", lynq_fota_addr);
fd_delta = open(lynq_fota_addr,O_RDWR);
if (fd_delta < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
return -err;
}
fd_update_status = open(FILE_UPDATE_STATE,O_RDWR | O_CREAT,0777);
- //fd_update_status = open(FILE_UPDATE_STATE,O_RDWR);
-
if (fd_update_status < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening fd_delta file: %s\n",strerror(errno));
return -err;
}
return 0;
}
+#endif
+#ifdef MOBILETEK_FOTA_CFG
+static int init_dev_fd()
+{
+
+ int err, result;
+ char lynq_fota_addr[35];
+ if(0 != lynq_fota_get_addr_value(lynq_fota_addr))
+ {
+ return E_ROCK_FOTA_ADDR;
+ }
+ RLOGD("lynq_fota_addr: %s\n", lynq_fota_addr);
+ if(!(strcmp(lynq_fota_addr, "/tmp/fota.delta")))
+ {
+ result = test_write_delta(lynq_fota_addr, DEV_DELTA);
+ if(result != 0)
+ {
+ RLOGD("fota.delta write into mtd fail !\n");
+ }
+ strcpy(lynq_fota_addr, DEV_DELTA);
+ }
+ if(lynq_fota_set_addr_value(lynq_fota_addr,strlen(lynq_fota_addr)))
+ {
+ RLOGD("set addr fail\n");
+ return 1;
+ }
+ RLOGD("+[UA]: get fota pack addr: %s\n", lynq_fota_addr);
+ fd_delta = open(lynq_fota_addr,O_RDWR);
+ if (fd_delta < 0) {
+ err = errno;
+ RLOGD("+[UA]: Error opening fd_delta file: %s\n",strerror(errno));
+ return -err;
+ }
+ get_fota_flag();
+ return 0;
+}
+#endif
-
-
+#ifdef MOBILETEK_FOTA_CFG
+static int reboot_device()
+{
+ sleep(5);
+ sync();
+ sleep(5);
+ system("reboot");
+}
+#endif
+#ifdef GSW_FOTA_CFG
static int close_dev_fd(int fd)
{
close(fd);
}
-
static int reboot_device() {
reboot(RB_AUTOBOOT);
while (1) pause();
}
+#endif
int test_write_delta(char *source, char *target)
{
int fd_source,fd_target,size;
-
- char delta_data[ROCK_DEFAULT_BLOCK_SIZE];
-
+
+ char delta_data[ROCK_DEFAULT_BLOCK_SIZE];
fd_source = open(source,O_RDONLY);
-
+
if (fd_source < 0) {
- LYERRLOG("+[UA]: open source error\n");
+ RLOGD("+[UA]: open source error\n");
return 1;
}
fd_target = mtk_device_wrap_open(target,O_RDWR);
-
if (fd_target < 0) {
mtk_device_wrap_close(fd_target);
- close(fd_source);
- LYERRLOG("+[UA]: open target error\n");
+ close(fd_source);
+ RLOGD("+[UA]: open target error\n");
return 1;
- }
-
- while(( size = read(fd_source,delta_data,ROCK_DEFAULT_BLOCK_SIZE))>0) {
- mtk_device_wrap_write(fd_target,delta_data,ROCK_DEFAULT_BLOCK_SIZE);
}
-
- mtk_device_wrap_close(fd_target);
- close(fd_source);
- return 0;
+#ifdef MOBILETEK_FOTA_CFG
+ system("flash_eraseall /dev/mtd41");
+#endif
+ while(( size = read(fd_source,delta_data,ROCK_DEFAULT_BLOCK_SIZE))>0) {
+ mtk_device_wrap_write(fd_target,delta_data,ROCK_DEFAULT_BLOCK_SIZE);
+ }
+
+ mtk_device_wrap_close(fd_target);
+ close(fd_source);
+ return 0;
}
@@ -444,7 +485,7 @@
fd_source = mtk_device_wrap_open(source,O_RDONLY);
if (fd_source < 0) {
- LYERRLOG("+[UA]: open source error\n");
+ RLOGD("+[UA]: open source error\n");
return 1;
}
@@ -453,7 +494,7 @@
if (fd_target < 0) {
mtk_device_wrap_close(fd_target);
mtk_device_wrap_close(fd_source);
- LYERRLOG("+[UA]: open target error\n");
+ RLOGD("+[UA]: open target error\n");
return 1;
}
@@ -518,27 +559,35 @@
static int rock_update_main(unsigned int rom_base, unsigned int backup_base, unsigned int backup_len, int read_rom_directly, int first_run) {
- int status,err,start;
+ int status,err;
+#ifdef MOBILETEK_FOTA_CFG
+ int start;
+#endif
int ret = 0;
- int i = 0;
- int retry_cnt = 0;
-
- IOT_UPDATA_CONTEXT ctx;
+ int i = 0;
+ int retry_cnt = 0;
+
+ IOT_UPDATA_CONTEXT ctx;
+#ifdef GSW_FOTA_CFG
UPDATE_INFO up_info;
//OTA_STATUS fota_status;
-
+#endif
const hw_module_t* hw_module;
unsigned int slot;
+#ifdef MOBILETEK_FOTA_CFG
+ unsigned int update_mode = -1;
+#endif
+#ifdef GSW_FOTA_CFG
unsigned int update_mode = MODE_NORMAL;
- unsigned int delta_size;
+#endif
+ unsigned int delta_size;
unsigned char full_header[9];
-
- char digest_s[SHA_DIGEST_SIZE];
- char digest_t[SHA_DIGEST_SIZE];
-
+ char digest_s[SHA_DIGEST_SIZE];
+ char digest_t[SHA_DIGEST_SIZE];
+
hw_module = &HAL_MODULE_INFO_SYM;
if (!hw_module ||
@@ -546,7 +595,7 @@
ret = -EINVAL;
}
if (ret != 0) {
- LYERRLOG("+[UA]: Error loading boot_control HAL implementation.\n");
+ RLOGD("+[UA]: Error loading boot_control HAL implementation.\n");
return -1;
}
@@ -555,8 +604,8 @@
if (module == NULL) {
- LYERRLOG("+[UA]: Error getting bootctrl module.\n");
- return -1;
+ RLOGD("+[UA]: Error getting bootctrl module.\n");
+ return -1;
}
lynq_init_wake_lock_func();
@@ -567,60 +616,77 @@
int is_successful = module->isSlotMarkedSuccessful(module, current_slot);
- LYVERBLOG("Booting slot = %d, : isSlotMarkedSuccessful= %d\n",current_slot,is_successful);
-
+ RLOGD("+[UA]: Booting slot = %d, : isSlotMarkedSuccessful= %d\n",current_slot,is_successful);
- memset(&ctx, 0, sizeof(ctx));
- ctx.rom_base = 0;
- ctx.ram_base =(unsigned char *)&ram_buffer[0];
- ctx.ram_len = ROCK_RAM_LEN;
- ctx.backup_base = BACKUP_ADDR_FLAG;
- ctx.backup_len = ROCK_DEFAULT_BLOCK_SIZE;
- ctx.update_nvram = 0;
- ctx.read_rom_directly = read_rom_directly;
+ memset(&ctx, 0, sizeof(ctx));
+ ctx.rom_base = 0;
+ ctx.ram_base =(unsigned char *)&ram_buffer[0];
+ ctx.ram_len = ROCK_RAM_LEN;
+ ctx.backup_base = BACKUP_ADDR_FLAG;
+ ctx.backup_len = ROCK_DEFAULT_BLOCK_SIZE;
+ ctx.update_nvram = 0;
+ ctx.read_rom_directly = read_rom_directly;
//ctx.first_run = first_run;
ctx.first_run = 1;
-
+#ifdef MOBILETEK_FOTA_CFG
+ get_fota_flag();
+#endif
if(0 != init_dev_fd())
{
- LYVERBLOG("+[UA]: get fota addr error\n");
+ RLOGD("+[UA]: get fota addr error\n");
lynq_fota_release_wake_lock();
return E_ROCK_FOTA_ADDR;
}
+
+#ifdef GSW_FOTA_CFG
memset(&up_info, 0, sizeof(up_info));
memset(&fota_status,0,sizeof(fota_status));
-
+#endif
+#ifdef MOBILETEK_FOTA_CFG
+ fd_update_status = open(FILE_UPDATE_STATE,O_RDWR | O_CREAT,0777);
+ if (fd_update_status < 0) {
+ err = errno;
+ RLOGD("+[UA]: Error opening fd_update_status file: %s\n",strerror(errno));
+ return -err;
+ }
+#endif
lseek(fd_update_status,0,SEEK_SET);
+#ifdef MOBILETEK_FOTA_CFG
+ memset(&up_info, 0, sizeof(up_info));
+#endif
read(fd_update_status,(unsigned char *)&up_info,sizeof(up_info));
- LYVERBLOG("+[UA]: up_info.ota_run = %d\n",up_info.ota_run);
-
-
- if ((up_info.ota_run>PATCH_BL33)||(up_info.ota_run<PATCH_SYSTEM))
- {
- up_info.ota_run = 0;
- }
-
- up_info.ota_run = 0;
-
- if((up_info.fota_flag[0]=='A')&&(up_info.fota_flag[1]=='-')&&(up_info.fota_flag[2]=='B')){
- update_mode = MODE_A2B;
- }else if((up_info.fota_flag[0]=='B')&&(up_info.fota_flag[1]=='-')&&(up_info.fota_flag[2]=='A')){
- update_mode = MODE_B2A;
- }else{
- update_mode = MODE_NORMAL;
- }
-
- LYVERBLOG("+[UA]: up_info.fota_flag = %s\n",up_info.fota_flag);
- LYVERBLOG("+[UA]: update_mode = %d\n",update_mode);
-
+ RLOGD("+[UA]: up_info.ota_run = %d\n",up_info.ota_run);
+#ifdef MOBILETEK_FOTA_CFG
+ RLOGD("+[UA]: up_info.fota_flag = %s\n",up_info.fota_flag);
+#endif
+ if ((up_info.ota_run>PATCH_BL33)||(up_info.ota_run<PATCH_SYSTEM))
+ {
+ up_info.ota_run = 0;
+ }
+ up_info.ota_run = 0;
+ if((up_info.fota_flag[0]=='A')&&(up_info.fota_flag[1]=='-')&&(up_info.fota_flag[2]=='B'))
+ {
+ update_mode = MODE_A2B;
+ }
+ else if((up_info.fota_flag[0]=='B')&&(up_info.fota_flag[1]=='-')&&(up_info.fota_flag[2]=='A'))
+ {
+ update_mode = MODE_B2A;
+ }
+ else
+ {
+ update_mode = MODE_NORMAL;
+ }
+#ifdef GSW_FOTA_CFG
+ RLOGD("+[UA]: up_info.fota_flag = %s\n",up_info.fota_flag);
+#endif
+ RLOGD("+[UA]: update_mode = %d\n",update_mode);
memset(&da_head, 0, sizeof(da_head));
-
- read(fd_delta, (unsigned char*)&da_head, sizeof(da_head));
+ read(fd_delta, (unsigned char*)&da_head, sizeof(da_head));
#ifdef GSW_FOTA_CFG
rock_trace(&ctx, "da_head.sys:%d,da_head.boot:%d,da_head.tee:%d,da_head.md1img=%d,da_head.md1dsp=%d,da_head.vbmeta=%d,da_head.oemapp=%d,da_head.oemapp2=%d,da_head.bl33=%d\n", da_head.sys, da_head.boot,da_head.tee,da_head.md1img,da_head.md1dsp,da_head.vbmeta,da_head.oemapp,da_head.oemapp2,da_head.bl33);
@@ -756,7 +822,7 @@
fd_system_a = mtk_device_wrap_open(DEV_SYSTEM_A,O_RDWR);
if (fd_system_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening system file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -765,7 +831,7 @@
fd_system_b = mtk_device_wrap_open(DEV_SYSTEM_B,O_RDWR);
if (fd_system_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening system file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -795,13 +861,10 @@
sync();
- LYVERBLOG("+[UA]: Start upgrading system.\n");
+ RLOGD("+[UA]: Start upgrading system.\n");
status = iot_patch(&ctx);
- LYVERBLOG("+[UA]: system upgrade result:%d\n",status);
+ RLOGD("+[UA]: system upgrade result:%d\n",status);
- //up_info.ota_run = 0;
-
- //fota_status.ota_run = 0;
fota_status.update_status[PATCH_SYSTEM -1].update_result= status;
fota_status.update_result= status;
@@ -810,6 +873,7 @@
fota_status.update_status[PATCH_SYSTEM -1].check_delta = PASS;
fota_status.update_status[PATCH_SYSTEM -1].check_rom = PASS;
+ RLOGD("system upgrade success!!!\n");
}else if(status == E_ROCK_INVALID_DELTA) {
fota_status.update_status[PATCH_SYSTEM -1].check_delta = ERROR;
@@ -881,7 +945,7 @@
fd_boot_a = mtk_device_wrap_open(DEV_BOOT_A,O_RDWR);
if (fd_boot_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening boot file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -890,7 +954,7 @@
fd_boot_b = mtk_device_wrap_open(DEV_BOOT_B,O_RDWR);
if (fd_boot_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening boot file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -922,9 +986,9 @@
- LYVERBLOG("+[UA]: Start upgrading boot.\n");
+ RLOGD("+[UA]: Start upgrading boot.\n");
status = iot_patch(&ctx);
- LYVERBLOG("+[UA]: boot upgrade result:%d\n",status);
+ RLOGD("+[UA]: boot upgrade result:%d\n",status);
//up_info.ota_run = 0;
//fota_status.ota_run = 0;
@@ -936,6 +1000,7 @@
fota_status.update_status[PATCH_BOOT-1].check_delta = PASS;
fota_status.update_status[PATCH_BOOT-1].check_rom = PASS;
+ RLOGD("boot upgrade success!!!\n");
}else if(status == E_ROCK_INVALID_DELTA) {
fota_status.update_status[PATCH_BOOT-1].check_delta = ERROR;
@@ -1007,7 +1072,7 @@
fd_tee_a = mtk_device_wrap_open(DEV_TEE_A,O_RDWR);
if (fd_tee_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening tee file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1016,7 +1081,7 @@
fd_tee_b = mtk_device_wrap_open(DEV_TEE_B,O_RDWR);
if (fd_tee_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening tee file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1046,9 +1111,9 @@
write(fd_update_status, &up_info,sizeof(up_info));
sync();
- LYVERBLOG("+[UA]: Start upgrading tee.\n");
+ RLOGD("+[UA]: Start upgrading tee.\n");
status = iot_patch(&ctx);
- LYVERBLOG("+[UA]: tee upgrade result:%d\n",status);
+ RLOGD("+[UA]: tee upgrade result:%d\n",status);
//up_info.ota_run = 0;
//fota_status.ota_run = 0;
fota_status.update_status[PATCH_TEE-1].update_result= status;
@@ -1059,6 +1124,7 @@
fota_status.update_status[PATCH_TEE-1].check_delta = PASS;
fota_status.update_status[PATCH_TEE-1].check_rom = PASS;
+ RLOGD("tee upgrade success!!!\n");
}else if(status == E_ROCK_INVALID_DELTA) {
fota_status.update_status[PATCH_TEE-1].check_delta = ERROR;
@@ -1127,7 +1193,7 @@
fd_md1img_a = mtk_device_wrap_open(DEV_MD1IMG_A,O_RDWR);
if (fd_md1img_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening md1img file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1136,7 +1202,7 @@
fd_md1img_b = mtk_device_wrap_open(DEV_MD1IMG_B,O_RDWR);
if (fd_md1img_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening md1img file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1166,9 +1232,9 @@
sync();
- LYVERBLOG("+[UA]: Start upgrading md1img.\n");
+ RLOGD("+[UA]: Start upgrading md1img.\n");
status = iot_patch(&ctx);
- LYVERBLOG("+[UA]: md1img upgrade result:%d\n",status);
+ RLOGD("+[UA]: md1img upgrade result:%d\n",status);
//fota_status.ota_run = 0;
fota_status.update_status[PATCH_MD1IMG-1].update_result= status;
@@ -1179,6 +1245,7 @@
fota_status.update_status[PATCH_MD1IMG-1].check_delta = PASS;
fota_status.update_status[PATCH_MD1IMG-1].check_rom = PASS;
+ RLOGD("md1img upgrade success!!!\n");
}else if(status == E_ROCK_INVALID_DELTA) {
fota_status.update_status[PATCH_MD1IMG-1].check_delta = ERROR;
@@ -1247,7 +1314,7 @@
fd_md1dsp_a = mtk_device_wrap_open(DEV_MD1DSP_A,O_RDWR);
if (fd_md1dsp_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening md1dsp file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1256,7 +1323,7 @@
fd_md1dsp_b = mtk_device_wrap_open(DEV_MD1DSP_B,O_RDWR);
if (fd_md1dsp_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening md1dsp file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1288,9 +1355,9 @@
sync();
- LYVERBLOG("+[UA]: Start upgrading md1dsp.\n");
+ RLOGD("+[UA]: Start upgrading md1dsp.\n");
status = iot_patch(&ctx);
- LYVERBLOG("+[UA]: md1dsp upgrade result:%d\n",status);
+ RLOGD("+[UA]: md1dsp upgrade result:%d\n",status);
//fota_status.ota_run = 0;
fota_status.update_status[PATCH_MD1DSP-1].update_result= status;
@@ -1301,6 +1368,7 @@
fota_status.update_status[PATCH_MD1DSP-1].check_delta = PASS;
fota_status.update_status[PATCH_MD1DSP-1].check_rom = PASS;
+ RLOGD("md1dsp upgrade success!!!\n");
}else if(status == E_ROCK_INVALID_DELTA) {
fota_status.update_status[PATCH_MD1DSP-1].check_delta = ERROR;
@@ -1368,7 +1436,7 @@
fd_vbmeta_a = mtk_device_wrap_open(DEV_VBMETA_A,O_RDWR);
if (fd_vbmeta_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening vbmeta file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1377,7 +1445,7 @@
fd_vbmeta_b = mtk_device_wrap_open(DEV_VBMETA_B,O_RDWR);
if (fd_vbmeta_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening vbmeta file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1406,9 +1474,9 @@
write(fd_update_status, &up_info,sizeof(up_info));
sync();
- LYVERBLOG("+[UA]: Start upgrading vbmeta.\n");
+ RLOGD("+[UA]: Start upgrading vbmeta.\n");
status = iot_patch(&ctx);
- LYVERBLOG("+[UA]: vbmeta upgrade result:%d\n",status);
+ RLOGD("+[UA]: vbmeta upgrade result:%d\n",status);
up_info.ota_run = 0;
//fota_status.ota_run = 0;
@@ -1420,6 +1488,7 @@
fota_status.update_status[PATCH_VBMETA-1].check_delta = PASS;
fota_status.update_status[PATCH_VBMETA-1].check_rom = PASS;
+ RLOGD("vbmeta upgrade success!!!\n");
}else if(status == E_ROCK_INVALID_DELTA) {
fota_status.update_status[PATCH_VBMETA-1].check_delta = ERROR;
@@ -1720,7 +1789,7 @@
fd_bl33 = mtk_device_wrap_open(DEV_BL33,O_RDWR);
if (fd_bl33 < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1739,9 +1808,9 @@
write(fd_update_status, &up_info,sizeof(up_info));
sync();
- LYVERBLOG("+[UA]: Start upgrading bl33.\n");
+ RLOGD("+[UA]: Start upgrading bl33.\n");
status = iot_patch(&ctx);
- LYVERBLOG("+[UA]: bl33 upgrade result:%d\n",status);
+ RLOGD("+[UA]: bl33 upgrade result:%d\n",status);
up_info.ota_run = 0;
@@ -1753,6 +1822,7 @@
fota_status.update_status[PATCH_BL33-1].check_delta = PASS;
fota_status.update_status[PATCH_BL33-1].check_rom = PASS;
+ RLOGD("bl33 upgrade success!!!\n");
}else if(status == E_ROCK_INVALID_DELTA) {
fota_status.update_status[PATCH_BL33-1].check_delta = ERROR;
@@ -1812,7 +1882,7 @@
if (lseek(fd_delta, DELTA_HEARD_SIZE + delta_size, SEEK_SET) < 0) {
err = errno;
- LYERRLOG("+[UA]: mtk_device_wrap_seek df_delta err\n");
+ RLOGD("+[UA]: mtk_device_wrap_seek df_delta err\n");
lynq_fota_release_wake_lock();
return -1;
}
@@ -1821,7 +1891,7 @@
if (memcmp(full_header, "full-ota", DELTA_FULL_HEARD_SIZE) != 0) {
- LYERRLOG("+[UA]: invalid full delta header\r\n");
+ RLOGD("+[UA]: invalid full delta header\r\n");
up_info.fota_flag[0] = 'e';
up_info.fota_flag[1] = 'n';
up_info.fota_flag[2] = 'd';
@@ -1866,7 +1936,7 @@
fd_system_a = mtk_device_wrap_open(DEV_SYSTEM_A,O_RDWR);
if (fd_system_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening full_sys file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1875,7 +1945,7 @@
fd_system_b = mtk_device_wrap_open(DEV_SYSTEM_B,O_RDWR);
if (fd_system_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening full_sys file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1885,7 +1955,7 @@
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading system full.\n");
+ RLOGD("+[UA]: Start upgrading system full.\n");
do{
status = delta_copyto_nand(delta_offset,da_head.full_sys);
@@ -1896,7 +1966,7 @@
mtk_device_wrap_close(fd_curr);
- LYVERBLOG("+[UA]: system full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: system full retry_cnt = %d\n",retry_cnt);
if (retry_cnt>3) {
if (status == 0) {
@@ -1910,7 +1980,7 @@
}
}
- LYVERBLOG("+[UA]: system full upgrade result:%d\n",status);
+ RLOGD("+[UA]: system full upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_SYSTEM-1].update_result = status;
@@ -1951,7 +2021,7 @@
fd_boot_a = mtk_device_wrap_open(DEV_BOOT_A,O_RDWR);
if (fd_boot_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening full_boot file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1960,7 +2030,7 @@
fd_boot_b = mtk_device_wrap_open(DEV_BOOT_B,O_RDWR);
if (fd_boot_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening full_boot file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -1969,7 +2039,7 @@
fota_status.ota_run = FULL_BOOT;
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading boot full.\n");
+ RLOGD("+[UA]: Start upgrading boot full.\n");
do{
status = delta_copyto_nand(delta_offset,da_head.full_boot);
ROCK_SHA_FILE_COMMON(fd_delta,delta_offset,da_head.full_boot,digest_s);
@@ -1977,7 +2047,7 @@
retry_cnt++;
}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
- LYVERBLOG("+[UA]: boot full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: boot full retry_cnt = %d\n",retry_cnt);
mtk_device_wrap_close(fd_curr);
if (retry_cnt>3) {
@@ -1993,7 +2063,7 @@
}
- LYVERBLOG("+[UA]: boot full upgrade result:%d\n",status);
+ RLOGD("+[UA]: boot full upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_BOOT-1].update_result = status;
save_fota_status();
@@ -2032,7 +2102,7 @@
fd_tee_a = mtk_device_wrap_open(DEV_TEE_A,O_RDWR);
if (fd_tee_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening full_tee file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -2041,7 +2111,7 @@
fd_tee_b = mtk_device_wrap_open(DEV_TEE_B,O_RDWR);
if (fd_tee_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening full_tee file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -2050,7 +2120,7 @@
fota_status.ota_run = FULL_TEE;
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading tee full.\n");
+ RLOGD("+[UA]: Start upgrading tee full.\n");
do{
status = delta_copyto_nand(delta_offset,da_head.full_tee);
ROCK_SHA_FILE_COMMON(fd_delta,delta_offset,da_head.full_tee,digest_s);
@@ -2058,7 +2128,7 @@
retry_cnt++;
}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
mtk_device_wrap_close(fd_curr);
- LYVERBLOG("+[UA]: tee full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: tee full retry_cnt = %d\n",retry_cnt);
if (retry_cnt>3) {
if (status == 0) {
status = retry_cnt;
@@ -2110,7 +2180,7 @@
fd_md1img_a = mtk_device_wrap_open(DEV_MD1IMG_A,O_RDWR);
if (fd_md1img_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening full_md1img file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -2119,7 +2189,7 @@
fd_md1img_b = mtk_device_wrap_open(DEV_MD1IMG_B,O_RDWR);
if (fd_md1img_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening full_md1img file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -2128,7 +2198,7 @@
fota_status.ota_run = FULL_MD1IMG;
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading md1img full.\n");
+ RLOGD("+[UA]: Start upgrading md1img full.\n");
do{
status = delta_copyto_nand(delta_offset,da_head.full_md1img);
ROCK_SHA_FILE_COMMON(fd_delta,delta_offset,da_head.full_md1img,digest_s);
@@ -2137,7 +2207,7 @@
}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
mtk_device_wrap_close(fd_curr);
- LYVERBLOG("+[UA]: md1img full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: md1img full retry_cnt = %d\n",retry_cnt);
if (retry_cnt>3) {
if (status == 0) {
status = retry_cnt;
@@ -2150,7 +2220,7 @@
}
}
- LYVERBLOG("+[UA]: md1img upgrade result:%d\n",status);
+ RLOGD("+[UA]: md1img upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_MD1IMG-1].update_result = status;
save_fota_status();
@@ -2189,7 +2259,7 @@
fd_md1dsp_a = mtk_device_wrap_open(DEV_MD1DSP_A,O_RDWR);
if (fd_md1dsp_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening full_md1dsp file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -2198,7 +2268,7 @@
fd_md1dsp_b = mtk_device_wrap_open(DEV_MD1DSP_B,O_RDWR);
if (fd_md1dsp_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening full_md1dsp file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -2207,7 +2277,7 @@
fota_status.ota_run = FULL_MD1DSP;
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading md1dsp full.\n");
+ RLOGD("+[UA]: Start upgrading md1dsp full.\n");
do{
status = delta_copyto_nand(delta_offset,da_head.full_md1dsp);
ROCK_SHA_FILE_COMMON(fd_delta,delta_offset,da_head.full_md1dsp,digest_s);
@@ -2216,7 +2286,7 @@
}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
mtk_device_wrap_close(fd_curr);
- LYVERBLOG("+[UA]: md1dsp full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: md1dsp full retry_cnt = %d\n",retry_cnt);
if (retry_cnt>3) {
if (status == 0) {
status = retry_cnt;
@@ -2229,7 +2299,7 @@
}
}
- LYVERBLOG("+[UA]: md1dsp upgrade result:%d\n",status);
+ RLOGD("+[UA]: md1dsp upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_MD1DSP-1].update_result = status;
save_fota_status();
@@ -2268,7 +2338,7 @@
fd_vbmeta_a = mtk_device_wrap_open(DEV_VBMETA_A,O_RDWR);
if (fd_vbmeta_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening full_vbmeta file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -2277,7 +2347,7 @@
fd_vbmeta_b = mtk_device_wrap_open(DEV_VBMETA_B,O_RDWR);
if (fd_vbmeta_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening full_vbmeta file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -2286,7 +2356,7 @@
fota_status.ota_run = FULL_VBMETA;
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading vbmeta full.\n");
+ RLOGD("+[UA]: Start upgrading vbmeta full.\n");
do{
status = delta_copyto_nand(delta_offset,da_head.full_vbmeta);
ROCK_SHA_FILE_COMMON(fd_delta,delta_offset,da_head.full_vbmeta,digest_s);
@@ -2295,7 +2365,7 @@
}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
mtk_device_wrap_close(fd_curr);
- LYVERBLOG("+[UA]: vbmeta full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: vbmeta full retry_cnt = %d\n",retry_cnt);
if (retry_cnt>3) {
if (status == 0) {
status = retry_cnt;
@@ -2308,7 +2378,7 @@
}
}
- LYVERBLOG("+[UA]: vbmeta upgrade result:%d\n",status);
+ RLOGD("+[UA]: vbmeta upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_VBMETA-1].update_result = status;
save_fota_status();
@@ -2496,132 +2566,284 @@
if(update_mode == MODE_NORMAL){ //need A VS B
if(current_slot == SLOT_A) {
+ up_info.fota_flag[0] = 'B';
+ up_info.fota_flag[1] = '-';
+ up_info.fota_flag[2] = 'A';
+
+ }
+ else
+ {
- up_info.fota_flag[0] = 'B';
- up_info.fota_flag[1] = '-';
- up_info.fota_flag[2] = 'A';
-
- }else{
-
up_info.fota_flag[0] = 'A';
up_info.fota_flag[1] = '-';
up_info.fota_flag[2] = 'B';
}
-
- }else{
- up_info.fota_flag[0] = 'e';
- up_info.fota_flag[1] = 'n';
- up_info.fota_flag[2] = 'd';
-
- }
-
-
- up_info.update_result = status;
+ }
+ else
+ {
+ up_info.fota_flag[0] = 'e';
+ up_info.fota_flag[1] = 'n';
+ up_info.fota_flag[2] = 'd';
+ }
+ up_info.update_result = status;
up_info.ota_run = 0;
- lseek(fd_update_status,0,SEEK_SET);
- write(fd_update_status, &up_info,sizeof(up_info));
+ lseek(fd_update_status,0,SEEK_SET);
+ RLOGD("up_info: fota_flag: %s\n",up_info.fota_flag);
+ write(fd_update_status, &up_info,sizeof(up_info));
sync();
-
+#ifdef MOBILETEK_FOTA_CFG
+ close(fd_delta);
+#endif
+#ifdef GSW_FOTA_CFG
close_dev_fd(fd_delta);
-
+#endif
//close_dev_fd(fd_curr);
close(fd_update_status);
- sync();
-
+ sync();
- slot = (current_slot == 0) ? 1 : 0;
-
- LYVERBLOG("+[UA]: slot SLOT = %d\n",slot);
-
- if(update_mode==MODE_NORMAL){
- module->setActiveBootSlot(module,slot);
- LYVERBLOG("+[UA]: upgrade is success!!!!\n");
- }
+ slot = (current_slot == 0) ? 1 : 0;
+ RLOGD("+[UA]: slot SLOT = %d\n",slot);
+#ifdef MOBILETEK_FOTA_CFG
+ if(update_mode==MODE_NORMAL)
+ {
+ module->setActiveBootSlot(module,slot);
+ RLOGD("+[UA]:slot %d upgrade is success!!!!\n", slot);
+ }
+#endif
+#ifdef GSW_FOTA_CFG
+ if(switch_slot_flag==1)
+ {
+ module->setActiveBootSlot(module,slot);
+ RLOGD("+[UA]: upgrade is success!!!!\n");
+ }
+#endif
fota_status.ota_run = 0;
- fota_status.switch_slot = PASS;
- fota_status.update_result = status;
+ fota_status.switch_slot = PASS;
+ fota_status.update_result = status;
save_fota_status();
-
lynq_fota_release_wake_lock();
-
- if(update_mode==MODE_NORMAL){
- reboot_device();
- }
-
- return status;
+
+ if(update_mode==MODE_NORMAL)
+ {
+ reboot_device();
+ }
+
+ return status;
}
-
-static void rock_fail_handler() {
-
+#ifdef GSW_FOTA_CFG
+static void rock_fail_handler()
+{
+ int ret = 0;
+ RLOGD("rock_fail_handler start\n");
+ ret = rock_update_main(0, 0, 0, 0, 1, 1);
+ if(ret)
+ {
+ RLOGD("fota update fail again!\n");
+ }
}
+#endif
/* main entrpoint */
-int lynq_rock_main(int first_run) {
+int lynq_rock_main(int first_run)
+{
+ int ret = 0;
- int ret = 0;
-
#if 0
-
- printf("-********copy delta ***-\n");
- test_write_delta("/data/delta",DEV_DELTA);
-
-#endif
-
+
+ printf("-********copy delta ***-\n");
+ test_write_delta("/data/delta",DEV_DELTA);
+#endif
+#ifdef MOBILETEK_FOTA_CFG
ret = rock_update_main(0, 0, 0, 0, first_run);
- if(ret) {
- rock_fail_handler();
- }
- return ret;
+#endif
+#ifdef GSW_FOTA_CFG
+ ret = rock_update_main(0, 0, 0, 0, first_run, 1);
+#endif
+ RLOGD("rock_update_main ret = %d\n", ret);
+ if(ret)
+ {
+ RLOGD("fota update fail!\n");
+ }
+ return ret;
}
#endif
//lt add @2021.9.23 for deal with power down \ backup or upgrade.
+#ifdef GSW_FOTA_CFG
int lynq_fota_func(void)
{
+ int fd;
+ int first_run = 1;
+ int ret = 0;
+ UPDATE_INFO lynq_up_info;
+ memset(&lynq_up_info, 0, sizeof(lynq_up_info));
+ fd = open(FILE_UPDATE_STATE,O_RDWR | O_CREAT,0777);
+ if (fd < 0)
+ {
+ return -1;
+ }
+ read(fd,(unsigned char *)&lynq_up_info,sizeof(lynq_up_info));
+ close(fd);
- int fd;
- int first_run = 1;
- UPDATE_INFO lynq_up_info;
-
- memset(&lynq_up_info, 0, sizeof(lynq_up_info));
-
- fd = open(FILE_UPDATE_STATE,O_RDWR | O_CREAT,0777);
-
- if (fd < 0) {
- return -1;
- }
-
- read(fd,(unsigned char *)&lynq_up_info,sizeof(lynq_up_info));
- close(fd);
-
- if(lynq_up_info.ota_run != 0) {
- //Power off, call UA
- LYVERBLOG("[+UP]: ***Power off, call UA***\n");
- lynq_rock_main(first_run);
- }else if (((lynq_up_info.fota_flag[0]=='A')&&(lynq_up_info.fota_flag[1]=='-')&&(lynq_up_info.fota_flag[2]=='B'))||((lynq_up_info.fota_flag[0]=='B')&&(lynq_up_info.fota_flag[1]=='-')&&(lynq_up_info.fota_flag[2]=='A'))){
- //Upgrade the other side and call UA
- LYVERBLOG("[+UP]: ***Upgrade the other side and call UA***\n");
- lynq_rock_main(first_run);
- }
-/*
- else{
- //Normal procedure before, to check the upgrade package
-// LYVERBLOG("[+UP]: ***Normal procedure before, to check the upgrade package***\n");
-// lynq_rock_main(first_run);
- }*/
- return 0;
+ if(lynq_up_info.ota_run != 0)
+ {
+ //Power off, call UA
+ RLOGD("[+UP]: ***Power off, call UA***\n");
+ ret = rock_update_main(0, 0, 0, 0, first_run, 1);
+ RLOGD("rock_update_main ret = %d\n", ret);
+ if(ret)
+ {
+ RLOGD("fota update fail!\n");
+ }
+ }
+ if(((lynq_up_info.fota_flag[0]=='A')&&(lynq_up_info.fota_flag[1]=='-')&&(lynq_up_info.fota_flag[2]=='B'))||
+ ((lynq_up_info.fota_flag[0]=='B')&&(lynq_up_info.fota_flag[1]=='-')&&(lynq_up_info.fota_flag[2]=='A')))
+ {
+ //Upgrade the other side and call UA
+ RLOGD("[+UP]: ***Upgrade the other side and call UA***\n");
+ ret = rock_update_main(0, 0, 0, 0, first_run, 0);
+ RLOGD("rock_update_main ret = %d\n", ret);
+ if(ret)
+ {
+ RLOGD("fota update fail!\n");
+ }
+ }
+ return 0;
}
+#endif
+#ifdef MOBILETEK_FOTA_CFG
+int lynq_fota_func(void)
+{
+ int fd;
+ int first_run = 1;
+ UPDATE_INFO lynq_up_info;
+ memset(&lynq_up_info, 0, sizeof(lynq_up_info));
+ fd = open(FILE_UPDATE_STATE,O_RDWR | O_CREAT,0777);
+ if (fd < 0)
+ {
+ return -1;
+ }
+ read(fd,(unsigned char *)&lynq_up_info,sizeof(lynq_up_info));
+ close(fd);
+ RLOGD("lynq_up_info: fota_flag: %s\n",lynq_up_info.fota_flag);
+ if(lynq_up_info.ota_run != 0)
+ {
+ //Power off, call UA
+ RLOGD("[+UP]: ***Power off, call UA***\n");
+ lynq_rock_main(first_run);
+ }
+ if (((lynq_up_info.fota_flag[0]=='A')&&(lynq_up_info.fota_flag[1]=='-')&&(lynq_up_info.fota_flag[2]=='B'))||
+ ((lynq_up_info.fota_flag[0]=='B')&&(lynq_up_info.fota_flag[1]=='-')&&(lynq_up_info.fota_flag[2]=='A')))
+ {
+ //Upgrade the other side and call UA
+ RLOGD("[+UP]: ***Upgrade the other side and call UA***\n");
+ lynq_rock_main(first_run);
+ if( 0 != reset_fota_flag())
+ {
+ RLOGD("reset_fota_flag fail\n");
+ }
+ }
+ sleep(120);
+ check_ril_service();
+ return 0;
+}
+
+int reset_fota_flag(void)
+{
+ int err = 0;
+ fd_update_status = open(FILE_UPDATE_STATE,O_RDWR | O_CREAT,0777);
+ if (fd_update_status < 0) {
+ err = errno;
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ return err;
+ }
+ lseek(fd_update_status,0,SEEK_SET);
+ up_info.fota_flag[0] = 'e';
+ up_info.fota_flag[1] = 'n';
+ up_info.fota_flag[2] = 'd';
+ write(fd_update_status, &up_info,sizeof(up_info));
+ sync();
+ close(fd_update_status);
+ sync();
+ return err;
+
+}
+
+int get_fota_flag(void)
+{
+ int err = 0;
+ fd_update_status = open(FILE_UPDATE_STATE,O_RDWR | O_CREAT,0777);
+ if (fd_update_status < 0) {
+ err = errno;
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ return err;
+ }
+ lseek(fd_update_status,0,SEEK_SET);
+ memset(&up_info, 0, sizeof(up_info));
+ read(fd_update_status,(unsigned char *)&up_info,sizeof(up_info));
+ close(fd_update_status);
+ sync();
+ RLOGD("get_fota_flag: %s\n", up_info.fota_flag);
+ return err;
+}
+
+void check_ril_service(void)
+{
+ FILE *fp;
+ int ril_flag = 0;
+ char dtr_buffer[180];
+ char buffer[50] = "/usr/bin/lynq-ril-service";
+ fp = popen("ps -ef|grep lynq-ril","r");
+ fgets(dtr_buffer, sizeof(dtr_buffer), fp);
+ if(matchString(dtr_buffer, buffer) == 0)
+ {
+ ril_flag = 1;
+ }
+ pclose(fp);
+ if(ril_flag == 1)
+ {
+ reboot_device();
+ }
+}
+
+int matchString(char* buf, char* sub) {
+ char* tbuf = buf;
+ char* tsub = sub;
+ int i = 0;
+ int j = 0;
+ while (i <= strlen(tbuf ) - 1 && j <= strlen(tsub )-1)
+ {
+ if (tbuf [i] == tsub [j])
+ {
+ i++;
+ j++;
+ }
+ else
+ {
+ i = i - j + 1;
+ j = 0;
+ }
+ }
+
+ if (j == strlen(tsub))
+ {
+ return 1;
+ }
+
+ return 0;
+}
+#endif
int lynq_nand_open(const char *pathname, int flags)
{
@@ -2695,13 +2917,18 @@
*/
int lynq_fota_nrestart(void)
{
- int status,err,start;
+ int status,err;
+#ifdef GSW_FOTA_CFG
+ int start;
+#endif
int ret = 0;
int i = 0;
int retry_cnt = 0;
IOT_UPDATA_CONTEXT ctx;
+#ifdef GSW_FOTA_CFG
UPDATE_INFO up_info;
+#endif
//OTA_STATUS fota_status;
@@ -2723,7 +2950,7 @@
ret = -EINVAL;
}
if (ret != 0) {
- LYERRLOG("+[UA]: Error loading boot_control HAL implementation.\n");
+ RLOGD("+[UA]: Error loading boot_control HAL implementation.\n");
return -1;
}
@@ -2732,7 +2959,7 @@
if (module == NULL) {
- LYERRLOG("+[UA]: Error getting bootctrl module.\n");
+ RLOGD("+[UA]: Error getting bootctrl module.\n");
return -1;
}
@@ -2744,7 +2971,7 @@
int is_successful = module->isSlotMarkedSuccessful(module, current_slot);
- LYVERBLOG("Booting slot = %d, : isSlotMarkedSuccessful= %d\n",current_slot,is_successful);
+ RLOGD("Booting slot = %d, : isSlotMarkedSuccessful= %d\n",current_slot,is_successful);
@@ -2761,20 +2988,21 @@
if(0 != init_dev_fd())
{
- LYVERBLOG("+[UA]: get fota addr error\n");
+ RLOGD("+[UA]: get fota addr error\n");
lynq_fota_release_wake_lock();
return E_ROCK_FOTA_ADDR;
}
- memset(&up_info, 0, sizeof(up_info));
-
+
+#ifdef GSW_FOTA_CFG
memset(&fota_status,0,sizeof(fota_status));
-
+#endif
lseek(fd_update_status,0,SEEK_SET);
+ memset(&up_info, 0, sizeof(up_info));
read(fd_update_status,(unsigned char *)&up_info,sizeof(up_info));
- LYVERBLOG("+[UA]: up_info.ota_run = %d\n",up_info.ota_run);
+ RLOGD("+[UA]: up_info.ota_run = %d\n",up_info.ota_run);
if ((up_info.ota_run>PATCH_BL33)||(up_info.ota_run<PATCH_SYSTEM))
@@ -2792,8 +3020,8 @@
update_mode = MODE_NORMAL;
}
- LYVERBLOG("+[UA]: up_info.fota_flag = %s\n",up_info.fota_flag);
- LYVERBLOG("+[UA]: update_mode = %d\n",update_mode);
+ RLOGD("+[UA]: up_info.fota_flag = %s\n",up_info.fota_flag);
+ RLOGD("+[UA]: update_mode = %d\n",update_mode);
memset(&da_head, 0, sizeof(da_head));
@@ -3987,7 +4215,7 @@
if (lseek(fd_delta, DELTA_HEARD_SIZE + delta_size, SEEK_SET) < 0) {
err = errno;
- LYERRLOG("+[UA]: mtk_device_wrap_seek df_delta err\n");
+ RLOGD("+[UA]: mtk_device_wrap_seek df_delta err\n");
lynq_fota_release_wake_lock();
return -1;
}
@@ -3996,8 +4224,8 @@
if (memcmp(full_header, "full-ota", DELTA_FULL_HEARD_SIZE) != 0) {
- LYERRLOG("+[UA]: invalid full delta header\r\n");
- up_info.fota_flag[0] = 'e';
+ RLOGD("+[UA]: invalid full delta header\r\n");
+ up_info.fota_flag[0] = 'e';
up_info.fota_flag[1] = 'n';
up_info.fota_flag[2] = 'd';
up_info.update_result = -1;
@@ -4041,7 +4269,7 @@
fd_system_a = mtk_device_wrap_open(DEV_SYSTEM_A,O_RDWR);
if (fd_system_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4050,7 +4278,7 @@
fd_system_b = mtk_device_wrap_open(DEV_SYSTEM_B,O_RDWR);
if (fd_system_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4060,7 +4288,7 @@
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading system full.\n");
+ RLOGD("+[UA]: Start upgrading system full.\n");
do{
status = delta_copyto_nand(delta_offset,da_head.full_sys);
@@ -4071,7 +4299,7 @@
mtk_device_wrap_close(fd_curr);
- LYVERBLOG("+[UA]: system full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: system full retry_cnt = %d\n",retry_cnt);
if (retry_cnt>3) {
if (status == 0) {
@@ -4085,7 +4313,7 @@
}
}
- LYVERBLOG("+[UA]: system full upgrade result:%d\n",status);
+ RLOGD("+[UA]: system full upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_SYSTEM-1].update_result = status;
@@ -4126,7 +4354,7 @@
fd_boot_a = mtk_device_wrap_open(DEV_BOOT_A,O_RDWR);
if (fd_boot_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4135,7 +4363,7 @@
fd_boot_b = mtk_device_wrap_open(DEV_BOOT_B,O_RDWR);
if (fd_boot_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4144,7 +4372,7 @@
fota_status.ota_run = FULL_BOOT;
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading boot full.\n");
+ RLOGD("+[UA]: Start upgrading boot full.\n");
do{
status = delta_copyto_nand(delta_offset,da_head.full_boot);
ROCK_SHA_FILE_COMMON(fd_delta,delta_offset,da_head.full_boot,digest_s);
@@ -4152,7 +4380,7 @@
retry_cnt++;
}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
- LYVERBLOG("+[UA]: boot full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: boot full retry_cnt = %d\n",retry_cnt);
mtk_device_wrap_close(fd_curr);
if (retry_cnt>3) {
@@ -4168,7 +4396,7 @@
}
- LYVERBLOG("+[UA]: boot full upgrade result:%d\n",status);
+ RLOGD("+[UA]: boot full upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_BOOT-1].update_result = status;
save_fota_status();
@@ -4207,7 +4435,7 @@
fd_tee_a = mtk_device_wrap_open(DEV_TEE_A,O_RDWR);
if (fd_tee_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4216,7 +4444,7 @@
fd_tee_b = mtk_device_wrap_open(DEV_TEE_B,O_RDWR);
if (fd_tee_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4225,7 +4453,7 @@
fota_status.ota_run = FULL_TEE;
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading tee full.\n");
+ RLOGD("+[UA]: Start upgrading tee full.\n");
do{
status = delta_copyto_nand(delta_offset,da_head.full_tee);
ROCK_SHA_FILE_COMMON(fd_delta,delta_offset,da_head.full_tee,digest_s);
@@ -4233,7 +4461,7 @@
retry_cnt++;
}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
mtk_device_wrap_close(fd_curr);
- LYVERBLOG("+[UA]: tee full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: tee full retry_cnt = %d\n",retry_cnt);
if (retry_cnt>3) {
if (status == 0) {
status = retry_cnt;
@@ -4246,7 +4474,7 @@
}
}
- printf("+[UA] tee full upgrade result:%d\n",status);
+ RLOGD("+[UA] tee full upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_TEE-1].update_result = status;
save_fota_status();
@@ -4285,7 +4513,7 @@
fd_md1img_a = mtk_device_wrap_open(DEV_MD1IMG_A,O_RDWR);
if (fd_md1img_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4294,7 +4522,7 @@
fd_md1img_b = mtk_device_wrap_open(DEV_MD1IMG_B,O_RDWR);
if (fd_md1img_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4303,7 +4531,7 @@
fota_status.ota_run = FULL_MD1IMG;
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading md1img full.\n");
+ RLOGD("+[UA]: Start upgrading md1img full.\n");
do{
status = delta_copyto_nand(delta_offset,da_head.full_md1img);
ROCK_SHA_FILE_COMMON(fd_delta,delta_offset,da_head.full_md1img,digest_s);
@@ -4312,7 +4540,7 @@
}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
mtk_device_wrap_close(fd_curr);
- LYVERBLOG("+[UA]: md1img full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: md1img full retry_cnt = %d\n",retry_cnt);
if (retry_cnt>3) {
if (status == 0) {
status = retry_cnt;
@@ -4325,7 +4553,7 @@
}
}
- LYVERBLOG("+[UA]: md1img upgrade result:%d\n",status);
+ RLOGD("+[UA]: md1img upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_MD1IMG-1].update_result = status;
save_fota_status();
@@ -4364,7 +4592,7 @@
fd_md1dsp_a = mtk_device_wrap_open(DEV_MD1DSP_A,O_RDWR);
if (fd_md1dsp_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4373,7 +4601,7 @@
fd_md1dsp_b = mtk_device_wrap_open(DEV_MD1DSP_B,O_RDWR);
if (fd_md1dsp_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4382,7 +4610,7 @@
fota_status.ota_run = FULL_MD1DSP;
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading md1dsp full.\n");
+ RLOGD("+[UA]: Start upgrading md1dsp full.\n");
do{
status = delta_copyto_nand(delta_offset,da_head.full_md1dsp);
ROCK_SHA_FILE_COMMON(fd_delta,delta_offset,da_head.full_md1dsp,digest_s);
@@ -4391,7 +4619,7 @@
}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
mtk_device_wrap_close(fd_curr);
- LYVERBLOG("+[UA]: md1dsp full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: md1dsp full retry_cnt = %d\n",retry_cnt);
if (retry_cnt>3) {
if (status == 0) {
status = retry_cnt;
@@ -4404,7 +4632,7 @@
}
}
- LYVERBLOG("+[UA]: md1dsp upgrade result:%d\n",status);
+ RLOGD("+[UA]: md1dsp upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_MD1DSP-1].update_result = status;
save_fota_status();
@@ -4447,7 +4675,7 @@
fd_vbmeta_a = mtk_device_wrap_open(DEV_VBMETA_A,O_RDWR);
if (fd_vbmeta_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4456,7 +4684,7 @@
fd_vbmeta_b = mtk_device_wrap_open(DEV_VBMETA_B,O_RDWR);
if (fd_vbmeta_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4465,7 +4693,7 @@
fota_status.ota_run = FULL_VBMETA;
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading vbmeta full.\n");
+ RLOGD("+[UA]: Start upgrading vbmeta full.\n");
do{
status = delta_copyto_nand(delta_offset,da_head.full_vbmeta);
ROCK_SHA_FILE_COMMON(fd_delta,delta_offset,da_head.full_vbmeta,digest_s);
@@ -4474,7 +4702,7 @@
}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
mtk_device_wrap_close(fd_curr);
- LYVERBLOG("+[UA]: vbmeta full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: vbmeta full retry_cnt = %d\n",retry_cnt);
if (retry_cnt>3) {
if (status == 0) {
status = retry_cnt;
@@ -4487,7 +4715,7 @@
}
}
- LYVERBLOG("+[UA]: vbmeta upgrade result:%d\n",status);
+ RLOGD("+[UA]: vbmeta upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_VBMETA-1].update_result = status;
save_fota_status();
@@ -4525,7 +4753,7 @@
fd_oemapp_a = mtk_device_wrap_open(DEV_OEMAPP_A,O_RDWR);
if (fd_oemapp_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4534,7 +4762,7 @@
fd_oemapp_b = mtk_device_wrap_open(DEV_OEMAPP_B,O_RDWR);
if (fd_oemapp_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4543,7 +4771,7 @@
fota_status.ota_run = FULL_OEMAPP;
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading oemapp full.\n");
+ RLOGD("+[UA]: Start upgrading oemapp full.\n");
do {
status = delta_copyto_nand(delta_offset,da_head.full_oemapp);
ROCK_SHA_FILE_COMMON(fd_delta,delta_offset,da_head.full_oemapp,digest_s);
@@ -4552,7 +4780,7 @@
}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
mtk_device_wrap_close(fd_curr);
- LYVERBLOG("+[UA]: oemapp full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: oemapp full retry_cnt = %d\n",retry_cnt);
if (retry_cnt>3) {
if (status == 0) {
status = retry_cnt;
@@ -4565,7 +4793,7 @@
}
}
- LYVERBLOG("+[UA]: oemapp upgrade result:%d\n",status);
+ RLOGD("+[UA]: oemapp upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_OEMAPP-1].update_result = status;
save_fota_status();
@@ -4602,7 +4830,7 @@
fd_oemapp2_a = mtk_device_wrap_open(DEV_OEMAPP2_A,O_RDWR);
if (fd_oemapp2_a < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4611,7 +4839,7 @@
fd_oemapp2_b = mtk_device_wrap_open(DEV_OEMAPP2_B,O_RDWR);
if (fd_oemapp2_b < 0) {
err = errno;
- LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
lynq_fota_release_wake_lock();
return -err;
}
@@ -4620,7 +4848,7 @@
fota_status.ota_run = FULL_OEMAPP2;
save_fota_status();
retry_cnt = 0;
- LYVERBLOG("+[UA]: Start upgrading oemapp2 full.\n");
+ RLOGD("+[UA]: Start upgrading oemapp2 full.\n");
do {
status = delta_copyto_nand(delta_offset,da_head.full_oemapp2);
ROCK_SHA_FILE_COMMON(fd_delta,delta_offset,da_head.full_oemapp2,digest_s);
@@ -4628,7 +4856,7 @@
retry_cnt++;
}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
mtk_device_wrap_close(fd_curr);
- LYVERBLOG("+[UA]: oemapp2 full retry_cnt = %d\n",retry_cnt);
+ RLOGD("+[UA]: oemapp2 full retry_cnt = %d\n",retry_cnt);
if (retry_cnt>3) {
if (status == 0) {
status = retry_cnt;
@@ -4640,7 +4868,7 @@
nand_copyto_nand(DEV_OEMAPP2_A,DEV_OEMAPP2_B);
}
}
- LYVERBLOG("+[UA]: oemapp2 upgrade result:%d\n",status);
+ RLOGD("+[UA]: oemapp2 upgrade result:%d\n",status);
fota_status.update_result = status;
fota_status.update_status[FULL_OEMAPP2-1].update_result = status;
save_fota_status();
@@ -4691,34 +4919,42 @@
}
- up_info.update_result = status;
+ up_info.update_result = status;
up_info.ota_run = 0;
lseek(fd_update_status,0,SEEK_SET);
- write(fd_update_status, &up_info,sizeof(up_info));
+ write(fd_update_status, &up_info,sizeof(up_info));
sync();
-
+#ifdef GSW_FOTA_CFG
close_dev_fd(fd_delta);
+#endif
- //close_dev_fd(fd_curr);
+#ifdef MOBILETEK_FOTA_CFG
+ close(fd_delta);
+#endif
close(fd_update_status);
- sync();
-
+ sync();
- slot = (current_slot == 0) ? 1 : 0;
-
- LYVERBLOG("+[UA]: slot SLOT = %d\n",slot);
-
- if(update_mode==MODE_NORMAL){
- module->setActiveBootSlot(module,slot);
- LYVERBLOG("+[UA]: upgrade is success!!!!\n");
- }
+ slot = (current_slot == 0) ? 1 : 0;
+ RLOGD("+[UA]: slot SLOT = %d\n",slot);
+#ifdef MOBILETEK_FOTA_CFG
+ if(update_mode==MODE_NORMAL)
+ {
+ module->setActiveBootSlot(module,slot);
+ RLOGD("+[UA]: upgrade is success!!!!\n");
+ }
+#endif
+
+#ifdef GSW_FOTA_CFG
+ module->setActiveBootSlot(module,slot);
+ RLOGD("+[UA]: upgrade is success!!!!\n");
+#endif
fota_status.ota_run = 0;
- fota_status.switch_slot = PASS;
- fota_status.update_result = status;
+ fota_status.switch_slot = PASS;
+ fota_status.update_result = status;
save_fota_status();
lynq_fota_release_wake_lock();
@@ -4732,6 +4968,51 @@
* @param1 szie:fota addr length
* @return 0:set success other:set fail
*/
+#ifdef MOBILETEK_FOTA_CFG
+int lynq_fota_set_addr_value(char *value,int size)
+{
+ int err = 0;
+ fd_update_status = open(FILE_UPDATE_STATE,O_RDWR | O_CREAT,0777);
+ if (fd_update_status < 0) {
+ err = errno;
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ return err;
+ }
+ lseek(fd_update_status,0,SEEK_SET);
+ strcpy(up_info.addr,value);
+ write(fd_update_status, &up_info,sizeof(up_info));
+ sync();
+ close(fd_update_status);
+ sync();
+ return err;
+}
+/**
+ * @brief get the upgrade package address
+ *
+ * @param1 value:fota addr
+ * @return 0:get success other:set fail
+ */
+int lynq_fota_get_addr_value(char *tmp)
+{
+ int err;
+ fd_update_status = open(FILE_UPDATE_STATE,O_RDWR | O_CREAT,0777);
+ if (fd_update_status < 0) {
+ err = errno;
+ RLOGD("+[UA]: Error opening metadata file: %s\n",strerror(errno));
+ return err;
+ }
+ lseek(fd_update_status,0,SEEK_SET);
+ memset(&up_info, 0, sizeof(up_info));
+ read(fd_update_status,(unsigned char *)&up_info,sizeof(up_info));
+ strcpy(tmp, up_info.addr);
+ sync();
+ close(fd_update_status);
+ sync();
+ return 0;
+}
+#endif
+
+#ifdef GSW_FOTA_CFG
int lynq_fota_set_addr_value(char *value,int size)
{
if(size < 64)
@@ -4740,6 +5021,7 @@
}
return -1;
}
+
/**
* @brief get the upgrade package address
*
@@ -4750,7 +5032,7 @@
{
return lynq_get_value(FOTA_UCI_FILE, FOTA_UCI_MODULE,FOTA_UCI_ADDR, tmp);
}
-
+#endif
/**
* @brief The following is the wake up
* start
diff --git a/src/lynq/lib/liblynq-gnss/include/lynq_gnss.h b/src/lynq/lib/liblynq-gnss/include/lynq_gnss.h
index e7e3816..362baaf 100755
--- a/src/lynq/lib/liblynq-gnss/include/lynq_gnss.h
+++ b/src/lynq/lib/liblynq-gnss/include/lynq_gnss.h
@@ -78,6 +78,10 @@
gnss_measurement_ext_callback lynq_measurement_callback;
}lynq_raw_gnss_cbs;
+typedef void ( *lynq_atsvc_incb )(const char *input,const int length);
+typedef void ( *lynq_atsvc_outcb )(char *output,int out_size,int type);
+lynq_atsvc_incb lynq_register_gnss(lynq_atsvc_outcb out_cb);
+lynq_atsvc_outcb atsvc_gnss_outcb;
int lynq_gnss_init(void);
@@ -107,6 +111,10 @@
int lynq_gnss_output_frequency_set(int frequency);
+int lynq_agps_set_enabled(LYNQ_CONF_SWITCH agps_status);
+
+int lynq_agps_get_enabled_status(int *status);
+
#ifdef __cplusplus
}
#endif
diff --git a/src/lynq/lib/liblynq-gnss/makefile b/src/lynq/lib/liblynq-gnss/makefile
index 4d7cc72..f1ca7fc 100755
--- a/src/lynq/lib/liblynq-gnss/makefile
+++ b/src/lynq/lib/liblynq-gnss/makefile
@@ -15,7 +15,6 @@
-std=c++11 \
LOCAL_PATH = .
-$(warning ################# ZHOUQUNCHAO LOCAL_PATH:$(LOCAL_PATH),ROOT: $(ROOT),includedir:$(includedir),libdir:$(libdir))
LOCAL_C_INCLUDES = \
-I$(LOCAL_PATH)/include \
diff --git a/src/lynq/lib/liblynq-gnss/src/lynq_agps.c b/src/lynq/lib/liblynq-gnss/src/lynq_agps.c
new file mode 100644
index 0000000..762e36c
--- /dev/null
+++ b/src/lynq/lib/liblynq-gnss/src/lynq_agps.c
@@ -0,0 +1,509 @@
+#include <stdio.h>
+#include <sys/socket.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+#include <log/log.h>
+
+
+#include "lynq_gnss.h"
+#include "lynq_agps.h"
+
+#define LOG_TAG "LYNQ_AGPS"
+
+
+// -1 means failure
+int do_socket_connect(const char* path)
+{
+ struct sockaddr_un addr;
+ int fd = socket(PF_LOCAL, SOCK_STREAM, 0);
+ if(fd < 0) {
+ RLOGD("socket() failed fd=%d\n", fd);
+ return -1;
+ }
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_path[0] = 0;
+ memcpy(addr.sun_path + 1, path, strlen(path));
+ addr.sun_family = AF_UNIX;
+
+ if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+ RLOGD("connect failed reason=[%s] path=[%s]\n", strerror(errno), path);
+ close(fd);
+ return -1;
+ }
+
+ return fd;
+}
+
+//get
+char get_byte(char* buff, int* offset)
+{
+ char ret = buff[*offset];
+ *offset += 1;
+ return ret;
+}
+
+short get_short(char* buff, int* offset)
+{
+ short ret = 0;
+ ret |= get_byte(buff, offset) & 0xff;
+ ret |= (get_byte(buff, offset) << 8);
+ return ret;
+}
+
+int get_int(char* buff, int* offset)
+{
+ int ret = 0;
+ ret |= get_short(buff, offset) & 0xffff;
+ ret |= (get_short(buff, offset) << 16);
+ return ret;
+}
+
+int socket_connect() {
+ return do_socket_connect("agpsd2");
+}
+
+//-1 means failure
+static int safe_write(int fd, void* buf, int len)
+{
+ int n, retry = 10;
+
+ if(fd < 0 || buf == NULL || len < 0) {
+ RLOGD("safe_write fd=%d buf=%p len=%d\n", fd, buf, len);
+ return -1;
+ }
+
+ while((n = write(fd, buf, len)) != len) {
+ if(errno == EINTR) continue;
+ if(errno == EAGAIN) {
+ if(retry-- > 0) {
+ usleep(100 * 1000);
+ continue;
+ }
+ goto exit;
+ }
+ goto exit;
+ }
+ return n;
+exit:
+ RLOGD("safe_write reason=[%s]%d\n", strerror(errno), errno);
+ return -1;
+}
+
+//-1 means failure
+static int safe_read(int fd, void* buf, int len)
+{
+ int n, retry = 10;
+
+ if(fd < 0 || buf == NULL || len < 0)
+ {
+ RLOGD("safe_read fd=%d buf=%p len=%d\n", fd, buf, len);
+ return -1;
+ }
+
+ if(len == 0)
+ {
+ return 0;
+ }
+
+ while((n = read(fd, buf, len)) < 0)
+ {
+ if(errno == EINTR)
+ {
+ RLOGD("safe read interrupt");
+ continue;
+ }
+ if(errno == EAGAIN)
+ {
+ if(retry-- > 0)
+ {
+ usleep(100 * 1000);
+ continue;
+ }
+ goto exit;
+ }
+ goto exit;
+ }
+ return n;
+
+exit:
+ if(errno != EAGAIN)
+ {
+ RLOGD("safe_read reason=[%s] fd=%d len=%d buf=%p\n",
+ strerror(errno), fd, len, buf);
+ }
+ return -1;
+}
+
+static char socket_get_byte(int fd)
+{
+ int read_len = 0;
+ char buff[1] = {0};
+ int offset = 0;
+
+ read_len = safe_read(fd, buff, sizeof(buff));
+ if(read_len != sizeof(buff))
+ {
+ RLOGD("socket_get_byte read_len=%d\n", read_len);
+ }
+ return get_byte(buff, &offset);
+}
+
+static int socket_get_int(int fd)
+{
+ int read_len = 0;
+ char buff[4] = {0};
+ int offset = 0;
+
+ read_len = safe_read(fd, buff, sizeof(buff));
+ if(read_len != sizeof(buff))
+ {
+ RLOGD("socket_get_int read_len=%d\n", read_len);
+ }
+ return get_int(buff, &offset);
+}
+
+static char* socket_get_string(int fd, char* buff, int buff_len)
+{
+ int read_len = 0;
+
+ char ret = socket_get_byte(fd);
+ if(ret == 0)
+ {
+ return NULL;
+ }
+ else
+ {
+ int len = socket_get_int(fd);
+ if(len > buff_len)
+ {
+ RLOGD("socket_get_string your buff len=%d is too small, need len=%d\n",
+ buff_len, len);
+ return NULL;
+ }
+
+ read_len = safe_read(fd, buff, len);
+ if(read_len != len)
+ {
+ RLOGD("socket_get_string read_len=%d len=%d\n", read_len, len);
+ return NULL;
+ }
+
+ return buff;
+ }
+}
+
+
+static int socket_get_binary(int fd, char* buff)
+{
+ int read_len = 0;
+
+ int len = socket_get_int(fd);
+ if(len > 0)
+ {
+ read_len = safe_read(fd, buff, len);
+ if(read_len != len)
+ {
+ RLOGD("socket_get_binary read_len=%d len=%d\n", read_len, len);
+ return 0;
+ }
+ }
+ return len;
+}
+
+void put_byte(char* buff, int* offset, const char input)
+{
+ *((char*)&buff[*offset]) = input;
+ *offset += 1;
+}
+
+void put_short(char* buff, int* offset, const short input)
+{
+ put_byte(buff, offset, input & 0xff);
+ put_byte(buff, offset, (input >> 8) & 0xff);
+}
+
+void put_int(char* buff, int* offset, const int input)
+{
+ put_short(buff, offset, input & 0xffff);
+ put_short(buff, offset, (input >> 16) & 0xffff);
+}
+
+int set_template_1(app_mgr_cmd_enum cmd,char data)
+{
+ char buff[MAX_BUFF_SIZE] = {0};
+ int offset = 0;
+ int fd = 0;
+
+ fd = socket_connect();
+ if(fd < 0)
+ {
+ RLOGD("Socket connect fail");
+ return -1;
+ }
+ RLOGD("Set template start fd:%d cmd:%d data:%d",fd,cmd,data);
+ // write
+ put_int(buff, &offset, cmd);
+ put_byte(buff, &offset, data);
+ if(safe_write(fd, buff, offset) == -1)
+ {
+ RLOGD("set_template_1 Safe write fail");
+ close(fd);
+ return -1;
+ }
+
+ // read ACK
+ socket_get_byte(fd);
+
+ close(fd);
+ return 0;
+}
+
+int get_template_agps_config(app_mgr_cmd_enum cmd,agps_intf_agps_config *config)
+{
+ char buff[MAX_BUFF_SIZE] = {0};
+ int offset = 0;
+ int fd = 0;
+
+ fd = socket_connect();
+ if(fd < 0)
+ {
+ RLOGD("Socket connect fail");
+ return -1;
+ }
+ RLOGD("get_template_agps_config start fd:%d cmd:%d",fd,cmd);
+
+ // write
+ put_int(buff, &offset, cmd);
+ if(safe_write(fd, buff, offset) == -1)
+ {
+ RLOGD("get_template_agps_config Safe write fail");
+ close(fd);
+ return -1;
+ }
+
+ // read
+ config->agps_setting.agps_enable = socket_get_byte(fd);
+ config->agps_setting.agps_protocol = socket_get_int(fd);
+ config->agps_setting.gpevt = socket_get_byte(fd);
+
+ config->cp_setting.molr_pos_method = socket_get_int(fd);
+ config->cp_setting.external_addr_enable = socket_get_byte(fd);
+ socket_get_string(fd, config->cp_setting.external_addr, sizeof(config->cp_setting.external_addr));
+ config->cp_setting.mlc_number_enable = socket_get_byte(fd);
+ socket_get_string(fd, config->cp_setting.mlc_number, sizeof(config->cp_setting.mlc_number));
+ config->cp_setting.cp_auto_reset = socket_get_byte(fd);
+ config->cp_setting.epc_molr_lpp_payload_enable = socket_get_byte(fd);
+ config->cp_setting.epc_molr_lpp_payload_len =
+ socket_get_binary(fd, config->cp_setting.epc_molr_lpp_payload);
+
+ config->up_setting.ca_enable = socket_get_byte(fd);
+ config->up_setting.ni_request = socket_get_byte(fd);
+ config->up_setting.roaming = socket_get_byte(fd);
+ config->up_setting.cdma_preferred = socket_get_int(fd);
+ config->up_setting.pref_method = socket_get_int(fd);
+ config->up_setting.supl_version = socket_get_int(fd);
+ config->up_setting.tls_version = socket_get_int(fd);
+ config->up_setting.supl_log = socket_get_byte(fd);
+ config->up_setting.msa_enable = socket_get_byte(fd);
+ config->up_setting.msb_enable = socket_get_byte(fd);
+ config->up_setting.ecid_enable = socket_get_byte(fd);
+ config->up_setting.otdoa_enable = socket_get_byte(fd);
+ config->up_setting.qop_hacc = socket_get_int(fd);
+ config->up_setting.qop_vacc = socket_get_int(fd);
+ config->up_setting.qop_loc_age = socket_get_int(fd);
+ config->up_setting.qop_delay = socket_get_int(fd);
+ config->up_setting.lpp_enable = socket_get_byte(fd);
+ config->up_setting.cert_from_sdcard = socket_get_byte(fd);
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V14)
+ {
+ config->up_setting.auto_profile_enable = socket_get_byte(fd);
+ config->up_setting.ut2 = socket_get_byte(fd);
+ config->up_setting.ut3 = socket_get_byte(fd);
+ config->up_setting.apn_enable = socket_get_byte(fd);
+ config->up_setting.sync_to_slp = socket_get_byte(fd);
+ config->up_setting.udp_enable = socket_get_byte(fd);
+ config->up_setting.autonomous_enable = socket_get_byte(fd);
+ config->up_setting.aflt_enable = socket_get_byte(fd);
+ config->up_setting.imsi_enable = socket_get_byte(fd);
+
+ config->gnss_setting.sib8_sib16_enable = socket_get_byte(fd);
+ config->gnss_setting.gps_satellite_enable = socket_get_byte(fd);
+ config->gnss_setting.glonass_satellite_enable = socket_get_byte(fd);
+ config->gnss_setting.beidou_satellite_enable = socket_get_byte(fd);
+ config->gnss_setting.galileo_satellite_enable = socket_get_byte(fd);
+ config->gnss_setting.gps_satellite_support = socket_get_byte(fd);
+ config->gnss_setting.glonass_satellite_support = socket_get_byte(fd);
+ config->gnss_setting.beidou_satellite_support = socket_get_byte(fd);
+ config->gnss_setting.galileo_satellite_support = socket_get_byte(fd);
+
+ config->up_setting.supl_ver_minor = socket_get_byte(fd);
+ config->up_setting.supl_ver_ser_ind = socket_get_byte(fd);
+
+ config->gnss_setting.a_glonass_satellite_enable = socket_get_byte(fd);
+ }
+
+ socket_get_string(fd, config->cur_supl_profile.name, sizeof(config->cur_supl_profile.name));
+ socket_get_string(fd, config->cur_supl_profile.addr, sizeof(config->cur_supl_profile.addr));
+ config->cur_supl_profile.port = socket_get_int(fd);
+ config->cur_supl_profile.tls = socket_get_byte(fd);
+ socket_get_string(fd, config->cur_supl_profile.mcc_mnc, sizeof(config->cur_supl_profile.mcc_mnc));
+ socket_get_string(fd, config->cur_supl_profile.app_id, sizeof(config->cur_supl_profile.app_id));
+ socket_get_string(fd, config->cur_supl_profile.provider_id, sizeof(config->cur_supl_profile.provider_id));
+ socket_get_string(fd, config->cur_supl_profile.default_apn, sizeof(config->cur_supl_profile.default_apn));
+ socket_get_string(fd, config->cur_supl_profile.optional_apn, sizeof(config->cur_supl_profile.optional_apn));
+ socket_get_string(fd, config->cur_supl_profile.optional_apn_2, sizeof(config->cur_supl_profile.optional_apn_2));
+ socket_get_string(fd, config->cur_supl_profile.address_type, sizeof(config->cur_supl_profile.address_type));
+
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V14)
+ {
+ socket_get_string(fd, config->cdma_profile.name, sizeof(config->cdma_profile.name));
+ config->cdma_profile.mcp_enable = socket_get_byte(fd);;
+ socket_get_string(fd, config->cdma_profile.mcp_addr, sizeof(config->cdma_profile.mcp_addr));
+ config->cdma_profile.mcp_port = socket_get_int(fd);;
+ config->cdma_profile.pde_addr_valid = socket_get_byte(fd);;
+ config->cdma_profile.pde_ip_type = socket_get_int(fd);;
+ socket_get_string(fd, config->cdma_profile.pde_addr, sizeof(config->cdma_profile.pde_addr));
+ config->cdma_profile.pde_port = socket_get_int(fd);;
+ config->cdma_profile.pde_url_valid = socket_get_byte(fd);;
+ socket_get_string(fd, config->cdma_profile.pde_url_addr, sizeof(config->cdma_profile.pde_url_addr));
+ }
+
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V20)
+ {
+ //V15
+ config->agps_setting.e911_gps_icon_enable = socket_get_byte(fd);
+ //V16
+ config->agps_setting.e911_open_gps = socket_get_byte(fd);
+ //V17
+ config->gnss_setting.a_gps_satellite_enable = socket_get_byte(fd);
+ config->gnss_setting.a_beidou_satellite_enable = socket_get_byte(fd);
+ config->gnss_setting.a_galileo_satellite_enable = socket_get_byte(fd);
+ //V18
+ config->up_setting.sha_version = socket_get_int(fd);
+ config->up_setting.preferred_2g3g_cell_age = socket_get_int(fd);
+ config->up_setting.ut1 = socket_get_byte(fd);
+ config->up_setting.no_sensitive_log = socket_get_byte(fd);
+ config->up_setting.tls_reuse_enable = socket_get_byte(fd);
+ config->up_setting.imsi_cache_enable = socket_get_byte(fd);
+ config->up_setting.supl_raw_data_enable = socket_get_byte(fd);
+ config->up_setting.tc10_enable = socket_get_byte(fd);
+ config->up_setting.tc10_use_apn = socket_get_byte(fd);
+ config->up_setting.tc10_use_fw_dns = socket_get_byte(fd);
+ config->up_setting.allow_ni_for_gps_off = socket_get_byte(fd);
+ config->up_setting.force_otdoa_assist_req = socket_get_byte(fd);
+ config->cp_setting.reject_non911_nilr_enable = socket_get_byte(fd);
+ config->cp_setting.cp_2g_disable = socket_get_byte(fd);
+ config->cp_setting.cp_3g_disable = socket_get_byte(fd);
+ config->cp_setting.cp_4g_disable = socket_get_byte(fd);
+ config->agps_setting.tc10_ignore_fw_config = socket_get_byte(fd);
+ config->agps_setting.lppe_hide_wifi_bt_status = socket_get_byte(fd);
+ //V19
+ config->agps_setting.lppe_network_location_disable = socket_get_byte(fd);
+ config->cp_setting.cp_lppe_enable = socket_get_byte(fd);
+ config->up_setting.up_lppe_enable = socket_get_byte(fd);
+ //V20
+ config->cp_setting.support_cp_lppe = socket_get_byte(fd);
+ config->gnss_setting.mnl_support_lppe = socket_get_byte(fd);
+ }
+
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V21)
+ {
+ config->agps_setting.agps_nvram_enable = socket_get_byte(fd);
+ config->agps_setting.lbs_log_enable = socket_get_byte(fd);
+ config->agps_setting.lppe_crowd_source_confident = socket_get_int(fd);
+
+ config->up_setting.esupl_apn_mode = socket_get_int(fd);
+ config->up_setting.tcp_keepalive = socket_get_int(fd);
+ config->up_setting.aosp_profile_enable = socket_get_byte(fd);
+ config->up_setting.bind_nlp_setting_to_supl = socket_get_byte(fd);
+ }
+
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V22)
+ {
+ config->agps_setting.ignore_si_for_e911 = socket_get_byte(fd);
+ config->cp_setting.cp_lppe_wlan_enable = socket_get_byte(fd);
+ config->cp_setting.cp_lppe_srn_enable = socket_get_byte(fd);
+ config->cp_setting.cp_lppe_sensor_enable = socket_get_byte(fd);
+ config->cp_setting.cp_lppe_dbh_enable = socket_get_byte(fd);
+
+ config->up_setting.up_lppe_wlan_enable = socket_get_byte(fd);
+ config->up_setting.up_lppe_srn_enable = socket_get_byte(fd);
+ config->up_setting.up_lppe_sensor_enable = socket_get_byte(fd);
+ config->up_setting.up_lppe_dbh_enable = socket_get_byte(fd);
+ config->up_setting.ip_version_prefer = socket_get_int(fd);
+ config->up_setting.up_lppe_in_2g3g_disable = socket_get_byte(fd);
+ config->up_setting.up_rrlp_in_4g_disable = socket_get_byte(fd);
+ config->up_setting.up_si_disable = socket_get_byte(fd);
+ }
+
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V23)
+ {
+ config->up_setting.use_ni_slp = socket_get_byte(fd);
+ config->agps_setting.use_tc10_config = socket_get_byte(fd);
+ config->agps_setting.lppe_def_nlp_enable = socket_get_byte(fd);
+ }
+
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V24)
+ {
+ config->agps_setting.emergency_ext_secs = socket_get_int(fd);
+ config->up_setting.aosp_pos_mode_enable = socket_get_byte(fd);
+ config->up_setting.privacy_override_mode = socket_get_int(fd);
+ }
+
+ config->valid = 1;
+ // read ACK
+ socket_get_byte(fd);
+ RLOGD("Socket read ACK sucess, close fd");
+ close(fd);
+ return 0;
+}
+
+int agps_get_total_status(agps_intf_agps_config *config)
+{
+ if (NULL == config)
+ {
+ RLOGD("agps_get_total_status incoming paramter error");
+ }
+ int res = 0;
+ res = get_template_agps_config(APP_MGR_CMD_GET_CONFIG_V24,config);
+ return res;
+}
+
+
+int lynq_agps_set_enabled(LYNQ_CONF_SWITCH agps_status)
+{
+ int ret = -1;
+
+ ret = set_template_1(APP_MGR_CMD_SET_AGPS_ENABLE,agps_status);
+ if (ret != 0)
+ {
+ RLOGD("set AGPS error ret = %d",ret);
+ return ret;
+ }
+ return ret;
+}
+
+int lynq_agps_get_enabled_status(int *status)
+{
+ int ret = 0;
+ if (NULL == status)
+ {
+ RLOGD("incoming paramter error");
+ return -1;
+ }
+
+ agps_intf_agps_config config;
+ memset(&config, 0, sizeof(config));
+ ret = agps_get_total_status(&config);
+ if (ret != 0)
+ {
+ RLOGD("agps get status fail");
+ return ret;
+ }
+ *status = config.agps_setting.agps_enable;
+ return ret;
+}
\ No newline at end of file
diff --git a/src/lynq/lib/liblynq-gnss/src/lynq_agps.h b/src/lynq/lib/liblynq-gnss/src/lynq_agps.h
new file mode 100644
index 0000000..f3da3d3
--- /dev/null
+++ b/src/lynq/lib/liblynq-gnss/src/lynq_agps.h
@@ -0,0 +1,393 @@
+#ifndef LYNQ_AGPS_H
+#define LYNQ_AGPS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*Copy for agps_interface.h*/
+#define agps_bool char
+
+#define MAX_BUFF_SIZE 8192
+#define SUPL_PROFILES_NUM 30
+
+#define AGPS_INTF_STRING_LEN 64
+#define AGPS_SUPL_ADDR_LEN 128
+#define MNL_MCC_STRING_LEN 16
+#define EXTERNAL_ADD_LEN 20
+#define MLC_NUMBER_LEN 20
+#define EPC_MOLR_LPP_PAYLOAD_LEN 300
+#define SUPL_PROFILES_NUM 30
+#define PROFILING_MESSAGE_LEN 64
+#define PROFILING_ELEMENT_NUM 20
+
+typedef enum {
+ // Command Enum APP -> AGPSD
+ APP_MGR_CMD_CODER_TEST = 0,
+ APP_MGR_CMD_VERSION = 1,
+
+ APP_MGR_CMD_GET_CONFIG = 100, //AgpsConfig
+ APP_MGR_CMD_GET_OMA_CP_SUPL_PROFILE = 101,
+ APP_MGR_CMD_GET_SYSTEM_PROPERTY = 102,
+ APP_MGR_CMD_GET_AGPS_PROFILING = 103,
+ APP_MGR_CMD_GET_EMULATOR_MODE = 104,
+ APP_MGR_CMD_GET_CONFIG_V2 = 105,
+ APP_MGR_CMD_GET_CONFIG_V3 = 106, // add cert_from_sdcard
+ APP_MGR_CMD_GET_CONFIG_V14 = 117,
+ APP_MGR_CMD_GET_CONFIG_V20 = 123,
+ APP_MGR_CMD_GET_CONFIG_V21 = 124,
+ APP_MGR_CMD_GET_CONFIG_V22 = 125,
+ APP_MGR_CMD_GET_CONFIG_V23 = 126,
+ APP_MGR_CMD_GET_CONFIG_V24 = 127,
+
+ APP_MGR_CMD_SET_AGPS_ENABLE = 200,
+ APP_MGR_CMD_SET_PROTOCOL,
+ APP_MGR_CMD_SET_CDMA_PREF,
+ APP_MGR_CMD_SET_UP_PREF_METHOD,
+ APP_MGR_CMD_SET_POS_TECHNOLOGY_MSA,
+ APP_MGR_CMD_SET_POS_TECHNOLOGY_MSB,
+ APP_MGR_CMD_SET_POS_TECHNOLOGY_ECID,
+ APP_MGR_CMD_SET_POS_TECHNOLOGY_OTDOA,
+ APP_MGR_CMD_SET_SUPL_VERSION,
+ APP_MGR_CMD_SET_SUPL_PROFILE, //AgpsProfil
+ APP_MGR_CMD_SET_QOP = 210, //AgpsQoP
+ APP_MGR_CMD_SET_MOLR_POS_METHDO,
+ APP_MGR_CMD_SET_EXTERNAL_ADDR,
+ APP_MGR_CMD_SET_MLC_NUMBER,
+ APP_MGR_CMD_SET_CP_AUTO_RESET,
+ APP_MGR_CMD_SET_ALLOW_NI,
+ APP_MGR_CMD_SET_ALLOW_ROAMING,
+ APP_MGR_CMD_SET_SUPL_2_FILE,
+ APP_MGR_CMD_SET_RESET_TO_DEFAULT,
+ APP_MGR_CMD_SET_OMA_CP_SUPL_PROFILE,
+ APP_MGR_CMD_SET_NI_REQ = 220, //un-implemented for test
+ APP_MGR_CMD_SET_EPC_MOLR_PDU_ENABLE,
+ APP_MGR_CMD_SET_EPC_MOLR_PDU,
+ APP_MGR_CMD_SET_TLS_VERSION,
+ APP_MGR_CMD_SET_CA_ENABLE,
+ APP_MGR_CMD_SET_UDP_ENABLE,
+ APP_MGR_CMD_SET_LPP_ENABLE,
+ APP_MGR_CMD_SET_CERT_FROM_SDCARD_ENABLE,
+ APP_MGR_CMD_SET_AUTO_PROFILE_ENABLE,
+ APP_MGR_CMD_SET_UT2,
+ APP_MGR_CMD_SET_UT3 = 230,
+ APP_MGR_CMD_SET_SUPL_APN_ENABLE,
+ APP_MGR_CMD_SET_SYNC_TO_SLP,
+ APP_MGR_CMD_SET_UDP_ENABLE_V2,
+ APP_MGR_CMD_SET_AUTONOMOUS_ENABLE,
+ APP_MGR_CMD_SET_AFLT_ENABLE,
+ APP_MGR_CMD_SET_IMSI_ENABLE,
+ APP_MGR_CMD_SET_SIB8_16_ENABLE,
+ APP_MGR_CMD_SET_GPS_ENABLE,
+ APP_MGR_CMD_SET_GLONASS_ENABLE,
+ APP_MGR_CMD_SET_BEIDOU_ENABLE = 240,
+ APP_MGR_CMD_SET_GALILEO_ENABLE,
+ APP_MGR_CMD_SET_SUPL_SHA_VERSION,
+ APP_MGR_CMD_SET_SUPL_TLS_VERSION,
+ APP_MGR_CMD_SET_SUPL_VER_MINOR,
+ APP_MGR_CMD_SET_SUPL_VER_SER_IND,
+ APP_MGR_CMD_SET_A_GLONASS_ENABLE,
+ APP_MGR_CMD_SET_PDE_PROFILE,
+ APP_MGR_CMD_SET_E911_GPS_ICON_ENABLE,
+ APP_MGR_CMD_SET_E911_OPEN_GPS_ENABLE,
+ APP_MGR_CMD_SET_A_GPS_ENABLE = 250,
+ APP_MGR_CMD_SET_A_BEIDOU_ENABLE,
+ APP_MGR_CMD_SET_A_GALILEO_ENABLE,
+ APP_MGR_CMD_SET_PREF_2G3G_CELL_AGE,
+ APP_MGR_CMD_SET_UT1,
+ APP_MGR_CMD_SET_NO_SENSITIVE_LOG,
+ APP_MGR_CMD_SET_TLS_REUSE_ENABLE,
+ APP_MGR_CMD_SET_IMSI_CACHE_ENABLE,
+ APP_MGR_CMD_SET_SUPL_RAW_DATA_ENABLE,
+ APP_MGR_CMD_SET_TC10_ENABLE,
+ APP_MGR_CMD_SET_TC10_USE_APN = 260,
+ APP_MGR_CMD_SET_TC10_USE_FW_DNS,
+ APP_MGR_CMD_SET_ALLOW_NI_FOR_GPS_OFF,
+ APP_MGR_CMD_SET_FORCE_OTDOA_ASSIST_REQ,
+ APP_MGR_CMD_SET_REJECT_NON911_NILR_ENABLE,
+ APP_MGR_CMD_SET_CP_2G_DISABLE,
+ APP_MGR_CMD_SET_CP_3G_DISABLE,
+ APP_MGR_CMD_SET_CP_4G_DISABLE,
+ APP_MGR_CMD_SET_TC10_IGNORE_FW_CONFIG,
+ APP_MGR_CMD_SET_LPPE_HIDE_WIFI_BT_STATUS,
+ APP_MGR_CMD_SET_LPPE_NETWORK_LOCATION_DISABLE = 270,
+ APP_MGR_CMD_SET_LPPE_CP_ENABLE,
+ APP_MGR_CMD_SET_LPPE_UP_ENABLE,
+ APP_MGR_CMD_SET_VZW_DEBUG_SCREEN_ENABLE,
+ APP_MGR_CMD_SET_AOSP_PROFILE_ENABLE,
+ APP_MGR_CMD_SET_BIND_NLP_SETTING_TO_SUPL,
+ APP_MGR_CMD_SET_ESUPL_APN_MODE,
+ APP_MGR_CMD_SET_TCP_KEEPALIVE,
+ APP_MGR_CMD_SET_AGPS_NVRAM_ENABLE,
+ APP_MGR_CMD_SET_LBS_LOG_ENABLE,
+ APP_MGR_CMD_SET_LPPE_CROWD_SOURCE_CONFIDENT = 280,
+ APP_MGR_CMD_SET_IGNORE_SI_FOR_E911,
+ APP_MGR_CMD_SET_LPPE_CP_WLAN_ENABLE,
+ APP_MGR_CMD_SET_LPPE_CP_SRN_ENABLE,
+ APP_MGR_CMD_SET_LPPE_CP_SENSOR_ENABLE,
+ APP_MGR_CMD_SET_LPPE_CP_DBH_ENABLE,
+ APP_MGR_CMD_SET_LPPE_UP_WLAN_ENABLE,
+ APP_MGR_CMD_SET_LPPE_UP_SRN_ENABLE,
+ APP_MGR_CMD_SET_LPPE_UP_SENSOR_ENABLE,
+ APP_MGR_CMD_SET_LPPE_UP_DBH_ENABLE,
+ APP_MGR_CMD_SET_IP_VERSION_PREFER = 290,
+ APP_MGR_CMD_SET_UP_LPP_IN_2G3G_DISABLE,
+ APP_MGR_CMD_SET_UP_RRLP_IN_4G_DISABLE,
+ APP_MGR_CMD_UP_SI_DISABLE,
+
+ // To implement
+ APP_MGR_CMD_SET_USE_NI_SLP,
+ APP_MGR_CMD_SET_USE_TC10_CONFIG,
+ APP_MGR_CMD_SET_LPPE_DEF_NLP_ENABLE,
+ APP_MGR_CMD_SET_AOSP_POS_MODE_ENABLE,
+ APP_MGR_CMD_SET_PRIVACY_OVERRIDE_MODE,
+ APP_MGR_CMD_SET_EMERGENCY_EXT_SECS, // 299
+
+
+ APP_MGR_CMD_START_PERIODIC = 300,
+ APP_MGR_CMD_ABORT_PERIODIC,
+ APP_MGR_CMD_START_AREA_EVENT,
+ APP_MGR_CMD_ABORT_AREA_EVENT,
+
+ APP_MGR_CMD_START_TEST_CASE = 400,
+ APP_MGR_CMD_START_TEST_BUTTON,
+ APP_MGR_CMD_START_RESET_AGPSD,
+ APP_MGR_CMD_START_EMULATOR_MODE,
+
+
+ // To implement
+ APP_MGR_CMD_SET_TC10_SUPL_SSL_METHOD = 500,
+ APP_MGR_CMD_SET_TC10_AUTO_SUPL_VER_FOR_NI,
+ APP_MGR_CMD_SET_TC10_SUPL_VER_SKT_NI,
+ APP_MGR_CMD_SET_TC10_USE_APN_NI,
+ APP_MGR_CMD_SET_TC10_USE_APN_SI,
+ APP_MGR_CMD_SET_CP_PRIVACY_OVERRIDE,
+ APP_MGR_CMD_SET_SUPL_ADDR_NI,
+ APP_MGR_CMD_SET_RRLP_GOOGLE_SUPL,
+ APP_MGR_CMD_SET_SUPL2_CAP_EXT_DISABLE,
+ APP_MGR_CMD_SET_NI_STATISTIC_ENABLE,
+ APP_MGR_CMD_SET_UP_OPERATION_MODE, // 510
+ APP_MGR_CMD_SET_GLONASS_MSA_ENABLE,
+ APP_MGR_CMD_SET_GLONASS_MSB_ENABLE,
+ APP_MGR_CMD_SET_BEIDOU_MSA_ENABLE,
+ APP_MGR_CMD_SET_BEIDOU_MSB_ENABLE,
+ APP_MGR_CMD_SET_GALILEO_MSA_ENABLE,
+ APP_MGR_CMD_SET_GALILEO_MSB_ENABLE,
+ APP_MGR_CMD_SET_TC10_AUTO_SUPL_VER_FOR_ENI,
+ APP_MGR_CMD_SET_TC10_CP_LPP_GUARD_TIME_SEC,
+ APP_MGR_CMD_SET_TC10_CP_CAPABILITY_VALID_ENABLE,
+ APP_MGR_CMD_SET_TC10_CP_CAPABILITY_ENABLE, // 520
+ APP_MGR_CMD_SET_IGNORE_EMERGENCY_EXT_SECS_FROM_FRAMEWORK,
+ APP_MGR_CMD_GET_AGPSD_VERSION,
+ APP_MGR_CMD_GET_IMSI,
+} app_mgr_cmd_enum;
+
+typedef enum {
+ AGPS_INTF_PDE_IP_TYPE_IPV4 = 0,
+ AGPS_INTF_PDE_IP_TYPE_IPV6 = 1,
+} agps_intf_pde_ip_type;
+
+typedef enum {
+ AGPS_INTF_CDMA_PREFERRED_WCDMA = 0,
+ AGPS_INTF_CDMA_PREFERRED_CDMA = 1,
+ AGPS_INTF_CDMA_PREFERRED_CDMA_FORCE = 2,
+} agps_intf_cdma_preferred;
+
+typedef enum {
+ AGPS_INTF_PREF_METHOD_MSA = 0,
+ AGPS_INTF_PREF_METHOD_MSB = 1,
+ AGPS_INTF_PREF_METHOD_NO_PREF = 2,
+} agps_intf_pref_method;
+
+typedef enum {
+ AGPS_INTF_AGPS_PROTOCOL_UP = 0,
+ AGPS_INTF_AGPS_PROTOCOL_CP = 1,
+} agps_intf_agps_protocol;
+
+typedef enum {
+ AGPS_INTF_SUPL_VERSION_1 = 1,
+ AGPS_INTF_SUPL_VERSION_2 = 2,
+} agps_intf_supl_version;
+
+typedef enum {
+ AGPS_INTF_TLS_VERSION_1_0 = 0,
+ AGPS_INTF_TLS_VERSION_1_1 = 1,
+ AGPS_INTF_TLS_VERSION_1_2 = 2,
+} agps_intf_tls_version;
+
+typedef enum {
+ AGPS_INTF_ESUPL_APN_EIMS_IMS = 0,
+ AGPS_INTF_ESUPL_APN_EIMS = 1,
+ AGPS_INTF_ESUPL_APN_IMS = 2,
+ AGPS_INTF_ESUPL_APN_AS_NORMAL = 3,
+} agps_intf_esupl_apn;
+
+typedef enum {
+ AGPS_INTF_MOLR_POS_METHOD_LOC_EST = 0,
+ AGPS_INTF_MOLR_POS_METHOD_ASSIST_DATA = 1,
+} agps_intf_molr_pos_method;
+
+typedef struct {
+ char name[AGPS_INTF_STRING_LEN];
+ char addr[AGPS_SUPL_ADDR_LEN];
+ int port;
+ agps_bool tls;
+ char mcc_mnc[MNL_MCC_STRING_LEN];
+ char app_id[AGPS_INTF_STRING_LEN];
+ char provider_id[AGPS_INTF_STRING_LEN];
+ char default_apn[AGPS_INTF_STRING_LEN];
+ char optional_apn[AGPS_INTF_STRING_LEN];
+ char optional_apn_2[AGPS_INTF_STRING_LEN];
+ char address_type[AGPS_INTF_STRING_LEN];
+} agps_intf_supl_profile;
+
+typedef struct {
+ char name[AGPS_INTF_STRING_LEN];
+ agps_bool mcp_enable;
+ char mcp_addr[AGPS_INTF_STRING_LEN];
+ int mcp_port;
+ agps_bool pde_addr_valid;
+ agps_intf_pde_ip_type pde_ip_type; //0=IPV4 1=IPV6
+ char pde_addr[AGPS_INTF_STRING_LEN];
+ int pde_port;
+ agps_bool pde_url_valid;
+ char pde_url_addr[AGPS_INTF_STRING_LEN];
+} agps_intf_cdma_profile;
+
+typedef struct {
+ agps_bool agps_enable;
+ agps_intf_agps_protocol agps_protocol;
+ agps_bool gpevt;
+ agps_bool e911_gps_icon_enable;
+ agps_bool e911_open_gps;
+ agps_bool tc10_ignore_fw_config;
+ agps_bool lppe_hide_wifi_bt_status;
+ agps_bool lppe_network_location_disable;
+ agps_bool agps_nvram_enable;
+ agps_bool lbs_log_enable;
+ int lppe_crowd_source_confident;
+ agps_bool ignore_si_for_e911; // North America operator 'V' asks us to ignore SI triggered by GMS
+ agps_bool use_tc10_config;
+ agps_bool lppe_def_nlp_enable;
+ int emergency_ext_secs;
+} agps_intf_agps_setting;
+
+typedef struct {
+ agps_intf_molr_pos_method molr_pos_method;
+ agps_bool external_addr_enable;
+ char external_addr[EXTERNAL_ADD_LEN];
+ agps_bool mlc_number_enable;
+ char mlc_number[MLC_NUMBER_LEN];
+ agps_bool cp_auto_reset;
+ agps_bool epc_molr_lpp_payload_enable;
+ int epc_molr_lpp_payload_len;
+ char epc_molr_lpp_payload[EPC_MOLR_LPP_PAYLOAD_LEN];
+ agps_bool cp_lppe_enable;
+ agps_bool support_cp_lppe;
+ agps_bool reject_non911_nilr_enable;
+ agps_bool cp_2g_disable;
+ agps_bool cp_3g_disable;
+ agps_bool cp_4g_disable;
+ agps_bool cp_lppe_wlan_enable;
+ agps_bool cp_lppe_srn_enable;
+ agps_bool cp_lppe_sensor_enable;
+ agps_bool cp_lppe_dbh_enable;
+} agps_intf_cp_setting;
+
+typedef struct {
+ agps_bool ca_enable;
+ agps_bool ni_request;
+ agps_bool roaming;
+ agps_intf_cdma_preferred cdma_preferred;
+ agps_intf_pref_method pref_method;
+ agps_intf_supl_version supl_version;
+ agps_intf_tls_version tls_version;
+ agps_bool supl_log;
+ agps_bool msa_enable;
+ agps_bool msb_enable;
+ agps_bool ecid_enable;
+ agps_bool otdoa_enable;
+ int qop_hacc;
+ int qop_vacc;
+ int qop_loc_age;
+ int qop_delay;
+ agps_bool lpp_enable;
+ agps_bool cert_from_sdcard;
+ agps_bool auto_profile_enable;
+ char ut2;
+ char ut3;
+ agps_bool apn_enable;
+ agps_bool sync_to_slp;
+ agps_bool udp_enable;
+ agps_bool autonomous_enable;
+ agps_bool aflt_enable;
+ agps_bool imsi_enable;
+ char supl_ver_minor;
+ char supl_ver_ser_ind;
+ int sha_version; // 0: SHA1 for SUPL1.0 and SHA256 for SUPL2.0, 1: SHA1 for SUPL1.0 and SUPL2.0, 2: SHA256 for SUPL1.0 and SUPL2.0
+ int preferred_2g3g_cell_age;
+ char ut1;
+ agps_bool no_sensitive_log;
+ agps_bool tls_reuse_enable;
+ agps_bool imsi_cache_enable;
+ agps_bool supl_raw_data_enable;
+ agps_bool tc10_enable;
+ agps_bool tc10_use_apn;
+ agps_bool tc10_use_fw_dns;
+ agps_bool allow_ni_for_gps_off;
+ agps_bool force_otdoa_assist_req;
+ agps_bool up_lppe_enable;
+ agps_intf_esupl_apn esupl_apn_mode;
+ int tcp_keepalive;
+ agps_bool aosp_profile_enable;
+ agps_bool bind_nlp_setting_to_supl;
+ agps_bool up_lppe_wlan_enable;
+ agps_bool up_lppe_srn_enable;
+ agps_bool up_lppe_sensor_enable;
+ agps_bool up_lppe_dbh_enable;
+ int ip_version_prefer; //0=IPv6 prefer 1=IPv4 prefer
+ agps_bool up_lppe_in_2g3g_disable; // For ATT SUPL server
+ agps_bool up_rrlp_in_4g_disable; // For ATT SUPL server
+ agps_bool up_si_disable; // For Sprint
+ agps_bool use_ni_slp; // tc10 (ALPS04423530)
+ agps_bool aosp_pos_mode_enable;
+ int privacy_override_mode;
+} agps_intf_up_setting;
+
+typedef struct {
+ agps_bool sib8_sib16_enable;
+ agps_bool gps_satellite_enable;
+ agps_bool glonass_satellite_enable;
+ agps_bool beidou_satellite_enable;
+ agps_bool galileo_satellite_enable;
+ agps_bool a_glonass_satellite_enable;
+
+ agps_bool gps_satellite_support;
+ agps_bool glonass_satellite_support;
+ agps_bool beidou_satellite_support;
+ agps_bool galileo_satellite_support;
+
+ agps_bool a_gps_satellite_enable;
+ agps_bool a_beidou_satellite_enable;
+ agps_bool a_galileo_satellite_enable;
+
+ agps_bool mnl_support_lppe;
+} agps_intf_gnss_setting;
+
+typedef struct {
+ int supl_profiles_num;
+ agps_intf_supl_profile supl_profiles[SUPL_PROFILES_NUM];
+ agps_intf_supl_profile cur_supl_profile;
+ agps_intf_cdma_profile cdma_profile;
+ agps_intf_agps_setting agps_setting;
+ agps_intf_cp_setting cp_setting;
+ agps_intf_up_setting up_setting;
+ agps_intf_gnss_setting gnss_setting;
+ agps_bool valid;
+} agps_intf_agps_config;
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
\ No newline at end of file
diff --git a/src/lynq/lib/liblynq-gnss/src/lynq_callback.c b/src/lynq/lib/liblynq-gnss/src/lynq_callback.c
index 09f6d2b..b8a402f 100755
--- a/src/lynq/lib/liblynq-gnss/src/lynq_callback.c
+++ b/src/lynq/lib/liblynq-gnss/src/lynq_callback.c
@@ -141,3 +141,69 @@
{
return &lynq_test_raw_callbacks;
}
+
+
+void lynq_at_gps_location_callback(lynq_GpsLocation_ext* location)
+{
+
+}
+
+void lynq_at_gps_status_callback(GpsStatus* status)
+{
+
+}
+
+#define NMEA_ACC "ACCURACY"
+#define NMEA_GSA "GSA"
+#define NMEA_RMC "RMC"
+#define NMEA_GGA "GGA"
+#define NMEA_VTG "VTG"
+#define NMEA_GSV "GSV"
+
+void lynq_at_gps_nmea_callback(GpsUtcTime timestamp, const char* nmea, int length)
+{
+ if (at_gpsnmea_status == 1)
+ {
+ if(strncmp(nmea+3,NMEA_GSA,strlen(NMEA_GSA))==0 || strncmp(nmea+3,NMEA_RMC,strlen(NMEA_RMC)) == 0 || \
+ strncmp(nmea+3,NMEA_GGA,strlen(NMEA_GGA)) == 0 || strncmp(nmea+3,NMEA_VTG,strlen(NMEA_VTG)) == 0|| \
+ strncmp(nmea+3,NMEA_GSV,strlen(NMEA_GSV)) == 0)
+ {
+ atsvc_gnss_outcb(nmea,strlen(nmea),1);
+ }
+ }
+}
+
+
+
+pthread_t lynq_at_gps_create_thread(const char* name, void (*start)(void *), void* arg)
+{
+ pthread_t at_ntid = 0;
+ int ret = 0;
+
+ ret = pthread_create(&at_ntid, NULL, (void *(*)(void *))start, arg);
+
+ if(ret != 0)
+ {
+ printf("thread %s create fail(%s)!\r\n", name, strerror(errno));
+ at_ntid = 0;
+ }
+ else
+ {
+ printf("tread %s create success!\r\n", name);
+ }
+
+ return at_ntid;
+}
+
+lynq_gnss_cb lynq_at_gnss_callbacks = {
+ .size = sizeof(lynq_gnss_cb),
+ .lynq_location_cb =lynq_at_gps_location_callback,
+ .lynq_status_cb = lynq_at_gps_status_callback,
+ .lynq_nmea_cb = lynq_at_gps_nmea_callback,
+ .lynq_create_thread_cb = lynq_at_gps_create_thread,
+};
+
+lynq_gnss_cb* lynq_at_get__gnss_callbacks(void)
+{
+ return &lynq_at_gnss_callbacks;
+}
diff --git a/src/lynq/lib/liblynq-gnss/src/lynq_gnss.c b/src/lynq/lib/liblynq-gnss/src/lynq_gnss.c
index 12e717e..3565676 100755
--- a/src/lynq/lib/liblynq-gnss/src/lynq_gnss.c
+++ b/src/lynq/lib/liblynq-gnss/src/lynq_gnss.c
@@ -15,6 +15,7 @@
#include <semaphore.h>
#include <pthread.h>
#include <log/log.h>
+#include <stdlib.h>
#include "lynq_gnss.h"
#include "gpshal.h"
@@ -33,6 +34,7 @@
GpsCallbacks_ext* turn_cbs = NULL;
GpsMeasurementCallbacks_ext* raw_cbs = NULL;
+lynq_gnss_cb* lynq_at_callbacks = NULL ;
/**
* @brief mark gnss initialization state
* 0: deinit state
@@ -304,3 +306,274 @@
mnld_write_cfg(LYNQ_OUTPUT_FREQUENCY,freq);
return 0;
}
+
+lynq_atsvc_outcb atsvc_gnss_outcb;
+void atsvc_incb_entity(const char *input,const int length);
+int lynq_at_cgps(int at_type,char *at_paramter);
+int lynq_at_cgpsnmea(int at_type,char *at_paramter);
+
+int at_gps_status = 0;
+int at_gpsnmea_status = 0;
+
+int strUpper(char * str)
+{
+ int i=0;
+ while(1)
+ {
+ if(str[i]=='\0')
+ {
+ break;
+ }
+ if(str[i]>='a'&&str[i]<='z')
+ {
+ str[i]=str[i]-32;
+ }
+ i++;
+ }
+ return 0;
+}
+
+int gnss_at_cmd_parse(char *cmd,char *parse_cmd[],int* at_type)
+{
+ if (NULL == cmd || NULL == parse_cmd || NULL == at_type)
+ {
+ return -1;
+ }
+ int ret = 0;
+ int at_type_jug = 0;
+ int cmd_size;
+ char cmd_buf[128] = {0};
+ char buffer1[128] = {0};
+ char buffer2[128] = {0};
+ bzero(cmd_buf,128);
+ bzero(buffer1,128);
+ bzero(buffer2,128);
+ cmd_size = strlen(cmd);
+ memcpy(cmd_buf,cmd,cmd_size);
+ strUpper(cmd_buf);
+ ret = sscanf(cmd_buf, "%[^=]=%[^=]", buffer1,buffer2);
+ if (ret == 1)
+ {
+ *at_type = 1;
+ sscanf(buffer1, "%[^?]", buffer2);
+ strcpy(parse_cmd[0],buffer2);
+ return 0;
+ }
+ else if (ret == 2)
+ {
+ at_type_jug = strcmp(buffer2,"?");
+ RLOGD("at_type_jug :%d",at_type_jug);
+ if (at_type_jug == 0)
+ {
+ *at_type = 0;
+ strcpy(parse_cmd[0],buffer1);
+ return 0;
+ }
+ else
+ {
+ *at_type = 2;
+ RLOGD("Buffertest1:buffer1 :%s buffer2 :%s",buffer1,buffer2);
+ strcpy(parse_cmd[0],buffer1);
+ strcpy(parse_cmd[1],buffer2);
+ RLOGD("buffer1 :%s buffer2 :%s",parse_cmd[0],parse_cmd[1]);
+ return 0;
+ }
+ }
+ else
+ {
+ RLOGD("unknown paramters");
+ return -1;
+ }
+}
+
+lynq_atsvc_incb lynq_register_gnss(lynq_atsvc_outcb out_cb)
+{
+ char reg_return[100] = {0};
+ if(NULL == out_cb)
+ {
+ RLOGD("out cb is null");
+ return NULL;
+ }
+ atsvc_gnss_outcb=out_cb;
+ memcpy(reg_return,"gnss register success\r\n",24);
+ atsvc_gnss_outcb(reg_return,24,0);
+ return atsvc_incb_entity;
+}
+
+
+void atsvc_incb_entity(const char *input,const int length)
+{
+ int res = 0;
+ int income_at_type = 0;
+ char at_cmd[512]={0};
+ char gnss_at_cmd[100] = {0};
+ char *parse_atcmd[128]; //argv[0]:at cmd,argv[2]:at paramter
+ if(NULL == input)
+ {
+ RLOGD("input is null");
+ memcpy(gnss_at_cmd,"+CME ERROR: 100\r\n",strlen("+CME ERROR: 100\r\n"));
+ atsvc_gnss_outcb(gnss_at_cmd,strlen("+CME ERROR: 100\r\n"),0);
+ return -1;
+ }
+ if (strlen(input) >= 128)
+ {
+ RLOGD("input size more than 128");
+ memcpy(gnss_at_cmd,"+CME ERROR: 100\r\n",strlen("+CME ERROR: 100\r\n"));
+ atsvc_gnss_outcb(gnss_at_cmd,strlen("+CME ERROR: 100\r\n"),0);
+ return -1;
+ }
+ bzero(at_cmd,512);
+ memcpy(at_cmd,input,strlen(input));
+ res = gnss_at_cmd_parse(at_cmd,parse_atcmd,&income_at_type);
+ if (res != 0)
+ {
+ RLOGD("parse at cmd error");
+ return -1;
+ }
+
+ if (!strcmp(parse_atcmd[0], "AT+CGPS"))
+ {
+ res = lynq_at_cgps(income_at_type,parse_atcmd[1]);
+ if (res != 0)
+ {
+ RLOGD("cgps unknown error");
+ }
+ }
+ else if (!strcmp(parse_atcmd[0], "AT+CGPSNMEA"))
+ {
+ lynq_at_cgpsnmea(income_at_type,parse_atcmd[1]);
+ }
+ else
+ {
+ memcpy(gnss_at_cmd,"+CME ERROR: 100\r\n",strlen("+CME ERROR: 100\r\n"));
+ }
+ memcpy(gnss_at_cmd,"OK\r\n",4);
+ atsvc_gnss_outcb(gnss_at_cmd,4,0);
+}
+
+
+int lynq_at_cgps(int at_type,char *at_paramter)
+{
+ int ret = 0;
+ char cgps_at_res[512]={};
+
+ if (at_type == LYNQ_ATCMD_TEST)
+ {
+ bzero(cgps_at_res,512);
+ memcpy(cgps_at_res,"+CGPS:(0,1)\r\n",strlen("+CGPS:(0,1)"));
+ atsvc_gnss_outcb(cgps_at_res,strlen("+CGPS:(0,1)\r\n"),0);
+ return 0;
+ }
+ else if(at_type == LYNQ_ATCMD_READ)
+ {
+ bzero(cgps_at_res,512);
+ sprintf(cgps_at_res,"+CGPS:<%d>",at_gps_status);
+ atsvc_gnss_outcb(cgps_at_res,strlen(cgps_at_res),0);
+ return 0;
+ }
+ else if(at_type == LYNQ_ATCMD_WRITE)
+ {
+ if (at_gps_status != atoi(at_paramter))
+ {
+ at_gps_status = atoi(at_paramter);
+ }
+ else
+ {
+ bzero(cgps_at_res,512);
+ memcpy(cgps_at_res,"+CGPS ERROR: same status\r\n",strlen("+CGPS ERROR: same status\r\n"));
+ atsvc_gnss_outcb(cgps_at_res,strlen(cgps_at_res),0);
+ return -1;
+ }
+ if (at_gps_status == 0)
+ {
+ ret = lynq_gnss_stop();
+ if (ret != 0)
+ {
+ RLOGD("lynq gnss stop fail");
+ return -1;
+ }
+ ret = lynq_gnss_deinit();
+ if (ret != 0)
+ {
+ RLOGD("lynq gnss deinit fail");
+ return -1;
+ }
+ bzero(cgps_at_res,512);
+ memcpy(cgps_at_res,"+CGPS OK\r\n",strlen("+CGPS OK\r\n"));
+ atsvc_gnss_outcb(cgps_at_res,strlen(cgps_at_res),0);
+ }
+ else if(at_gps_status == 1)
+ {
+ lynq_at_callbacks = lynq_at_get__gnss_callbacks();
+ ret = lynq_gnss_callback_reg(lynq_at_callbacks);
+ if (ret != 0)
+ {
+ RLOGD("lynq gnss callback reg fail");
+ return -1;
+ }
+ ret = lynq_gnss_init();
+ if (ret != 0)
+ {
+ RLOGD("lynq gnss init fail");
+ return -1;
+ }
+ ret = lynq_gnss_start();
+ if (ret != 0)
+ {
+ RLOGD("lynq gnss init fail");
+ return -1;
+ }
+ bzero(cgps_at_res,512);
+ memcpy(cgps_at_res,"+CGPS OK\r\n",strlen("+CGPS OK\r\n"));
+ atsvc_gnss_outcb(cgps_at_res,strlen(cgps_at_res),0);
+ }
+ else
+ {
+ RLOGD("unknown at paramters");
+ bzero(cgps_at_res,512);
+ memcpy(cgps_at_res,"+CGPS ERROR: 100\r\n",strlen("+CGPS ERROR: 100\r\n"));
+ atsvc_gnss_outcb(cgps_at_res,strlen("+CGPS ERROR: 100\r\n"),0);
+ }
+ return 0;
+ }
+}
+
+
+int lynq_at_cgpsnmea(int at_type,char *at_paramter)
+{
+ int ret = 0;
+ char cgpsnmea_at_res[512]={};
+
+ if (at_type == LYNQ_ATCMD_TEST)
+ {
+ bzero(cgpsnmea_at_res,512);
+ memcpy(cgpsnmea_at_res,"+CGPSNMEA:(0,1)\r\n",strlen("+CGPSNMEA:(0,1)"));
+ atsvc_gnss_outcb(cgpsnmea_at_res,strlen(cgpsnmea_at_res),0);
+ return 0;
+ }
+ else if(at_type == LYNQ_ATCMD_READ)
+ {
+ bzero(cgpsnmea_at_res,512);
+ sprintf(cgpsnmea_at_res,"+CGPSNMEA:<%d>",at_gpsnmea_status);
+ atsvc_gnss_outcb(cgpsnmea_at_res,strlen(cgpsnmea_at_res),0);
+ return 0;
+ }
+ else if(at_type == LYNQ_ATCMD_WRITE)
+ {
+ if (at_gpsnmea_status != atoi(at_paramter))
+ {
+ at_gpsnmea_status = atoi(at_paramter);
+ bzero(cgpsnmea_at_res,512);
+ memcpy(cgpsnmea_at_res,"+CGPSNMEA OK\r\n",strlen("+CGPSNMEA OK\r\n"));
+ atsvc_gnss_outcb(cgpsnmea_at_res,strlen(cgpsnmea_at_res),0);
+ }
+ else
+ {
+ RLOGD("unknown at paramters");
+ bzero(cgpsnmea_at_res,512);
+ memcpy(cgpsnmea_at_res,"+CGPSNMEA ERROR: 100\r\n",strlen("+CGPSNMEA ERROR: 100\r\n"));
+ atsvc_gnss_outcb(cgpsnmea_at_res,strlen(cgpsnmea_at_res),0);
+ }
+ return 0;
+ }
+}
\ No newline at end of file
diff --git a/src/lynq/lib/liblynq-gnss/src/lynq_gnsshal.h b/src/lynq/lib/liblynq-gnss/src/lynq_gnsshal.h
index a7687fe..04938c9 100755
--- a/src/lynq/lib/liblynq-gnss/src/lynq_gnsshal.h
+++ b/src/lynq/lib/liblynq-gnss/src/lynq_gnsshal.h
@@ -6,6 +6,7 @@
#endif
#include<pthread.h>
+#include "lynq_gnss.h"
#include "hardware/gps_mtk.h"
#include "hal2mnl_interface.h"
#include "gpshal.h"
@@ -37,6 +38,17 @@
GpsMeasurementCallbacks_ext* lynq_gnss_get_raw_callbacks(void);
+lynq_gnss_cb* lynq_at_get__gnss_callbacks(void);
+
+extern lynq_atsvc_outcb atsvc_gnss_outcb;
+extern int at_gpsnmea_status;
+
+typedef enum{
+ LYNQ_ATCMD_TEST = 0,
+ LYNQ_ATCMD_READ,
+ LYNQ_ATCMD_WRITE
+}LYNQ_ATCMD_TYPE;
+
#ifdef __cplusplus
}
#endif
diff --git a/src/lynq/lib/liblynq-network/LICENSE b/src/lynq/lib/liblynq-network/LICENSE
index 77f59ed..605b7ea 100755
--- a/src/lynq/lib/liblynq-network/LICENSE
+++ b/src/lynq/lib/liblynq-network/LICENSE
@@ -1,31 +1,31 @@
Copyright Statement:
-This software/firmware and related documentation ("MediaTek Software") are
+This software/firmware and related documentation ("MobileTek Software") are
protected under relevant copyright laws. The information contained herein is
-confidential and proprietary to MediaTek Inc. and/or its licensors. Without
-the prior written permission of MediaTek inc. and/or its licensors, any
-reproduction, modification, use or disclosure of MediaTek Software, and
+confidential and proprietary to MobileTek Inc. and/or its licensors. Without
+the prior written permission of MobileTek inc. and/or its licensors, any
+reproduction, modification, use or disclosure of MobileTek Software, and
information contained herein, in whole or in part, shall be strictly
prohibited.
-MediaTek Inc. (C) 2015. All rights reserved.
+MobileTek Inc. (C) 2015. All rights reserved.
BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
-THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
-RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
-ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
+THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MobileTek SOFTWARE")
+RECEIVED FROM MobileTek AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
+ON AN "AS-IS" BASIS ONLY. MobileTek EXPRESSLY DISCLAIMS ANY AND ALL
WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
-NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
+NONINFRINGEMENT. NEITHER DOES MobileTek PROVIDE ANY WARRANTY WHATSOEVER WITH
RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
-INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
+INCORPORATED IN, OR SUPPLIED WITH THE MobileTek SOFTWARE, AND RECEIVER AGREES
TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
-OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
-SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
+OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MobileTek
+SOFTWARE. MobileTek SHALL ALSO NOT BE RESPONSIBLE FOR ANY MobileTek SOFTWARE
RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
-STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
-ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
-RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
-MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
-CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
+STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MobileTek'S
+ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MobileTek SOFTWARE
+RELEASED HEREUNDER WILL BE, AT MobileTek'S OPTION, TO REVISE OR REPLACE THE
+MobileTek SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
+CHARGE PAID BY RECEIVER TO MobileTek FOR SUCH MobileTek SOFTWARE AT ISSUE.
diff --git a/src/lynq/lib/liblynq-network/lynq_module_common.h b/src/lynq/lib/liblynq-network/lynq_module_common.h
index a582538..57ea5b2 100755
--- a/src/lynq/lib/liblynq-network/lynq_module_common.h
+++ b/src/lynq/lib/liblynq-network/lynq_module_common.h
@@ -28,6 +28,8 @@
#define LYNQ_REQUEST_RECORD (LYNQ_REQUEST_VENDOR_BASE +11)
#define LYNQ_REQUEST_OOS_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +12)
#define LYNQ_REQUEST_OOS_DEEP_SLEEP_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +13)
+#define LYNQ_REQUEST_CHANGE_SCREEN_STATE (LYNQ_REQUEST_VENDOR_BASE + 14)/*jb.qi add for two sim suspend 2022/9/19*/
+#define LYNQ_REQUEST_CHANGE_RADIO (LYNQ_REQUEST_VENDOR_BASE + 15)
/*the same with lynq_interface.h end*/
typedef enum{
@@ -60,4 +62,7 @@
#define MODULE_CLOSED (0)
#define MODULE_SWITCHING (1)
#define MODULE_RUNNING (2)
+
+extern int g_module_init_flag;
+
#endif
diff --git a/src/lynq/lib/liblynq-network/lynq_module_socket.cpp b/src/lynq/lib/liblynq-network/lynq_module_socket.cpp
index fa71d82..c3f7334 100755
--- a/src/lynq/lib/liblynq-network/lynq_module_socket.cpp
+++ b/src/lynq/lib/liblynq-network/lynq_module_socket.cpp
@@ -15,6 +15,7 @@
#include "lynq_module_common.h"
#include "lynq_module_socket.h"
#include "liblog/lynq_deflog.h"
+#include "lynq_shm.h"
#define LYNQ_SERVICE_PORT 8088
#define LYNQ_ADDRESS "127.0.0.1"
@@ -40,6 +41,11 @@
int error;
}lynq_resp_t;
+typedef struct{
+ int resp_type;
+ int urcid;
+}lynq_head_t;
+
lynq_client_t client_t;
lynq_resp_t response;
@@ -67,6 +73,21 @@
const int waitResponse(int token,int time_out);
/*hq add for set waiting time 2022/09/13 end*/
+/*hq add for urc process asynchronous 2022/12/26 begin*/
+static pthread_mutex_t s_ProcessUrcMsgBlockMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_WaitProcessUrcMsgCond = PTHREAD_COND_INITIALIZER;
+
+#define BLOCK_PROCESS_URC_MSG_INIT() pthread_mutex_init(&s_ProcessUrcMsgBlockMutex,NULL)
+#define BLOCK_PROCESS_URC_MSG_LOCK() pthread_mutex_lock(&s_ProcessUrcMsgBlockMutex)
+#define BLOCK_PROCESS_URC_MSG_UNLOCK() pthread_mutex_unlock(&s_ProcessUrcMsgBlockMutex)
+#define BLOCK_WAIT_PROCESS_URC_MSG() pthread_cond_wait(&s_WaitProcessUrcMsgCond, &s_ProcessUrcMsgBlockMutex)
+#define BLOCK_WAKEUP_PROCESS_URC_MSG() pthread_cond_broadcast(&s_WaitProcessUrcMsgCond)
+static std::list<Parcel*> s_recv_urc_parcel_list;
+void *thread_urc_process(void *p);
+pthread_t module_urc_process_tid = -1;
+int module_urc_process_status = 1;
+/*hq add for urc process asynchronous 2022/12/26 end*/
+
int g_module_Global_uToken = 0;
int g_wait_time=5;
@@ -118,7 +139,7 @@
std::list<Parcel*>::iterator iter;
int cnt=0;
- gettimeofday(&now,NULL);
+ gettimeofday(&now,NULL);
timeout.tv_sec = now.tv_sec+time_out; //timeout is 1min
timeout.tv_nsec = now.tv_usec*1000;
@@ -268,6 +289,295 @@
return ret;
}
+/*hq add for urc broadcase optimisson 2023/01/03 begin*/
+#define SHM_BUFFER_INDEX_OFFSET 1
+#define SHM_BUFFER_SIZE_OFFSET 16
+#define SHM_BUFFER_INDEX_MASK 0x0000007F
+#define SHM_BUFFER_SIZE_MASK 0x0000FFFF
+
+bool urc_data_is_in_shm_data(int responseType,int& level, int& index, int& size)
+{
+ int shm_index=((responseType>>SHM_BUFFER_INDEX_OFFSET)&SHM_BUFFER_INDEX_MASK);
+ if (shm_index>0)
+ {
+ index=shm_index-1;
+ size=((responseType>>SHM_BUFFER_SIZE_OFFSET)&SHM_BUFFER_SIZE_MASK);
+ if(size>=sizeof(int32_t)*3 && get_shem_buffer_level(size,&level))
+ {
+ LYINFLOG("urc_data_is_in_shm_data level is %d, index is %d size is %d",level,index,size);
+ return true;
+ }
+ }
+ LYINFLOG("urc_data_is_in_shm_data return false, responseType is %d",responseType);
+ return false;
+}
+/*hq add for urc broadcase optimisson 2023/01/03 end*/
+
+void *thread_urc_recv(void *p)
+{
+ Parcel *urc_p =NULL;
+ char urc_data[LYNQ_REC_BUF];
+ int res = 0;
+ lynq_head_t* phead;
+ int level,index,size;
+ uint8_t * shm_buffer;
+
+ LYINFLOG("urc recv thread is running");
+ while(module_urc_status)
+ {
+ bzero(urc_data,LYNQ_REC_BUF);
+ res = recvfrom(module_urc_sock_fd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&module_urc_addr_serv,(socklen_t*)&module_len_urc_addr_serv);
+ if(res<sizeof(int32_t)*2)
+ {
+ LYERRLOG("thread_urc_recv step2 fail: res is %d",res);
+ continue;
+ }
+
+ phead=(lynq_head_t*) urc_data;
+ if(is_support_urc(phead->urcid)==false)
+ {
+ continue;
+ }
+ urc_p = new Parcel();
+ if(urc_p == NULL)
+ {
+ LYERRLOG("new parcel failure!!!");
+ continue;
+ }
+ if(urc_data_is_in_shm_data(phead->resp_type,level,index,size))
+ {
+ shm_buffer = (uint8_t *) get_shem_buffer(level,index);
+ LYINFLOG("shm pointer is %p", shm_buffer);
+ urc_p->setData(shm_buffer,size); // p.setData((uint8_t *) buffer, buflen);
+ }
+ else if(res>=sizeof(int32_t)*3)
+ {
+ urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
+ }
+ else
+ {
+ LYERRLOG("res %d error!!!", res);
+ delete urc_p;
+ urc_p = NULL;
+ continue;
+ }
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ BLOCK_PROCESS_URC_MSG_LOCK();
+ s_recv_urc_parcel_list.push_back(urc_p);
+ BLOCK_WAKEUP_PROCESS_URC_MSG();
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+ }
+ else
+ {
+ delete urc_p;
+ urc_p = NULL;
+ }
+ }
+ LYINFLOG("urc recv thread ended");
+ return NULL;
+}
+
+void cleanup_urc_process_mutex(void *arg)
+{
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+}
+
+void *thread_urc_process(void *p)
+{
+ Parcel *urc_p =NULL;
+ std::list<Parcel*>::iterator iter;
+
+ LYINFLOG("urc process thread is running");
+ pthread_cleanup_push(cleanup_urc_process_mutex, NULL); // thread cleanup handler
+ while(module_urc_process_status)
+ {
+ BLOCK_PROCESS_URC_MSG_LOCK();
+ while(s_recv_urc_parcel_list.empty())
+ {
+ BLOCK_WAIT_PROCESS_URC_MSG();
+ }
+ iter=s_recv_urc_parcel_list.begin();
+ urc_p=(*iter);
+ s_recv_urc_parcel_list.erase(iter);
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ pthread_mutex_lock(&s_urc_mutex);
+ urc_msg_process(urc_p);
+ pthread_mutex_unlock(&s_urc_mutex);
+ }
+ delete urc_p;
+ urc_p = NULL;
+ }
+ pthread_cleanup_pop(0);
+ LYINFLOG("urc process thread ended");
+ return NULL;
+}
+
+void lynq_close_urc_rev_thread()
+{
+ int ret;
+
+ BLOCK_PROCESS_URC_MSG_LOCK(); //just cancel urc process tid when recv from
+ module_urc_status = 0;
+ if(module_urc_tid!=-1)
+ {
+ ret = pthread_cancel(module_urc_tid);
+ LYINFLOG("pthread cancel urc rev ret = %d",ret);
+ }
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+ if(module_urc_tid != -1)
+ {
+ ret = pthread_join(module_urc_tid,NULL);
+ LYINFLOG("pthread join urc tid ret = %d",ret);
+ module_urc_tid =-1;
+ }
+}
+
+void lynq_close_urc_process_thread()
+{
+ int ret;
+ BLOCK_PROCESS_URC_MSG_LOCK(); //just cancel urc process tid when not process urc msg in list
+ pthread_mutex_lock(&s_urc_mutex); //just cancel urc process tid when not process urg msg avoid mutual lock for tid may call pthread_cond_wait
+ module_urc_process_status = 0;
+ if(module_urc_process_tid!=-1)
+ {
+ ret = pthread_cancel(module_urc_process_tid);
+ LYINFLOG("pthread cancel urc process ret = %d",ret);
+ }
+ pthread_mutex_unlock(&s_urc_mutex);
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+ if(module_urc_process_tid != -1)
+ {
+ ret = pthread_join(module_urc_process_tid,NULL);
+ LYINFLOG("pthread join urc process tid ret = %d",ret);
+ module_urc_process_tid =-1;
+ }
+}
+
+int lynq_setup_urc_socket()
+{
+ int on = 1;
+ int ret = 0;
+ module_len_urc_addr_serv = sizeof(sockaddr_in);
+ module_urc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if (module_urc_sock_fd <0){
+ LYERRLOG("urc socket error");
+ return RESULT_ERROR;
+ }
+ module_urc_addr_serv.sin_family = AF_INET;
+ module_urc_addr_serv.sin_port = htons(LYNQ_URC_SERVICE_PORT);
+ module_urc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_URC_ADDRESS);
+ /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
+ ret = setsockopt(module_urc_sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
+ if(ret <0)
+ {
+ LYERRLOG("urc socket set error");
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ return RESULT_ERROR;
+ }
+ ret = bind(module_urc_sock_fd ,(struct sockaddr*)&module_urc_addr_serv, sizeof(module_urc_addr_serv));
+ if(ret <0)
+ {
+ LYERRLOG("urc socket bind error");
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ return RESULT_ERROR;
+ }
+ return RESULT_OK;
+}
+
+void lynq_close_urc_socket()
+{
+ if (module_urc_sock_fd >= 0)
+ {
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ }
+}
+
+int lynq_start_all_urc_socket_thread()
+{
+
+ if(ril_init_mem()!=0)
+ {
+ LYERRLOG("ril_init_mem fail");
+ return RESULT_ERROR;
+ }
+
+ int ret= lynq_setup_urc_socket();
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("call lynq_setup_urc_socket fail");
+ ril_deinit_mem();
+ return RESULT_ERROR;
+ }
+
+ BLOCK_PROCESS_URC_MSG_INIT();
+ BLOCK_PROCESS_URC_MSG_LOCK();
+ std::list<Parcel*>::iterator iter;
+ for(iter=s_recv_urc_parcel_list.begin();iter!=s_recv_urc_parcel_list.end();++iter)
+ {
+ delete (*iter);
+ }
+ s_recv_urc_parcel_list.clear();
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+
+ pthread_mutex_init(&s_urc_mutex, NULL);
+
+ module_urc_status = 1;
+ // pthread_attr_init(&attr);
+ // pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ ret = pthread_create(&module_urc_tid,/*&attr*/NULL,thread_urc_recv,NULL);
+ if(ret <0)
+ {
+ LYERRLOG("urc recv pthread create error");
+ module_urc_status = 0;
+ lynq_close_urc_socket();
+ ril_deinit_mem();
+ return RESULT_ERROR;
+ }
+
+ module_urc_process_status = 1;
+ ret = pthread_create(&module_urc_process_tid,/*&attr*/NULL,thread_urc_process,NULL);
+ if(ret <0)
+ {
+ LYERRLOG("urc process pthread create error");
+ module_urc_process_status = 0;
+ lynq_close_urc_socket();
+ lynq_close_urc_rev_thread();
+ ril_deinit_mem();
+ return RESULT_ERROR;
+ }
+
+ LYINFLOG("urc start success");
+
+ return RESULT_OK;
+}
+
+void lynq_close_all_urc_socket_thread()
+{
+
+ lynq_close_urc_rev_thread();
+ lynq_close_urc_socket();
+ lynq_close_urc_process_thread();
+
+ BLOCK_PROCESS_URC_MSG_LOCK();
+ std::list<Parcel*>::iterator iter;
+ for(iter=s_recv_urc_parcel_list.begin();iter!=s_recv_urc_parcel_list.end();++iter)
+ {
+ delete (*iter);
+ }
+ s_recv_urc_parcel_list.clear();
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+
+ ril_deinit_mem();
+}
+
/**@ a thread just for recv\buffer solicited msg's response and notice waiting thread
* @param p [IN]: no meaning
* @return
@@ -347,44 +657,7 @@
return NULL;
}
-void *thread_urc_recv(void *p)
-{
- Parcel *urc_p =NULL;
- char urc_data[LYNQ_REC_BUF];
- int res = 0;
-
- LYINFLOG("urc thread is running");
- while(module_urc_status)
- {
- bzero(urc_data,LYNQ_REC_BUF);
- res = recvfrom(module_urc_sock_fd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&module_urc_addr_serv,(socklen_t*)&module_len_urc_addr_serv);
- if(res<=0)
- {
- LYERRLOG("thread_urc_recv step2 fail:");
- break;
- }
- urc_p = new Parcel();
- if(urc_p == NULL)
- {
- LYERRLOG("new parcel failure!!!");
- break;
- }
- urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
- urc_p->setDataPosition(0);
- if(urc_p->dataAvail()>0)
- {
- pthread_mutex_lock(&s_urc_mutex);
- urc_msg_process(urc_p);
- pthread_mutex_unlock(&s_urc_mutex);
- }
- delete urc_p;
- urc_p = NULL;
- }
- LYINFLOG("urc thread ended");
- return NULL;
-}
-
-int lynq_server_socket_start()
+int lynq_start_all_rc_socket_thread()
{
module_rc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
if(module_rc_sock_fd < 0)
@@ -434,82 +707,7 @@
return RESULT_OK;
}
-int lynq_urc_socket_start()
-{
-// pthread_t tid;
-// pthread_attr_t attr;
- int on = 1;
- int ret = 0;
- module_len_urc_addr_serv = sizeof(sockaddr_in);
- module_urc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
- if (module_urc_sock_fd <0){
- LYERRLOG("urc socket error");
- return RESULT_ERROR;
- }
- module_urc_addr_serv.sin_family = AF_INET;
- module_urc_addr_serv.sin_port = htons(LYNQ_URC_SERVICE_PORT);
- module_urc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_URC_ADDRESS);
- /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
- ret = setsockopt(module_urc_sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
- if(ret <0)
- {
- LYERRLOG("urc socket set error");
- close(module_urc_sock_fd);
- module_urc_sock_fd =-1;
- return RESULT_ERROR;
- }
- ret = bind(module_urc_sock_fd ,(struct sockaddr*)&module_urc_addr_serv, sizeof(module_urc_addr_serv));
- if(ret <0)
- {
- LYERRLOG("urc socket bind error");
- close(module_urc_sock_fd);
- module_urc_sock_fd =-1;
- return RESULT_ERROR;
- }
-
- module_urc_status = 1;
- // pthread_attr_init(&attr);
- // pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- ret = pthread_create(&module_urc_tid,/*&attr*/NULL,thread_urc_recv,NULL);
- if(ret <0)
- {
- LYERRLOG("urc pthread create error");
- module_urc_status = 0;
- close(module_urc_sock_fd);
- module_urc_sock_fd =-1;
- return RESULT_ERROR;
- }
- LYINFLOG("urc start success");
-
- return RESULT_OK;
-}
-
-void lynq_close_urc_thread()
-{
- int ret;
-
- pthread_mutex_lock(&s_urc_mutex); //just cancel urc tid when recvfrom avoid mutual lock for tid may call pthread_cond_wait
- module_urc_status = 0;
- if(module_urc_tid!=-1)
- {
- ret = pthread_cancel(module_urc_tid);
- LYINFLOG("pthread cancel urc ret = %d",ret);
- }
- pthread_mutex_unlock(&s_urc_mutex);
- if(module_urc_tid != -1)
- {
- ret = pthread_join(module_urc_tid,NULL);
- LYINFLOG("pthread join urc tid ret = %d",ret);
- module_urc_tid =-1;
- }
- if (module_urc_sock_fd > 0)
- {
- close(module_urc_sock_fd);
- module_urc_sock_fd =-1;
- }
-}
-
-void lynq_close_rc_thread()
+void lynq_close_all_rc_socket_thread()
{
int ret;
BLOCK_RECV_MSG_LOCK();
@@ -545,3 +743,273 @@
BLOCK_RECV_MSG_UNLOCK();
}
+const char * requestToString(int request)
+{
+ /*
+ cat libs/telephony/ril_commands.h \
+ | egrep "^ *{RIL_" \
+ | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/'
+
+
+ cat libs/telephony/ril_unsol_commands.h \
+ | egrep "^ *{RIL_" \
+ | sed -re 's/\{RIL_([^,]+),([^}]+).+/case RIL_\1: return "\1";/'
+
+ */
+ switch(request) {
+ case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS";
+ case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN";
+ case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK";
+ case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2";
+ case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2";
+ case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN";
+ case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2";
+ case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION";
+ case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS";
+ case RIL_REQUEST_DIAL: return "DIAL";
+ case RIL_REQUEST_GET_IMSI: return "GET_IMSI";
+ case RIL_REQUEST_HANGUP: return "HANGUP";
+ case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND";
+ case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND";
+ case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "SWITCH_WAITING_OR_HOLDING_AND_ACTIVE";
+ case RIL_REQUEST_CONFERENCE: return "CONFERENCE";
+ case RIL_REQUEST_UDUB: return "UDUB";
+ case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE";
+ case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH";
+ case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE";
+ case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE";
+ case RIL_REQUEST_OPERATOR: return "OPERATOR";
+ case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER";
+ case RIL_REQUEST_DTMF: return "DTMF";
+ case RIL_REQUEST_SEND_SMS: return "SEND_SMS";
+ case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE";
+ case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL";
+ case RIL_REQUEST_SIM_IO: return "SIM_IO";
+ case RIL_REQUEST_SEND_USSD: return "SEND_USSD";
+ case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD";
+ case RIL_REQUEST_GET_CLIR: return "GET_CLIR";
+ case RIL_REQUEST_SET_CLIR: return "SET_CLIR";
+ case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS";
+ case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD";
+ case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING";
+ case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING";
+ case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE";
+ case RIL_REQUEST_GET_IMEI: return "GET_IMEI";
+ case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV";
+ case RIL_REQUEST_ANSWER: return "ANSWER";
+ case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL";
+ case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK";
+ case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK";
+ case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD";
+ case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE";
+ case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC";
+ case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL";
+ case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS ";
+ case RIL_REQUEST_DTMF_START: return "DTMF_START";
+ case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP";
+ case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION";
+ case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION";
+ case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "SET_PREFERRED_NETWORK_TYPE";
+ case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "GET_PREFERRED_NETWORK_TYPE";
+ case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "GET_NEIGHBORING_CELL_IDS";
+ case RIL_REQUEST_SET_MUTE: return "SET_MUTE";
+ case RIL_REQUEST_GET_MUTE: return "GET_MUTE";
+ case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP";
+ case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE";
+ case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST";
+ case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO";
+ case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW";
+ case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS";
+ case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE";
+ case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE";
+ case RIL_REQUEST_STK_GET_PROFILE: return "STK_GET_PROFILE";
+ case RIL_REQUEST_STK_SET_PROFILE: return "STK_SET_PROFILE";
+ case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "STK_SEND_ENVELOPE_COMMAND";
+ case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "STK_SEND_TERMINAL_RESPONSE";
+ case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
+ case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE";
+ case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "EXPLICIT_CALL_TRANSFER";
+ case RIL_REQUEST_SET_LOCATION_UPDATES: return "SET_LOCATION_UPDATES";
+ case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:return"CDMA_SET_SUBSCRIPTION_SOURCE";
+ case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:return"CDMA_SET_ROAMING_PREFERENCE";
+ case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:return"CDMA_QUERY_ROAMING_PREFERENCE";
+ case RIL_REQUEST_SET_TTY_MODE:return"SET_TTY_MODE";
+ case RIL_REQUEST_QUERY_TTY_MODE:return"QUERY_TTY_MODE";
+ case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE";
+ case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE";
+ case RIL_REQUEST_CDMA_FLASH:return"CDMA_FLASH";
+ case RIL_REQUEST_CDMA_BURST_DTMF:return"CDMA_BURST_DTMF";
+ case RIL_REQUEST_CDMA_SEND_SMS:return"CDMA_SEND_SMS";
+ case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE:return"CDMA_SMS_ACKNOWLEDGE";
+ case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:return"GSM_GET_BROADCAST_SMS_CONFIG";
+ case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:return"GSM_SET_BROADCAST_SMS_CONFIG";
+ case RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION:return "GSM_SMS_BROADCAST_ACTIVATION";
+ case RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG:return "CDMA_GET_BROADCAST_SMS_CONFIG";
+ case RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG:return "CDMA_SET_BROADCAST_SMS_CONFIG";
+ case RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION:return "CDMA_SMS_BROADCAST_ACTIVATION";
+ case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return"CDMA_VALIDATE_AND_WRITE_AKEY";
+ case RIL_REQUEST_CDMA_SUBSCRIPTION: return"CDMA_SUBSCRIPTION";
+ case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "CDMA_WRITE_SMS_TO_RUIM";
+ case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "CDMA_DELETE_SMS_ON_RUIM";
+ case RIL_REQUEST_DEVICE_IDENTITY: return "DEVICE_IDENTITY";
+ case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "EXIT_EMERGENCY_CALLBACK_MODE";
+ case RIL_REQUEST_GET_SMSC_ADDRESS: return "GET_SMSC_ADDRESS";
+ case RIL_REQUEST_SET_SMSC_ADDRESS: return "SET_SMSC_ADDRESS";
+ case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "REPORT_SMS_MEMORY_STATUS";
+ case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "REPORT_STK_SERVICE_IS_RUNNING";
+ case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "CDMA_GET_SUBSCRIPTION_SOURCE";
+ case RIL_REQUEST_ISIM_AUTHENTICATION: return "ISIM_AUTHENTICATION";
+ case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU";
+ case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS";
+ case RIL_REQUEST_VOICE_RADIO_TECH: return "VOICE_RADIO_TECH";
+ case RIL_REQUEST_GET_CELL_INFO_LIST: return"GET_CELL_INFO_LIST";
+ case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: return"SET_UNSOL_CELL_INFO_LIST_RATE";
+ case RIL_REQUEST_SET_INITIAL_ATTACH_APN: return "RIL_REQUEST_SET_INITIAL_ATTACH_APN";
+ case RIL_REQUEST_IMS_REGISTRATION_STATE: return "IMS_REGISTRATION_STATE";
+ case RIL_REQUEST_IMS_SEND_SMS: return "IMS_SEND_SMS";
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: return "SIM_TRANSMIT_APDU_BASIC";
+ case RIL_REQUEST_SIM_OPEN_CHANNEL: return "SIM_OPEN_CHANNEL";
+ case RIL_REQUEST_SIM_CLOSE_CHANNEL: return "SIM_CLOSE_CHANNEL";
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: return "SIM_TRANSMIT_APDU_CHANNEL";
+ case RIL_REQUEST_GET_RADIO_CAPABILITY: return "RIL_REQUEST_GET_RADIO_CAPABILITY";
+ case RIL_REQUEST_SET_RADIO_CAPABILITY: return "RIL_REQUEST_SET_RADIO_CAPABILITY";
+ case RIL_REQUEST_SET_UICC_SUBSCRIPTION: return "SET_UICC_SUBSCRIPTION";
+ case RIL_REQUEST_ALLOW_DATA: return "ALLOW_DATA";
+ case RIL_REQUEST_GET_HARDWARE_CONFIG: return "GET_HARDWARE_CONFIG";
+ case RIL_REQUEST_SIM_AUTHENTICATION: return "SIM_AUTHENTICATION";
+ case RIL_REQUEST_GET_DC_RT_INFO: return "GET_DC_RT_INFO";
+ case RIL_REQUEST_SET_DC_RT_INFO_RATE: return "SET_DC_RT_INFO_RATE";
+ case RIL_REQUEST_SET_DATA_PROFILE: return "SET_DATA_PROFILE";
+ case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
+ case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
+ case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
+ case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
+ case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS";
+ case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
+ case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
+ case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD";
+ case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
+ case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
+ case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
+ case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
+ case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
+ case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
+ case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
+ case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL";
+ case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
+ case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
+ case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
+ case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
+ case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS";
+ case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_NEW_BROADCAST_SMS";
+ case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL";
+ case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED";
+ case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE";
+ case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING";
+ case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS";
+ case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC";
+ case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW";
+ case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE";
+ case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE";
+ case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED";
+ case RIL_UNSOL_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED";
+ case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE";
+ case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED";
+ case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED";
+ case RIL_UNSOL_CELL_INFO_LIST: return "UNSOL_CELL_INFO_LIST";
+ case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: return "RESPONSE_IMS_NETWORK_STATE_CHANGED";
+ case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: return "UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED";
+ case RIL_UNSOL_SRVCC_STATE_NOTIFY: return "UNSOL_SRVCC_STATE_NOTIFY";
+ case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "HARDWARE_CONFIG_CHANGED";
+ case RIL_UNSOL_DC_RT_INFO_CHANGED: return "UNSOL_DC_RT_INFO_CHANGED";
+ case RIL_REQUEST_SHUTDOWN: return "SHUTDOWN";
+ case RIL_UNSOL_RADIO_CAPABILITY: return "RIL_UNSOL_RADIO_CAPABILITY";
+ case RIL_REQUEST_SET_TRM: return "RIL_REQUEST_SET_TRM";
+ case RIL_REQUEST_SET_IMS_ENABLE:return "RIL_REQUEST_SET_IMS_ENABLE";
+ case RIL_REQUEST_SET_AUDIO_PATH: return "SET_AUDIO_PATH";
+ case RIL_REQUEST_HANGUP_ALL: return "HANGUP_ALL";
+ case RIL_REQUEST_FORCE_RELEASE_CALL: return "FORCE_RELEASE_CALL";
+ case RIL_REQUEST_EMERGENCY_DIAL: return "RIL_REQUEST_EMERGENCY_DIAL";
+ case RIL_REQUEST_SET_ECC_SERVICE_CATEGORY: return "RIL_REQUEST_SET_ECC_SERVICE_CATEGORY";
+ case RIL_REQUEST_SET_ECC_LIST: return "RIL_REQUEST_SET_ECC_LIST";
+ case RIL_REQUEST_AT_COMMAND_WITH_PROXY: return "AT_COMMAND_WITH_PROXY";
+ case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION: return "RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION";
+ case RIL_REQUEST_SET_CLIP: return "RIL_REQUEST_SET_CLIP";
+ case RIL_REQUEST_GET_COLP: return "RIL_REQUEST_GET_COLP";
+ case RIL_REQUEST_SET_COLP: return "RIL_REQUEST_SET_COLP";
+ case RIL_REQUEST_GET_COLR: return "RIL_REQUEST_GET_COLR";
+ case RIL_REQUEST_ADD_IMS_CONFERENCE_CALL_MEMBER: return "ADD_IMS_CONFERENCE_CALL_MEMBER";
+ case RIL_REQUEST_REMOVE_IMS_CONFERENCE_CALL_MEMBER: return "REMOVE_IMS_CONFERENCE_CALL_MEMBER";
+ case RIL_REQUEST_CONFERENCE_DIAL: return "CONFERENCE_DIAL";
+ case RIL_REQUEST_DIAL_WITH_SIP_URI: return "DIAL_WITH_SIP_URI";
+ case RIL_REQUEST_HOLD_CALL: return "HOLD_CALL";
+ case RIL_REQUEST_RESUME_CALL: return "RESUME_CALL";
+ case RIL_UNSOL_ECONF_SRVCC_INDICATION : return "ECONF_SRVCC_INDICATION";
+ case RIL_UNSOL_ECONF_RESULT_INDICATION : return "ECONF_RESULT_INDICATION";
+ case RIL_UNSOL_MAL_AT_INFO : return "UNSOL_MAL_AT_INFO";
+ case RIL_REQUEST_MODEM_POWEROFF: return "MODEM_POWEROFF";
+ case RIL_REQUEST_MODEM_POWERON: return "MODEM_POWERON";
+ case RIL_REQUEST_WRITE_SMS_TO_SIM: return "WRITE_SMS_TO_SIM";
+ case RIL_REQUEST_QUERY_ICCID: return "RIL_REQUEST_QUERY_ICCID";
+ case RIL_UNSOL_TX_POWER: return "RIL_UNSOL_TX_POWER";
+ case RIL_UNSOL_NETWORK_INFO: return "RIL_UNSOL_NETWORK_INFO";
+ case RIL_REQUEST_DELETE_SMS_ON_SIM: return "DELETE_SMS_ON_SIM";
+ case RIL_REQUEST_SET_IMSCFG: return "RIL_REQUEST_SET_IMSCFG";
+#ifdef ECALL_SUPPORT
+ case RIL_REQUEST_ECALL_FAST_MAKE_ECALL: return "ECALL_FAST_MAKE_ECALL";
+ case RIL_REQUEST_ECALL_SET_IVS: return "RIL_REQUEST_ECALL_SET_IVS";
+ case RIL_REQUEST_ECALL_SET_PSAP: return "RIL_REQUEST_ECALL_SET_PSAP";
+ case RIL_REQUEST_ECALL_MAKE_ECALL: return "RIL_REQUEST_ECALL_MAKE_ECALL";
+ case RIL_REQUEST_ECALL_IVS_PUSH_MSD: return "RIL_REQUEST_ECALL_IVS_PUSH_MSD";
+ case RIL_REQUEST_ECALL_PSAP_PULL_MSD: return "RIL_REQUEST_ECALL_PSAP_PULL_MSD";
+ case RIL_UNSOL_ECALL_MSDHACK : return "ECALL_MSDHACK";
+ case RIL_REQUEST_ECALL_SET_MSD: return "RIL_REQUEST_ECALL_SET_MSD";
+ case RIL_REQUEST_ECALL_CTRL_SEQUENCE: return "ECALL_SET_CTRL_SEQUENCE";
+ case RIL_UNSOL_ECALL_INDICATIONS : return "ECALL_INDICATIONS";
+ case RIL_REQUEST_ECALL_RESET_IVS: return "RIL_REQUEST_ECALL_RESET_IVS";
+ case RIL_REQUEST_ECALL_SET_PRI: return "RIL_REQUEST_ECALL_SET_PRI";
+ case RIL_REQUEST_ECALL_SET_TEST_NUM: return "RIL_REQUEST_ECALL_SET_TEST_NUM";
+ case RIL_REQUEST_ECALL_SET_RECONF_NUM: return "RIL_REQUEST_ECALL_SET_RECONF_NUM";
+ case RIL_REQUEST_SYNC_DATA_SETTINGS_TO_MD: return "RIL_REQUEST_SYNC_DATA_SETTINGS_TO_MD";
+ case RIL_REQUEST_ECALL_SET_NAD_DEREGISTRATION_TIME: return "RIL_REQUEST_ECALL_SET_NAD_DEREGISTRATION_TIME";
+ case RIL_REQUEST_ECALL_SET_REGISTRATION_STATE: return "RIL_REQUEST_ECALL_SET_REGISTRATION_STATE";
+#endif /*ECALL_SUPPORT*/
+#ifdef KEEP_ALIVE
+ case RIL_REQUEST_START_KEEPALIVE_PRO: return "RIL_REQUEST_START_KEEPALIVE_PRO";
+ case RIL_REQUEST_STOP_KEEPALIVE_PRO: return "RIL_REQUEST_STOP_KEEPALIVE_PRO";
+ case RIL_UNSOL_KEEPALIVE_STATUS_PRO: return "RIL_UNSOL_KEEPALIVE_STATUS_PRO";
+#endif /*KEEP_ALIVE*/
+ case RIL_REQUEST_SEND_USSI: return "SEND_USSI";
+ case RIL_REQUEST_CANCEL_USSI: return "CANCEL_USSI";
+ case RIL_REQUEST_GET_SMS_SIM_MEM_STATUS: return "GET_SMS_SIM_MEM_STATUS";
+ case RIL_UNSOL_SIP_CALL_PROGRESS_INDICATOR: return "RIL_UNSOL_SIP_CALL_PROGRESS_INDICATOR";
+ case RIL_REQUEST_REPORT_AIRPLANE_MODE: return "RIL_REQUEST_REPORT_AIRPLANE_MODE";
+ case RIL_REQUEST_SET_ECC_NUM: return "RIL_REQUEST_SET_ECC_NUM";
+ case RIL_REQUEST_GET_ECC_NUM: return "RIL_REQUEST_GET_ECC_NUM";
+ case RIL_UNSOL_ECC_NUM: return "RIL_UNSOL_ECC_NUM";
+ case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS_WITH_ACT: return "RIL_REQUEST_QUERY_AVAILABLE_NETWORKS_WITH_ACT";
+ case RIL_REQUEST_GSM_GET_BROADCAST_LANGUAGE: return "RIL_REQUEST_GSM_GET_BROADCAST_LANGUAGE";
+ case RIL_REQUEST_GSM_SET_BROADCAST_LANGUAGE: return "RIL_REQUEST_GSM_SET_BROADCAST_LANGUAGE";
+ case RIL_UNSOL_CALL_INFO_INDICATION: return "RIL_UNSOL_CALL_INFO_INDICATION";
+ case RIL_REQUEST_MODIFY_APN: return "RIL_REQUEST_MODIFY_APN";
+ case RIL_REQUEST_RESET_APN: return "RIL_REQUEST_RESET_APN";
+ case RIL_REQUEST_QUERY_SIM_RETRY_COUNT: return "RIL_REQUEST_QUERY_SIM_RETRY_COUNT";
+ case RIL_REQUEST_QUERY_EID: return "RIL_REQUEST_QUERY_EID";
+ case LYNQ_REQUEST_SET_DTMF_VOLUME: return "RIL_REQUEST_SET_DTMF_VOLUME";
+ case LYNQ_REQUEST_SET_SPEECH_VOLUME: return "RIL_REQUEST_SET_SPEECH_VOLUME";
+ case LYNQ_REQUEST_GET_SPEECH_VOLUME: return "RIL_REQUEST_GET_SPEECH_VOLUME";
+ case LYNQ_REQUEST_RECORD: return "RIL_REQUEST_RECORD";
+ /*warren add for t800 ril service 2022/1/22 start*/
+ case LYNQ_REQUEST_WRITE_SMS_TO_MEMORY: return "LYNQ_REQUEST_WRITE_SMS_TO_MEMORY";
+ case LYNQ_REQUEST_READ_SMS_FROM_MEMORY: return "LYNQ_REQUEST_READ_SMS_FROM_MEMORY";
+ case LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY: return "LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY";
+ case LYNQ_REQUEST_LIST_SMS_FROM_MEMORY: return "LYNQ_REQUEST_LIST_SMS_FROM_MEMORY";
+ case LYNQ_REQUEST_SET_DEFAULT_SIM_ALL:return "SET_DEFAULT_SIM_ALL";
+ case LYNQ_REQUEST_CHANGE_SCREEN_STATE:return "LYNQ_REQUEST_CHANGE_SCREEN_STATE";/*jb.qi add for two sim sleep 2022/9/19*/
+ case LYNQ_REQUEST_CHANGE_RADIO:return "LYNQ_REQUEST_CHANGE_RADIO";/*lei add for factory test of sleep 2022/9/19*/
+ /*warren add for t800 ril service 2022/1/22 end*/
+ default: return "<unknown request>";
+ }
+}
+
+
diff --git a/src/lynq/lib/liblynq-network/lynq_module_socket.h b/src/lynq/lib/liblynq-network/lynq_module_socket.h
index fb1785a..98f968e 100755
--- a/src/lynq/lib/liblynq-network/lynq_module_socket.h
+++ b/src/lynq/lib/liblynq-network/lynq_module_socket.h
@@ -4,15 +4,19 @@
using ::android::Parcel;
int lynq_set_test_network(const int test_mode);
-int lynq_send_common_request(Parcel*& p, int time_out, int request_id, int argc, const char* format,...);
-int lynq_server_socket_start();
-int lynq_urc_socket_start();
-void lynq_close_urc_thread();
-void lynq_close_rc_thread();
extern int g_module_Global_uToken;
extern int g_wait_time;
+int lynq_send_common_request(Parcel*& p, int time_out, int request_id, int argc, const char* format,...);
+
+int lynq_start_all_urc_socket_thread();
+void lynq_close_all_urc_socket_thread();
+int lynq_start_all_rc_socket_thread();
+void lynq_close_all_rc_socket_thread();
+
+const char * requestToString(int request);
void urc_msg_process(Parcel *p);
+bool is_support_urc(int urc_id);
#endif
diff --git a/src/lynq/lib/liblynq-network/lynq_module_state_buffer.cpp b/src/lynq/lib/liblynq-network/lynq_module_state_buffer.cpp
index d7c9111..1d0b5af 100755
--- a/src/lynq/lib/liblynq-network/lynq_module_state_buffer.cpp
+++ b/src/lynq/lib/liblynq-network/lynq_module_state_buffer.cpp
@@ -161,7 +161,7 @@
void deinit_network_timer_all()
{
for(int i=0;i<NETWORK_STATE_BUFFER_TYPE_MAX;i++){
- stop_network_timer(&s_state_buffer_timer[i],s_state_buffer_sig_value[i]);
+ stop_network_timer(s_state_buffer_timer[i],s_state_buffer_sig_value[i]);
s_state_buffer_valid[i] = false;
}
}
diff --git a/src/lynq/lib/liblynq-network/lynq_network.cpp b/src/lynq/lib/liblynq-network/lynq_network.cpp
index cca772f..98e33f6 100755
--- a/src/lynq/lib/liblynq-network/lynq_network.cpp
+++ b/src/lynq/lib/liblynq-network/lynq_network.cpp
@@ -54,8 +54,8 @@
int ret;
init_network_timer_all();
-
- ret = lynq_urc_socket_start();
+
+ ret = lynq_start_all_urc_socket_thread();
if(ret != 0)
{
LYERRLOG("init socket urc fail!!!");
@@ -63,11 +63,11 @@
return LYNQ_E_INNER_ERROR;
}
- ret = lynq_server_socket_start();
+ ret = lynq_start_all_rc_socket_thread();
if(ret !=0)
{
LYERRLOG("init socket client fail!!!");
- lynq_close_urc_thread();
+ lynq_close_all_urc_socket_thread();
g_module_init_flag = MODULE_CLOSED;
return LYNQ_E_INNER_ERROR;
}
@@ -85,8 +85,8 @@
}
g_module_init_flag = MODULE_SWITCHING;
- lynq_close_urc_thread();
- lynq_close_rc_thread();
+ lynq_close_all_urc_socket_thread();
+ lynq_close_all_rc_socket_thread();
deinit_network_timer_all();
g_module_init_flag = MODULE_CLOSED;
@@ -1113,6 +1113,20 @@
return;
}
+bool is_support_urc(int urc_id)
+{
+ switch(urc_id)
+ {
+ case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED:
+ case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED:
+ case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED:
+ case RIL_UNSOL_SIGNAL_STRENGTH:
+ return true;
+ default:
+ return false;
+ }
+}
+
void urc_msg_process(Parcel *p)
{
int resp_type;
@@ -1121,10 +1135,11 @@
int urc_LTE_signalstrength = 0;
int urc_WCDMA_signalstrength = 0;
+ int size=p->dataSize();
p->readInt32(&resp_type);
p->readInt32(&s_module_wait_urc_id);
p->readInt32(&s_module_urc_slot_id);
- LYINFLOG("urc id = %d, slot_id = %d",s_module_wait_urc_id,s_module_urc_slot_id);
+ LYINFLOG("%s urc id = %d, slot_id = %d, size is %d, msg is %s",__func__, s_module_wait_urc_id,s_module_urc_slot_id,size,requestToString(s_module_wait_urc_id));
switch(s_module_wait_urc_id)
{
case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED:
diff --git a/src/lynq/lib/liblynq-network/makefile b/src/lynq/lib/liblynq-network/makefile
index 491d547..0ae6805 100755
--- a/src/lynq/lib/liblynq-network/makefile
+++ b/src/lynq/lib/liblynq-network/makefile
@@ -22,6 +22,7 @@
-I$(ROOT)$(includedir)/liblog \
-I$(ROOT)$(includedir)/vendor-ril \
-I$(ROOT)$(includedir)/include \
+ -I$(ROOT)$(includedir)/lynq_shm \
@@ -35,6 +36,7 @@
-llynq-log \
-lutils \
-lcutils \
+ -llynq-shm \
SOURCES = $(wildcard *.cpp)
diff --git a/src/lynq/lib/liblynq-protcl/ftp/lynq_ftpclient.c b/src/lynq/lib/liblynq-protcl/ftp/lynq_ftpclient.c
index 87220ee..10299d1 100644
--- a/src/lynq/lib/liblynq-protcl/ftp/lynq_ftpclient.c
+++ b/src/lynq/lib/liblynq-protcl/ftp/lynq_ftpclient.c
@@ -250,13 +250,14 @@
}
-int lynq_ftp_download(lynq_ftp_socker_info* FTP)
+int lynq_ftp_download(lynq_ftp_socker_info* FTP, char *put_pach)
{
char catbuf[1024];
int data_sock;
int recvbytes, sendbytes;
char sendline[1024] = "", recvline[1024] = "";
- char getfilepath[FTP_MAX_ASCII_LEN+5] = "/tmp/";
+ char getfilepath[FTP_MAX_ASCII_LEN+5];
+ strcpy(getfilepath, put_pach);
#if 1
//type
diff --git a/src/lynq/lib/liblynq-protcl/include/ftp/lynq_ftp.h b/src/lynq/lib/liblynq-protcl/include/ftp/lynq_ftp.h
index 12e3f09..c0344bf 100644
--- a/src/lynq/lib/liblynq-protcl/include/ftp/lynq_ftp.h
+++ b/src/lynq/lib/liblynq-protcl/include/ftp/lynq_ftp.h
@@ -153,7 +153,7 @@
extern void lynq_ftp_get(int sck, char *pDownloadFileName, int session);
extern void lynq_ftp_rest(int control_sockfd);
extern int cliopen(char *hoster, int port);
-extern int lynq_ftp_download(lynq_ftp_socker_info* FTP);
+extern int lynq_ftp_download(lynq_ftp_socker_info* FTP, char *put_pach);
extern int lynq_ftp_up(lynq_ftp_socker_info* FTP);
int lynq_ftp_ls(lynq_ftp_socker_info* FTP);
void lynq_ftp_cd(lynq_ftp_socker_info* FTP);
diff --git a/src/lynq/lib/liblynq-shm/LICENSE b/src/lynq/lib/liblynq-shm/LICENSE
new file mode 100755
index 0000000..605b7ea
--- /dev/null
+++ b/src/lynq/lib/liblynq-shm/LICENSE
@@ -0,0 +1,31 @@
+Copyright Statement:
+
+This software/firmware and related documentation ("MobileTek Software") are
+protected under relevant copyright laws. The information contained herein is
+confidential and proprietary to MobileTek Inc. and/or its licensors. Without
+the prior written permission of MobileTek inc. and/or its licensors, any
+reproduction, modification, use or disclosure of MobileTek Software, and
+information contained herein, in whole or in part, shall be strictly
+prohibited.
+
+MobileTek Inc. (C) 2015. All rights reserved.
+
+BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
+THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MobileTek SOFTWARE")
+RECEIVED FROM MobileTek AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
+ON AN "AS-IS" BASIS ONLY. MobileTek EXPRESSLY DISCLAIMS ANY AND ALL
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+NONINFRINGEMENT. NEITHER DOES MobileTek PROVIDE ANY WARRANTY WHATSOEVER WITH
+RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
+INCORPORATED IN, OR SUPPLIED WITH THE MobileTek SOFTWARE, AND RECEIVER AGREES
+TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
+RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
+OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MobileTek
+SOFTWARE. MobileTek SHALL ALSO NOT BE RESPONSIBLE FOR ANY MobileTek SOFTWARE
+RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
+STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MobileTek'S
+ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MobileTek SOFTWARE
+RELEASED HEREUNDER WILL BE, AT MobileTek'S OPTION, TO REVISE OR REPLACE THE
+MobileTek SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
+CHARGE PAID BY RECEIVER TO MobileTek FOR SUCH MobileTek SOFTWARE AT ISSUE.
diff --git a/src/lynq/lib/liblynq-shm/include/lynq_shm.h b/src/lynq/lib/liblynq-shm/include/lynq_shm.h
new file mode 100755
index 0000000..bbac100
--- /dev/null
+++ b/src/lynq/lib/liblynq-shm/include/lynq_shm.h
@@ -0,0 +1,26 @@
+/**
+ * @file shm.h
+ * @author hq
+ * @brief
+ * @version 1.0
+ * @date 2022-12-16
+ *
+ * @copyright Copyright (c) 2022
+ *
+ */
+#ifndef __LYNQ_SHM_H__
+#define __LYNQ_SHM_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+int ril_init_mem();
+void ril_deinit_mem();
+bool get_cur_shem_buffer_index(int size, int* level, int* index);
+bool get_shem_buffer_level(int size, int* level);
+char* get_shem_buffer(int level,int index);
+int get_max_shem_buffer_size();
+#ifdef __cplusplus
+}
+#endif
+#endif //#ifndef __TEST_SHARED_MEMORY_INCLUDE__
diff --git a/src/lynq/lib/liblynq-shm/lynq_shm.cpp b/src/lynq/lib/liblynq-shm/lynq_shm.cpp
new file mode 100755
index 0000000..e06ca96
--- /dev/null
+++ b/src/lynq/lib/liblynq-shm/lynq_shm.cpp
@@ -0,0 +1,194 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+//#include <binder/Parcel.h>
+//#include <sys/socket.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include "lynq_shm.h"
+#include <sys/shm.h>
+#include "log/log.h"
+
+#undef LOG_TAG
+#define LOG_TAG "SHM"
+
+#define shm_key "shm_key"
+
+int shmid=-1;
+
+static int s_use_count=0;
+
+typedef struct{
+ int num_of_buffer;
+ int size_of_buffer;
+ int cur_index;
+}lynq_shm_type_config;
+
+typedef enum{
+ shm_buf_type_256,
+ shm_buf_type_1k,
+ shm_buf_type_max,
+}lynq_shm_buf_type;
+
+lynq_shm_type_config s_lynq_shm_config[shm_buf_type_max]={
+ {10,256,0},
+ {5,1024,0}
+};
+
+static void * s_ril_shm_buf=(void*) -1L;
+
+static pthread_mutex_t s_shm_mtx = PTHREAD_MUTEX_INITIALIZER;
+
+bool get_cur_shem_buffer_index(int size, int* level, int* index)
+{
+ pthread_mutex_lock(&s_shm_mtx);
+ for(int i=0;i<shm_buf_type_max;i++)
+ {
+ if(size<=s_lynq_shm_config[i].size_of_buffer)
+ {
+ (*level)=i;
+ (*index)=(s_lynq_shm_config[i].cur_index)%s_lynq_shm_config[i].num_of_buffer;
+ s_lynq_shm_config[i].cur_index++;
+ pthread_mutex_unlock(&s_shm_mtx);
+ return true;
+ }
+ }
+ pthread_mutex_unlock(&s_shm_mtx);
+ return false;
+}
+
+bool get_shem_buffer_level(int size, int* level)
+{
+ for(int i=0;i<shm_buf_type_max;i++)
+ {
+ if(size<=s_lynq_shm_config[i].size_of_buffer)
+ {
+ (*level)=i;
+ return true;
+ }
+ }
+ return false;
+}
+
+
+char* get_shem_buffer(int level,int index)
+{
+ int offset=0;
+ for(int i=0;i<level;i++)
+ {
+ offset+=s_lynq_shm_config[i].num_of_buffer*s_lynq_shm_config[i].size_of_buffer;
+ }
+ offset+=s_lynq_shm_config[level].size_of_buffer*index;
+ return ((char*) s_ril_shm_buf)+offset;
+}
+
+int get_max_shem_buffer_size()
+{
+ return s_lynq_shm_config[shm_buf_type_max-1].size_of_buffer;
+}
+
+int get_total_shem_buffer_size()
+{
+ int total_size=0;
+ for(int i=0;i<shm_buf_type_max;i++)
+ {
+ total_size+=s_lynq_shm_config[i].num_of_buffer*s_lynq_shm_config[i].size_of_buffer;
+ }
+ return total_size;
+}
+
+static int create_shm_common(int size,int flags)
+{
+ RLOGD("create shared memory\n");
+
+// key_t key = ftok(shm_key, 's');
+ key_t key=0x123456;
+ if (key == -1)
+ {
+ RLOGE("ftok error.\n");
+ return -1;
+ }
+ RLOGD("key is 0x%x\n", key);
+
+ int shmid = shmget(key,size , flags);
+ if (shmid == -1)
+ {
+ RLOGE("shmget error.\n");
+ return -1;
+ }
+ RLOGD("shmid is %d\n", shmid);
+
+ return shmid;
+}
+
+int create_shm()
+{
+ shmid = create_shm_common(get_total_shem_buffer_size(),IPC_CREAT|0644);
+
+ if(shmid==-1)
+ {
+ return -1;
+ }
+ s_ril_shm_buf = shmat(shmid, NULL, 0);
+ if (s_ril_shm_buf == (void*) -1L)
+ {
+ RLOGE("shmat error.\n");
+ return -1;
+ }
+ return 0;
+}
+
+void remove_shm()
+{
+ if(shmid!=-1)
+ {
+ if (shmdt(s_ril_shm_buf) != 0)
+ {
+ RLOGE("shmdt error.\n");
+ }
+ shmid = -1;
+ }
+ s_ril_shm_buf = (void*) -1L;
+ return ;
+}
+
+int ril_init_mem()
+{
+ pthread_mutex_lock(&s_shm_mtx);
+ RLOGE("init begin, use count is %d.\n",s_use_count);
+ if(s_use_count==0)
+ {
+ if(create_shm()!=0)
+ {
+ RLOGE("init end, use count is %d.\n",s_use_count);
+ pthread_mutex_unlock(&s_shm_mtx);
+ return -1;
+ }
+ }
+ s_use_count++;
+ RLOGE("init end, use count is %d.\n",s_use_count);
+ pthread_mutex_unlock(&s_shm_mtx);
+ return 0;
+}
+
+void ril_deinit_mem()
+{
+ pthread_mutex_lock(&s_shm_mtx);
+
+ RLOGE("de-init begin, use count is %d.\n",s_use_count);
+ if(s_use_count==1)
+ {
+ remove_shm();
+ }
+
+ if(s_use_count>0)
+ {
+ s_use_count--;
+ }
+ RLOGE("de-init end, use count is %d.\n",s_use_count);
+ pthread_mutex_unlock(&s_shm_mtx);
+ return ;
+}
+
diff --git a/src/lynq/lib/liblynq-shm/makefile b/src/lynq/lib/liblynq-shm/makefile
new file mode 100755
index 0000000..806cc77
--- /dev/null
+++ b/src/lynq/lib/liblynq-shm/makefile
@@ -0,0 +1,62 @@
+SHELL = /bin/sh
+RM = rm -f
+
+LOCAL_CFLAGS := -Wall \
+ -g -Os \
+ -flto \
+ -fPIC
+
+PWD := $(shell pwd)
+
+$(warning ################# lynq shm ROOT: $(ROOT),includedir:$(includedir), PWD :$(PWD))
+LOCAL_PATH = .
+
+LOCAL_C_INCLUDES = \
+ -I. \
+ -I$(LOCAL_PATH)/include \
+ -I$(ROOT)$(includedir) \
+
+LOCAL_LIBS := \
+ -L. \
+ -ldl \
+ -llog \
+# -lbinder \
+ -lpthread \
+# -lutils \
+# -lcutils \
+
+SOURCES = $(wildcard *.cpp)
+
+EXECUTABLE = liblynq-shm.so
+
+OBJECTS=$(SOURCES:.c=.o)
+all: $(EXECUTABLE)
+
+$(EXECUTABLE): $(OBJECTS)
+ $(CXX) -shared -Wl,--no-undefined $(OBJECTS) $(LOCAL_LIBS) $(LOCAL_CFLAGS) $(LOCAL_C_INCLUDES) -o $@
+
+%.o : %.c
+ $(CC) $(LOCAL_C_INCLUDES) $(LOCAL_CFLAGS) $(LOCAL_LIBS) -o $@ -c $<
+
+build: $(EXECUTABLE)
+ $(warning ########## build $(EXECUTABLE) ##########)
+
+install:
+ $(warning ################# lynq shm EXECUTABLE: $(EXECUTABLE),base:$(base_libdir))
+ mkdir -p $(ROOT)$(base_libdir)/
+ install $(EXECUTABLE) $(ROOT)$(base_libdir)/
+
+pack_rootfs:
+ $(warning ################# lynq shm PACK: $(PACK_INITRAMFS_TO),base:$(base_libdir))
+ mkdir -p $(PACK_INITRAMFS_TO)$(base_libdir)/
+ cp -af $(EXECUTABLE) $(PACK_INITRAMFS_TO)$(base_libdir)/
+ $(CROSS)strip $(PACK_INITRAMFS_TO)$(base_libdir)/$(EXECUTABLE)
+ mkdir -p $(PACK_TO)$(base_libdir)/
+ cp -af $(EXECUTABLE) $(PACK_TO)$(base_libdir)/
+ $(CROSS)strip $(PACK_TO)$(base_libdir)/$(EXECUTABLE)
+
+.PHONY: clean
+clean:
+ $(RM) $(OBJECTS) $(EXECUTABLE)
+
+
diff --git a/src/lynq/lib/liblynq-sms/LICENSE b/src/lynq/lib/liblynq-sms/LICENSE
index 77f59ed..605b7ea 100755
--- a/src/lynq/lib/liblynq-sms/LICENSE
+++ b/src/lynq/lib/liblynq-sms/LICENSE
@@ -1,31 +1,31 @@
Copyright Statement:
-This software/firmware and related documentation ("MediaTek Software") are
+This software/firmware and related documentation ("MobileTek Software") are
protected under relevant copyright laws. The information contained herein is
-confidential and proprietary to MediaTek Inc. and/or its licensors. Without
-the prior written permission of MediaTek inc. and/or its licensors, any
-reproduction, modification, use or disclosure of MediaTek Software, and
+confidential and proprietary to MobileTek Inc. and/or its licensors. Without
+the prior written permission of MobileTek inc. and/or its licensors, any
+reproduction, modification, use or disclosure of MobileTek Software, and
information contained herein, in whole or in part, shall be strictly
prohibited.
-MediaTek Inc. (C) 2015. All rights reserved.
+MobileTek Inc. (C) 2015. All rights reserved.
BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
-THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
-RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
-ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
+THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MobileTek SOFTWARE")
+RECEIVED FROM MobileTek AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
+ON AN "AS-IS" BASIS ONLY. MobileTek EXPRESSLY DISCLAIMS ANY AND ALL
WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
-NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
+NONINFRINGEMENT. NEITHER DOES MobileTek PROVIDE ANY WARRANTY WHATSOEVER WITH
RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
-INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
+INCORPORATED IN, OR SUPPLIED WITH THE MobileTek SOFTWARE, AND RECEIVER AGREES
TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
-OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
-SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
+OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MobileTek
+SOFTWARE. MobileTek SHALL ALSO NOT BE RESPONSIBLE FOR ANY MobileTek SOFTWARE
RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
-STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
-ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
-RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
-MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
-CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
+STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MobileTek'S
+ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MobileTek SOFTWARE
+RELEASED HEREUNDER WILL BE, AT MobileTek'S OPTION, TO REVISE OR REPLACE THE
+MobileTek SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
+CHARGE PAID BY RECEIVER TO MobileTek FOR SUCH MobileTek SOFTWARE AT ISSUE.
diff --git a/src/lynq/lib/liblynq-sms/include/libsms/lynq_sms.h b/src/lynq/lib/liblynq-sms/include/libsms/lynq_sms.h
index 64547c9..0d346a6 100755
--- a/src/lynq/lib/liblynq-sms/include/libsms/lynq_sms.h
+++ b/src/lynq/lib/liblynq-sms/include/libsms/lynq_sms.h
@@ -1,9 +1,9 @@
-#ifndef YLNQ_SMS_H
-#define YLNQ_SMS_H 1
-#include <sys/types.h>
+#ifndef LYNQ_SMS_H
+#define LYNQ_SMS_H 1
#ifdef __cplusplus
extern "C" {
#endif
+
#define MIN_MSM_PARAM_NUM 4
#define MIN_IMS_MSM_PARAM_NUM 6
#define MIN_WRITE_MSM_PARAM_NUM 5
@@ -12,6 +12,7 @@
#define STORAGE_SMS_MAX_SIZE 128
#define SMSC_MAX_LEN 22
#define SMS_NUM_MAX 255
+
int lynq_sms_init(int uToken);
int lynq_sms_deinit(void);
int lynq_send_sms(char telephony_num[TELEPHONE_NUM_LEN], int charset, char *msg, int msglen);
@@ -21,9 +22,6 @@
int lynq_list_sms(char index_list[SMS_NUM_MAX]);
int lynq_delete_sms(int index);
int lynq_wait_receive_new_sms(int *handle);
-
-
-
#ifdef __cplusplus
}
#endif
diff --git a/src/lynq/lib/liblynq-sms/lynq_module_common.h b/src/lynq/lib/liblynq-sms/lynq_module_common.h
new file mode 100755
index 0000000..590971a
--- /dev/null
+++ b/src/lynq/lib/liblynq-sms/lynq_module_common.h
@@ -0,0 +1,75 @@
+#ifndef LYNQ_MODULE_COMMON_H
+#define LYNQ_MODULE_COMMON_H
+
+#define RESULT_OK (0)
+#define RESULT_ERROR (-1)
+
+/*the same with lynq_interface.h begin*/
+#define LYNQ_REQUEST_VENDOR_BASE 8000
+#define LYNQ_URC_VENDOR_BASE 9000
+#define LYNQ_AT_SNED (LYNQ_REQUEST_VENDOR_BASE +1)
+#define LYNQ_URC_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+1)
+#define LYNQ_URC_DATA_STATUS_IND (LYNQ_URC_VENDOR_BASE+2)
+#define LYNQ_URC_DATA_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+3)
+#define LYNQ_AUTO_ANSWER_CALL (LYNQ_REQUEST_VENDOR_BASE +2)
+#define LYNQ_REQUEST_SET_DTMF_VOLUME (LYNQ_REQUEST_VENDOR_BASE +3)
+#define LYNQ_URC_MODIFY_APNDB (LYNQ_URC_VENDOR_BASE+4)
+#define LYNQ_URC_RESET_APNDB (LYNQ_URC_VENDOR_BASE+5)
+
+
+#define LYNQ_REQUEST_WRITE_SMS_TO_MEMORY (LYNQ_REQUEST_VENDOR_BASE +4)
+#define LYNQ_REQUEST_READ_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 5)
+#define LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 6)
+#define LYNQ_REQUEST_LIST_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 7)
+#define LYNQ_REQUEST_SET_DEFAULT_SIM_ALL (LYNQ_REQUEST_VENDOR_BASE + 8)
+
+#define LYNQ_REQUEST_SET_SPEECH_VOLUME (LYNQ_REQUEST_VENDOR_BASE +9)
+#define LYNQ_REQUEST_GET_SPEECH_VOLUME (LYNQ_REQUEST_VENDOR_BASE +10)
+#define LYNQ_REQUEST_RECORD (LYNQ_REQUEST_VENDOR_BASE +11)
+#define LYNQ_REQUEST_OOS_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +12)
+#define LYNQ_REQUEST_OOS_DEEP_SLEEP_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +13)
+#define LYNQ_REQUEST_CHANGE_SCREEN_STATE (LYNQ_REQUEST_VENDOR_BASE + 14)/*jb.qi add for two sim suspend 2022/9/19*/
+#define LYNQ_REQUEST_CHANGE_RADIO (LYNQ_REQUEST_VENDOR_BASE + 15)
+/*the same with lynq_interface.h end*/
+
+typedef enum{
+ /*base abnormal*/
+ LYNQ_E_PARAMETER_ANONALY=7000,
+ LYNQ_E_SEND_REQUEST_FAIL=7001,
+ LYNQ_E_GET_HEAD_ERROR=7002,
+ LYNQ_E_INNER_ERROR=7100,
+ LYNQ_E_MALLOC_ERROR=7101,
+ /**/
+ LYNQ_E_CARDSTATE_ERROR=8000,
+ /* The voice service state is out of service*/
+ LYNQ_E_STATE_OUT_OF_SERVICE=8001,
+ /* The voice service state is EMERGENCY_ONLY*/
+ LYNQ_E_STATE_EMERGENCY_ONLY=8002,
+ /* The radio power is power off*/
+ LYNQ_E_STATE_POWER_OFF=8003,
+ LYNQ_E_TIME_OUT=8004,
+ /*create or open sms DB fail */
+ LYNQ_E_SMS_DB_FAIL=8005,
+ /*Failed to execute sql statement*/
+ LYNQ_E_SMS_SQL_FAIL = 8006,
+ LYNQ_E_SMS_NOT_FIND = 8007,
+ /* The logic conflict*/
+ LYNQ_E_CONFLICT=9000,
+ /*Null anomaly*/
+ LYNQ_E_NULL_ANONALY=9001,
+ /*Invalid id anomaly*/
+ LYNQ_E_INVALID_ID_ANONALY=9002,
+#ifdef ECALL_SUPPORT
+ LYNQ_E_ECALL_BEING_RUNNING =9003,
+ LYNQ_E_ECALL_MSD_LENGTH_ERROR =9004,
+ LYNQ_E_ECALL_DAILING_NO_ANSWER =9005,
+#endif
+}LYNQ_E;
+
+#define MODULE_CLOSED (0)
+#define MODULE_SWITCHING (1)
+#define MODULE_RUNNING (2)
+
+extern int g_module_init_flag;
+
+#endif
diff --git a/src/lynq/lib/liblynq-sms/lynq_module_socket.cpp b/src/lynq/lib/liblynq-sms/lynq_module_socket.cpp
new file mode 100755
index 0000000..4b6f020
--- /dev/null
+++ b/src/lynq/lib/liblynq-sms/lynq_module_socket.cpp
@@ -0,0 +1,1041 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <unistd.h>
+#include <binder/Parcel.h>
+#include <log/log.h>
+#include <cutils/jstring.h>
+#include <pthread.h>
+#include <list>
+#include <vendor-ril/telephony/ril.h>
+#include <vendor-ril/telephony/mtk_ril_sp.h>
+#include "lynq_sms.h"
+#include "lynq_module_common.h"
+#include "lynq_module_socket.h"
+#include "liblog/lynq_deflog.h"
+#include "lynq_shm.h"
+
+#define LYNQ_SERVICE_PORT 8088
+#define LYNQ_ADDRESS "127.0.0.1"
+#define LYNQ_URC_SERVICE_PORT 8086
+#define LYNQ_URC_ADDRESS "0.0.0.0"
+#define LYNQ_REQUEST_PARAM_BUF 8192
+#define LYNQ_REC_BUF 8192
+
+#define USER_LOG_TAG "LYNQ_NETWORK"
+
+typedef struct{
+ int uToken;
+ int request;
+ int paramLen;
+ char param[LYNQ_REQUEST_PARAM_BUF];
+}lynq_client_t;
+
+typedef struct{
+ int resp_type;
+ int token;
+ int request;
+ int slot_id;
+ int error;
+}lynq_resp_t;
+
+typedef struct{
+ int resp_type;
+ int urcid;
+}lynq_head_t;
+
+lynq_client_t client_t;
+lynq_resp_t response;
+
+int module_len_rc_addr_serv;
+int module_len_urc_addr_serv;
+struct sockaddr_in module_rc_addr_serv;
+struct sockaddr_in module_urc_addr_serv;
+static int module_rc_sock_fd = -1;
+static int module_urc_sock_fd = -1;
+int module_urc_status = 1;
+int module_rc_status = 1;
+pthread_t module_urc_tid = -1;
+pthread_t module_rc_tid = -1;
+static pthread_mutex_t s_urc_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/*hq add for set waiting time 2022/09/13 begin*/
+static pthread_mutex_t s_sendto_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t s_RecvMsgBlockMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_WaitRecvMsgCond = PTHREAD_COND_INITIALIZER;
+#define BLOCK_RECV_MSG_LOCK() pthread_mutex_lock(&s_RecvMsgBlockMutex)
+#define BLOCK_RECV_MSG_UNLOCK() pthread_mutex_unlock(&s_RecvMsgBlockMutex)
+#define BLOCK_WAIT_RECV_MSG_TIME_OUT(a) pthread_cond_timedwait(&s_WaitRecvMsgCond, &s_RecvMsgBlockMutex,(a))
+#define BLOCK_WAKEUP_RECV_MSG() pthread_cond_broadcast(&s_WaitRecvMsgCond)
+static std::list<Parcel*> s_recv_parcel_list;
+const int waitResponse(int token,int time_out);
+/*hq add for set waiting time 2022/09/13 end*/
+
+/*hq add for urc process asynchronous 2022/12/26 begin*/
+static pthread_mutex_t s_ProcessUrcMsgBlockMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_WaitProcessUrcMsgCond = PTHREAD_COND_INITIALIZER;
+
+#define BLOCK_PROCESS_URC_MSG_INIT() pthread_mutex_init(&s_ProcessUrcMsgBlockMutex,NULL)
+#define BLOCK_PROCESS_URC_MSG_LOCK() pthread_mutex_lock(&s_ProcessUrcMsgBlockMutex)
+#define BLOCK_PROCESS_URC_MSG_UNLOCK() pthread_mutex_unlock(&s_ProcessUrcMsgBlockMutex)
+#define BLOCK_WAIT_PROCESS_URC_MSG() pthread_cond_wait(&s_WaitProcessUrcMsgCond, &s_ProcessUrcMsgBlockMutex)
+#define BLOCK_WAKEUP_PROCESS_URC_MSG() pthread_cond_broadcast(&s_WaitProcessUrcMsgCond)
+static std::list<Parcel*> s_recv_urc_parcel_list;
+void *thread_urc_process(void *p);
+pthread_t module_urc_process_tid = -1;
+int module_urc_process_status = 1;
+/*hq add for urc process asynchronous 2022/12/26 end*/
+
+int g_module_Global_uToken = 0;
+int g_wait_time=5;
+
+/*inner test*/
+static int s_inner_test=0;
+
+/**@brief just for inner test
+* @param test_mode [IN]: test mode
+* 0:success
+* other:failure
+*/
+void lynq_set_test_mode(const int test_mode)
+{
+ if(test_mode<0)
+ {
+ g_wait_time = -test_mode;
+ }
+ else if(test_mode==9999)
+ {
+ LYERRLOG("%s inner test para %d %d",__FUNCTION__,s_inner_test,g_wait_time);
+ }
+ else
+ {
+ s_inner_test = test_mode;
+ }
+}
+
+void cleanup_RecvMsgBlock_mutex(void *arg)
+{
+ BLOCK_RECV_MSG_UNLOCK();
+}
+
+/**@brief wait response with expected token and write msg to parcel in some time
+* @param p [IN]: pointer the parcel
+* @param token [IN]: the expected token for the response msg
+* @param time_out [IN]: timeout.
+* @return
+* 0:success
+* other:failure
+*/
+const int waitResponse(Parcel*& p, int token,int time_out)
+{
+ int waitToken = token;
+ int wakeup_token=-1;
+ int resp_type;
+ struct timeval now;
+ struct timespec timeout;
+ int ret;
+ std::list<Parcel*>::iterator iter;
+ int cnt=0;
+
+ gettimeofday(&now,NULL);
+ timeout.tv_sec = now.tv_sec+time_out; //timeout is 1min
+ timeout.tv_nsec = now.tv_usec*1000;
+
+ LYINFLOG("%s wait token is %d, wait time is %d",__FUNCTION__,waitToken,time_out);
+
+ BLOCK_RECV_MSG_LOCK();
+ pthread_cleanup_push(cleanup_RecvMsgBlock_mutex, NULL); // thread cleanup handler
+ while(module_rc_status){
+ cnt++;
+ for(iter=s_recv_parcel_list.begin();iter!=s_recv_parcel_list.end();++iter)
+ {
+ (*iter)->setDataPosition(0);
+ (*iter)->readInt32(&resp_type);
+ (*iter)->readInt32(&wakeup_token);
+ if(wakeup_token==waitToken)
+ {
+ LYINFLOG("%s get waitToken",__FUNCTION__);
+ p=(*iter);
+ p->setDataPosition(0);
+ s_recv_parcel_list.erase(iter);
+ goto waitResponse_end;
+ }
+ }
+ LYINFLOG("%s no wait Token in msg list, list size is %d",__FUNCTION__,s_recv_parcel_list.size());
+ ret=BLOCK_WAIT_RECV_MSG_TIME_OUT(&timeout);
+ if(ret!=0)
+ {
+ LYERRLOG("%s no expected token %d after %d second",__FUNCTION__,waitToken,time_out);
+ break;
+ }
+ }
+waitResponse_end:
+ LYINFLOG("%s wait token is %d wakeup_token is %d, cnt is %d",__FUNCTION__,waitToken,wakeup_token,cnt);
+ pthread_cleanup_pop(0);
+ BLOCK_RECV_MSG_UNLOCK();
+ return wakeup_token==waitToken ? 0:LYNQ_E_TIME_OUT;
+}
+
+/**@brief print solicied response msg's head information
+* @param head [IN]: head information
+* @return none
+*/
+void PrintHeader(lynq_resp_t& head)
+{
+ LYINFLOG("resp_type=%d,token=%d,request=%d,slot_id=%d,error_code=%d",head.resp_type,head.token,head.request,head.slot_id,head.error);
+}
+
+/**@brief get solicied response msg's head
+* @param head [OUT]: head information
+* @return
+* 0:success
+* other:failure
+*/
+int GetHeader(Parcel* &p, lynq_resp_t& head)
+{
+ LYINFLOG("get header");
+ if(p->dataAvail() > 0)
+ {
+ p->readInt32(&(head.resp_type));
+ p->readInt32(&(head.token));
+ p->readInt32(&(head.request));
+ p->readInt32(&(head.slot_id));
+ p->readInt32(&(head.error));
+ PrintHeader(head);
+ return RESULT_OK;
+ }
+ else
+ {
+ return RESULT_ERROR;
+ }
+}
+
+/**@brief send msg to service and get response from service
+* @param request_id [IN]: request id
+* @param time_out [IN]: wait time uplimit
+* @param p [IN]: point to response msg's parcel
+* @param argc [IN]: how many parameters in parameter string
+* @param format [IN]: parameter string's format
+* @param ... [IN]: the specific parameter
+* @return
+* 0:success
+* other:failure
+*/
+int lynq_send_common_request(Parcel*& p, int time_out, int request_id, int argc, const char* format,...)
+{
+ lynq_client_t client;
+ int ret;
+ int send_num;
+
+ client.uToken = g_module_Global_uToken;
+ g_module_Global_uToken=(g_module_Global_uToken+1)%10000;/*0-10000*/
+ client.request = request_id;
+ client.paramLen = argc;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ if(argc!=0)
+ {
+ va_list args;
+ va_start(args, format);
+ vsnprintf(client.param, LYNQ_REQUEST_PARAM_BUF, format, args);
+ va_end(args);
+ }
+ LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ pthread_mutex_lock(&s_sendto_mutex);
+ if(s_inner_test==1)
+ {
+ send_num = 1;
+ }
+ else
+ {
+ send_num = sendto(module_rc_sock_fd,&client,sizeof(client),0,(struct sockaddr *)&module_rc_addr_serv,module_len_rc_addr_serv);
+ }
+ if(s_inner_test>=1000)
+ {
+ time_out = s_inner_test-1000;
+ }
+ pthread_mutex_unlock(&s_sendto_mutex);
+
+ if(send_num <= 0)
+ {
+ LYERRLOG("send request fail, send num is %d", send_num);
+ return LYNQ_E_SEND_REQUEST_FAIL;
+ }
+ ret = waitResponse(p, client.uToken,time_out);
+
+ if(ret==0)
+ {
+ lynq_resp_t head;
+ ret=GetHeader(p,head);
+ if(ret!=0)
+ {
+ LYERRLOG("%s %d get head error %d",__FUNCTION__,client.uToken,ret);
+ delete p;
+ return LYNQ_E_GET_HEAD_ERROR;
+ }
+ if(head.error!=0)
+ {
+ LYERRLOG("%s %d mdm return head error %d",__FUNCTION__,client.uToken,head.error);
+ delete p;
+ return head.error;
+ }
+ LYERRLOG("%s %d suc",__FUNCTION__,client.uToken);
+ return RESULT_OK;
+ }
+
+ LYERRLOG("%s %d fail, ret is %d",__FUNCTION__,client.uToken,ret);
+
+ return ret;
+}
+
+/*hq add for urc broadcase optimisson 2023/01/03 begin*/
+#define SHM_BUFFER_INDEX_OFFSET 1
+#define SHM_BUFFER_SIZE_OFFSET 16
+#define SHM_BUFFER_INDEX_MASK 0x0000007F
+#define SHM_BUFFER_SIZE_MASK 0x0000FFFF
+
+bool urc_data_is_in_shm_data(int responseType,int& level, int& index, int& size)
+{
+ int shm_index=((responseType>>SHM_BUFFER_INDEX_OFFSET)&SHM_BUFFER_INDEX_MASK);
+ if (shm_index>0)
+ {
+ index=shm_index-1;
+ size=((responseType>>SHM_BUFFER_SIZE_OFFSET)&SHM_BUFFER_SIZE_MASK);
+ if(size>=sizeof(int32_t)*3 && get_shem_buffer_level(size,&level))
+ {
+ LYINFLOG("urc_data_is_in_shm_data level is %d, index is %d size is %d",level,index,size);
+ return true;
+ }
+ }
+ LYINFLOG("urc_data_is_in_shm_data return false, responseType is %d",responseType);
+ return false;
+}
+/*hq add for urc broadcase optimisson 2023/01/03 end*/
+
+void *thread_urc_recv(void *p)
+{
+ Parcel *urc_p =NULL;
+ char urc_data[LYNQ_REC_BUF];
+ int res = 0;
+ lynq_head_t* phead;
+
+ LYINFLOG("urc recv thread is running");
+ while(module_urc_status)
+ {
+ bzero(urc_data,LYNQ_REC_BUF);
+ res = recvfrom(module_urc_sock_fd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&module_urc_addr_serv,(socklen_t*)&module_len_urc_addr_serv);
+ if(res<sizeof(int32_t)*2)
+ {
+ LYERRLOG("thread_urc_recv step2 fail: res is %d",res);
+ continue;
+ }
+ LYINFLOG("__FUNCTION__ %s __LINE__ %d\n", __FUNCTION__, __LINE__);
+ phead=(lynq_head_t*) urc_data;
+ if(is_support_urc(phead->urcid)==false)
+ {
+ continue;
+ }
+ urc_p = new Parcel();
+ if(urc_p == NULL)
+ {
+ LYERRLOG("new parcel failure!!!");
+ continue;
+ }
+ LYINFLOG("__FUNCTION__ %s __LINE__ %d\n", __FUNCTION__, __LINE__);
+ int level,index,size;
+ if(urc_data_is_in_shm_data(phead->resp_type,level,index,size))
+ {
+ LYINFLOG("__FUNCTION__ %s __LINE__ %d,use share memory\n", __FUNCTION__, __LINE__);
+ urc_p->setData((uint8_t *)get_shem_buffer(level,index),size); // p.setData((uint8_t *) buffer, buflen);
+ }
+ else if(res>=sizeof(int32_t)*3)
+ {
+ urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
+ }
+ else
+ {
+ LYERRLOG("res %d error!!!", res);
+ delete urc_p;
+ urc_p = NULL;
+ continue;
+ }
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ BLOCK_PROCESS_URC_MSG_LOCK();
+ s_recv_urc_parcel_list.push_back(urc_p);
+ BLOCK_WAKEUP_PROCESS_URC_MSG();
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+ LYINFLOG("__FUNCTION__ %s __LINE__ %d\n", __FUNCTION__, __LINE__);
+ }
+ else
+ {
+ delete urc_p;
+ urc_p = NULL;
+ }
+ LYINFLOG("__FUNCTION__ %s __LINE__ %d\n", __FUNCTION__, __LINE__);
+ }
+ LYINFLOG("urc recv thread ended");
+ return NULL;
+}
+
+void cleanup_urc_process_mutex(void *arg)
+{
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+}
+
+void *thread_urc_process(void *p)
+{
+ Parcel *urc_p =NULL;
+ std::list<Parcel*>::iterator iter;
+
+ LYINFLOG("urc process thread is running");
+ pthread_cleanup_push(cleanup_urc_process_mutex, NULL); // thread cleanup handler
+ while(module_urc_process_status)
+ {
+ BLOCK_PROCESS_URC_MSG_LOCK();
+ while(s_recv_urc_parcel_list.empty())
+ {
+ LYINFLOG("__FUNCTION__ %s __LINE__ %d\n", __FUNCTION__, __LINE__);
+ BLOCK_WAIT_PROCESS_URC_MSG();
+ LYINFLOG("__FUNCTION__ %s __LINE__ %d\n", __FUNCTION__, __LINE__);
+ }
+ iter=s_recv_urc_parcel_list.begin();
+ urc_p=(*iter);
+ s_recv_urc_parcel_list.erase(iter);
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ LYINFLOG("__FUNCTION__ %s __LINE__ %d\n", __FUNCTION__, __LINE__);
+ pthread_mutex_lock(&s_urc_mutex);
+ urc_msg_process(urc_p);
+ pthread_mutex_unlock(&s_urc_mutex);
+ LYINFLOG("__FUNCTION__ %s __LINE__ %d\n", __FUNCTION__, __LINE__);
+ }
+ delete urc_p;
+ urc_p = NULL;
+ }
+ pthread_cleanup_pop(0);
+ LYINFLOG("urc process thread ended");
+ return NULL;
+}
+
+void lynq_close_urc_rev_thread()
+{
+ int ret;
+
+ BLOCK_PROCESS_URC_MSG_LOCK(); //just cancel urc process tid when recv from
+ module_urc_status = 0;
+ if(module_urc_tid!=-1)
+ {
+ ret = pthread_cancel(module_urc_tid);
+ LYINFLOG("pthread cancel urc rev ret = %d",ret);
+ }
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+ if(module_urc_tid != -1)
+ {
+ ret = pthread_join(module_urc_tid,NULL);
+ LYINFLOG("pthread join urc tid ret = %d",ret);
+ module_urc_tid =-1;
+ }
+}
+
+void lynq_close_urc_process_thread()
+{
+ int ret;
+ BLOCK_PROCESS_URC_MSG_LOCK(); //just cancel urc process tid when not process urc msg in list
+ pthread_mutex_lock(&s_urc_mutex); //just cancel urc process tid when not process urg msg avoid mutual lock for tid may call pthread_cond_wait
+ module_urc_process_status = 0;
+ if(module_urc_process_tid!=-1)
+ {
+ ret = pthread_cancel(module_urc_process_tid);
+ LYINFLOG("pthread cancel urc process ret = %d",ret);
+ }
+ pthread_mutex_unlock(&s_urc_mutex);
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+ if(module_urc_process_tid != -1)
+ {
+ ret = pthread_join(module_urc_process_tid,NULL);
+ LYINFLOG("pthread join urc process tid ret = %d",ret);
+ module_urc_process_tid =-1;
+ }
+}
+
+int lynq_setup_urc_socket()
+{
+ int on = 1;
+ int ret = 0;
+ module_len_urc_addr_serv = sizeof(sockaddr_in);
+ module_urc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if (module_urc_sock_fd <0){
+ LYERRLOG("urc socket error");
+ return RESULT_ERROR;
+ }
+ module_urc_addr_serv.sin_family = AF_INET;
+ module_urc_addr_serv.sin_port = htons(LYNQ_URC_SERVICE_PORT);
+ module_urc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_URC_ADDRESS);
+ /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
+ ret = setsockopt(module_urc_sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
+ if(ret <0)
+ {
+ LYERRLOG("urc socket set error");
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ return RESULT_ERROR;
+ }
+ ret = bind(module_urc_sock_fd ,(struct sockaddr*)&module_urc_addr_serv, sizeof(module_urc_addr_serv));
+ if(ret <0)
+ {
+ LYERRLOG("urc socket bind error");
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ return RESULT_ERROR;
+ }
+ return RESULT_OK;
+}
+
+void lynq_close_urc_socket()
+{
+ if (module_urc_sock_fd >= 0)
+ {
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ }
+}
+
+int lynq_start_all_urc_socket_thread()
+{
+
+ if(ril_init_mem()!=0)
+ {
+ LYERRLOG("ril_init_mem fail");
+ return RESULT_ERROR;
+ }
+
+ int ret= lynq_setup_urc_socket();
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("sms lynq_setup_urc_socket fail");
+ ril_deinit_mem();
+ return RESULT_ERROR;
+ }
+
+ BLOCK_PROCESS_URC_MSG_INIT();
+ BLOCK_PROCESS_URC_MSG_LOCK();
+ std::list<Parcel*>::iterator iter;
+ for(iter=s_recv_urc_parcel_list.begin();iter!=s_recv_urc_parcel_list.end();++iter)
+ {
+ delete (*iter);
+ }
+ s_recv_urc_parcel_list.clear();
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+
+ pthread_mutex_init(&s_urc_mutex, NULL);
+
+ module_urc_status = 1;
+ // pthread_attr_init(&attr);
+ // pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ ret = pthread_create(&module_urc_tid,/*&attr*/NULL,thread_urc_recv,NULL);
+ if(ret <0)
+ {
+ LYERRLOG("urc recv pthread create error");
+ module_urc_status = 0;
+ lynq_close_urc_socket();
+ ril_deinit_mem();
+ return RESULT_ERROR;
+ }
+
+ module_urc_process_status = 1;
+ ret = pthread_create(&module_urc_process_tid,/*&attr*/NULL,thread_urc_process,NULL);
+ if(ret <0)
+ {
+ LYERRLOG("urc process pthread create error");
+ module_urc_process_status = 0;
+ lynq_close_urc_socket();
+ lynq_close_urc_rev_thread();
+ ril_deinit_mem();
+ return RESULT_ERROR;
+ }
+
+ LYINFLOG("urc start success");
+
+ return RESULT_OK;
+}
+
+void lynq_close_all_urc_socket_thread()
+{
+
+ lynq_close_urc_rev_thread();
+ lynq_close_urc_socket();
+ lynq_close_urc_process_thread();
+
+ BLOCK_PROCESS_URC_MSG_LOCK();
+ std::list<Parcel*>::iterator iter;
+ for(iter=s_recv_urc_parcel_list.begin();iter!=s_recv_urc_parcel_list.end();++iter)
+ {
+ delete (*iter);
+ }
+ s_recv_urc_parcel_list.clear();
+ BLOCK_PROCESS_URC_MSG_UNLOCK();
+
+ ril_deinit_mem();
+}
+
+bool is_support_request(int req_id)
+{
+ switch(req_id)
+ {
+ case RIL_REQUEST_SEND_SMS:
+ case RIL_REQUEST_SET_SMSC_ADDRESS:
+ case RIL_REQUEST_GET_SMSC_ADDRESS:
+ case LYNQ_REQUEST_READ_SMS_FROM_MEMORY:
+ case LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY:
+ case LYNQ_REQUEST_LIST_SMS_FROM_MEMORY:
+ return true;
+ default:
+ return false;
+ }
+}
+
+/**@ a thread just for recv\buffer solicited msg's response and notice waiting thread
+* @param p [IN]: no meaning
+* @return
+* always null
+*/
+void *thread_rc_recv(void *p)
+{
+ Parcel* rc_p;
+ std::list<Parcel*>::iterator iter;
+ int resp_type = -1;
+ char rc_data[LYNQ_REC_BUF];
+ int rc_len;
+ int null_cnt=0;
+ int wakeup_token;
+ int resquest;
+ LYINFLOG("rc thread is running");
+ while(module_rc_status)
+ {
+ bzero(rc_data,LYNQ_REC_BUF);
+ while(true)
+ {
+ rc_len = recvfrom(module_rc_sock_fd,rc_data,sizeof(rc_data),0,(struct sockaddr *)&module_rc_addr_serv,(socklen_t *)&module_len_rc_addr_serv);
+ if(rc_len<sizeof(int32_t)*2)
+ {
+ LYERRLOG("%s recv len %d less %d",__FUNCTION__, rc_len,sizeof(int)*2);
+ continue;
+ }
+ rc_p= new Parcel;
+ if(rc_p==NULL)
+ {
+ null_cnt++;
+ LYERRLOG("%s rc_p is NULL, cnt is %d",__FUNCTION__, null_cnt);
+ if(null_cnt>20)
+ {
+ goto rc_recv_end;
+ }
+ continue;
+ }
+ else
+ {
+ null_cnt=0;
+ }
+
+ rc_p->setData((uint8_t *)rc_data,rc_len); // p.setData((uint8_t *) buffer, buflen);
+ rc_p->setDataPosition(0);
+ if(rc_p->dataAvail()>0)
+ {
+ rc_p->readInt32(&resp_type);
+ rc_p->readInt32(&wakeup_token);
+ rc_p->readInt32(&resquest);
+ if(!is_support_request(resquest))
+ {
+ continue;
+ }
+ BLOCK_RECV_MSG_LOCK();
+ s_recv_parcel_list.push_back(rc_p);
+ LYINFLOG("%s wakeup token is %d, list size is %d!",__FUNCTION__,wakeup_token,s_recv_parcel_list.size());
+ if(s_recv_parcel_list.size()>20) //max 20
+ {
+ iter=s_recv_parcel_list.begin();
+ (*iter)->setDataPosition(0);
+ (*iter)->readInt32(&resp_type);
+ (*iter)->readInt32(&wakeup_token);
+ delete (*(s_recv_parcel_list.begin()));
+ LYERRLOG("%s wakeup token %d is deleted!",__FUNCTION__,wakeup_token);
+ s_recv_parcel_list.erase(iter);
+ }
+ BLOCK_WAKEUP_RECV_MSG();
+ BLOCK_RECV_MSG_UNLOCK();
+ break;
+ }
+ else
+ {
+ LYERRLOG("%s rc_p data Avail %d not greater than 0",__FUNCTION__, rc_p->dataAvail());
+ delete rc_p;
+ }
+ }
+ }
+
+rc_recv_end:
+ LYINFLOG("rc thread ended");
+ return NULL;
+}
+
+int lynq_start_all_rc_socket_thread()
+{
+ module_rc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if(module_rc_sock_fd < 0)
+ {
+ LYERRLOG("socket open error");
+ return -1;
+ }
+
+ LYINFLOG("module_rc_sock_fd = %d",module_rc_sock_fd);
+
+ memset(&module_rc_addr_serv, 0, sizeof(module_rc_addr_serv));
+ module_rc_addr_serv.sin_family = AF_INET;
+ module_rc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_ADDRESS);
+ module_rc_addr_serv.sin_port = htons(LYNQ_SERVICE_PORT);
+ module_len_rc_addr_serv = sizeof(module_rc_addr_serv);
+
+ BLOCK_RECV_MSG_LOCK();
+ std::list<Parcel*>::iterator iter;
+ for(iter=s_recv_parcel_list.begin();iter!=s_recv_parcel_list.end();++iter)
+ {
+ delete (*iter);
+ }
+ s_recv_parcel_list.clear();
+ BLOCK_RECV_MSG_UNLOCK();
+
+// pthread_attr_t attr;
+ int ret;
+
+ pthread_mutex_init(&s_sendto_mutex, NULL);
+ pthread_mutex_init(&s_RecvMsgBlockMutex, NULL);
+
+ module_rc_status = 1;
+// pthread_attr_init(&attr);
+// pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ ret = pthread_create(&module_rc_tid,/*&attr*/NULL,thread_rc_recv,NULL);
+ if(ret <0)
+ {
+ LYERRLOG("rc pthread create error");
+ module_rc_status =0;
+ close(module_rc_sock_fd);
+ module_rc_sock_fd =-1;
+ return ret;
+ }
+
+ LYINFLOG("rc start success");
+
+ return RESULT_OK;
+}
+
+void lynq_close_all_rc_socket_thread()
+{
+ int ret;
+ BLOCK_RECV_MSG_LOCK();
+ module_rc_status = 0;
+ BLOCK_WAKEUP_RECV_MSG();
+ if(module_rc_tid != -1)
+ {
+ ret = pthread_cancel(module_rc_tid);
+ LYINFLOG("pthread cancel rc ret = %d",ret);
+ }
+ BLOCK_RECV_MSG_UNLOCK();
+ if(module_rc_tid != -1)
+ {
+ ret = pthread_join(module_rc_tid,NULL);
+ module_rc_tid =-1;
+ LYINFLOG("pthread join rc tid ret = %d",ret);
+
+ }
+
+ if (module_rc_sock_fd > 0)
+ {
+ close(module_rc_sock_fd);
+ module_rc_sock_fd =-1;
+ }
+
+ BLOCK_RECV_MSG_LOCK();
+ std::list<Parcel*>::iterator iter;
+ for(iter=s_recv_parcel_list.begin();iter!=s_recv_parcel_list.end();++iter)
+ {
+ delete (*iter);
+ }
+ s_recv_parcel_list.clear();
+ BLOCK_RECV_MSG_UNLOCK();
+}
+
+const char * requestToString(int request)
+{
+ /*
+ cat libs/telephony/ril_commands.h \
+ | egrep "^ *{RIL_" \
+ | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/'
+
+
+ cat libs/telephony/ril_unsol_commands.h \
+ | egrep "^ *{RIL_" \
+ | sed -re 's/\{RIL_([^,]+),([^}]+).+/case RIL_\1: return "\1";/'
+
+ */
+ switch(request) {
+ case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS";
+ case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN";
+ case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK";
+ case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2";
+ case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2";
+ case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN";
+ case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2";
+ case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION";
+ case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS";
+ case RIL_REQUEST_DIAL: return "DIAL";
+ case RIL_REQUEST_GET_IMSI: return "GET_IMSI";
+ case RIL_REQUEST_HANGUP: return "HANGUP";
+ case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND";
+ case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND";
+ case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "SWITCH_WAITING_OR_HOLDING_AND_ACTIVE";
+ case RIL_REQUEST_CONFERENCE: return "CONFERENCE";
+ case RIL_REQUEST_UDUB: return "UDUB";
+ case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE";
+ case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH";
+ case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE";
+ case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE";
+ case RIL_REQUEST_OPERATOR: return "OPERATOR";
+ case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER";
+ case RIL_REQUEST_DTMF: return "DTMF";
+ case RIL_REQUEST_SEND_SMS: return "SEND_SMS";
+ case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE";
+ case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL";
+ case RIL_REQUEST_SIM_IO: return "SIM_IO";
+ case RIL_REQUEST_SEND_USSD: return "SEND_USSD";
+ case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD";
+ case RIL_REQUEST_GET_CLIR: return "GET_CLIR";
+ case RIL_REQUEST_SET_CLIR: return "SET_CLIR";
+ case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS";
+ case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD";
+ case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING";
+ case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING";
+ case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE";
+ case RIL_REQUEST_GET_IMEI: return "GET_IMEI";
+ case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV";
+ case RIL_REQUEST_ANSWER: return "ANSWER";
+ case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL";
+ case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK";
+ case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK";
+ case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD";
+ case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE";
+ case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC";
+ case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL";
+ case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS ";
+ case RIL_REQUEST_DTMF_START: return "DTMF_START";
+ case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP";
+ case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION";
+ case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION";
+ case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "SET_PREFERRED_NETWORK_TYPE";
+ case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "GET_PREFERRED_NETWORK_TYPE";
+ case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "GET_NEIGHBORING_CELL_IDS";
+ case RIL_REQUEST_SET_MUTE: return "SET_MUTE";
+ case RIL_REQUEST_GET_MUTE: return "GET_MUTE";
+ case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP";
+ case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE";
+ case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST";
+ case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO";
+ case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW";
+ case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS";
+ case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE";
+ case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE";
+ case RIL_REQUEST_STK_GET_PROFILE: return "STK_GET_PROFILE";
+ case RIL_REQUEST_STK_SET_PROFILE: return "STK_SET_PROFILE";
+ case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "STK_SEND_ENVELOPE_COMMAND";
+ case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "STK_SEND_TERMINAL_RESPONSE";
+ case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
+ case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE";
+ case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "EXPLICIT_CALL_TRANSFER";
+ case RIL_REQUEST_SET_LOCATION_UPDATES: return "SET_LOCATION_UPDATES";
+ case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:return"CDMA_SET_SUBSCRIPTION_SOURCE";
+ case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:return"CDMA_SET_ROAMING_PREFERENCE";
+ case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:return"CDMA_QUERY_ROAMING_PREFERENCE";
+ case RIL_REQUEST_SET_TTY_MODE:return"SET_TTY_MODE";
+ case RIL_REQUEST_QUERY_TTY_MODE:return"QUERY_TTY_MODE";
+ case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE";
+ case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE";
+ case RIL_REQUEST_CDMA_FLASH:return"CDMA_FLASH";
+ case RIL_REQUEST_CDMA_BURST_DTMF:return"CDMA_BURST_DTMF";
+ case RIL_REQUEST_CDMA_SEND_SMS:return"CDMA_SEND_SMS";
+ case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE:return"CDMA_SMS_ACKNOWLEDGE";
+ case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:return"GSM_GET_BROADCAST_SMS_CONFIG";
+ case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:return"GSM_SET_BROADCAST_SMS_CONFIG";
+ case RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION:return "GSM_SMS_BROADCAST_ACTIVATION";
+ case RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG:return "CDMA_GET_BROADCAST_SMS_CONFIG";
+ case RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG:return "CDMA_SET_BROADCAST_SMS_CONFIG";
+ case RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION:return "CDMA_SMS_BROADCAST_ACTIVATION";
+ case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return"CDMA_VALIDATE_AND_WRITE_AKEY";
+ case RIL_REQUEST_CDMA_SUBSCRIPTION: return"CDMA_SUBSCRIPTION";
+ case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "CDMA_WRITE_SMS_TO_RUIM";
+ case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "CDMA_DELETE_SMS_ON_RUIM";
+ case RIL_REQUEST_DEVICE_IDENTITY: return "DEVICE_IDENTITY";
+ case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "EXIT_EMERGENCY_CALLBACK_MODE";
+ case RIL_REQUEST_GET_SMSC_ADDRESS: return "GET_SMSC_ADDRESS";
+ case RIL_REQUEST_SET_SMSC_ADDRESS: return "SET_SMSC_ADDRESS";
+ case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "REPORT_SMS_MEMORY_STATUS";
+ case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "REPORT_STK_SERVICE_IS_RUNNING";
+ case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "CDMA_GET_SUBSCRIPTION_SOURCE";
+ case RIL_REQUEST_ISIM_AUTHENTICATION: return "ISIM_AUTHENTICATION";
+ case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU";
+ case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS";
+ case RIL_REQUEST_VOICE_RADIO_TECH: return "VOICE_RADIO_TECH";
+ case RIL_REQUEST_GET_CELL_INFO_LIST: return"GET_CELL_INFO_LIST";
+ case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: return"SET_UNSOL_CELL_INFO_LIST_RATE";
+ case RIL_REQUEST_SET_INITIAL_ATTACH_APN: return "RIL_REQUEST_SET_INITIAL_ATTACH_APN";
+ case RIL_REQUEST_IMS_REGISTRATION_STATE: return "IMS_REGISTRATION_STATE";
+ case RIL_REQUEST_IMS_SEND_SMS: return "IMS_SEND_SMS";
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: return "SIM_TRANSMIT_APDU_BASIC";
+ case RIL_REQUEST_SIM_OPEN_CHANNEL: return "SIM_OPEN_CHANNEL";
+ case RIL_REQUEST_SIM_CLOSE_CHANNEL: return "SIM_CLOSE_CHANNEL";
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: return "SIM_TRANSMIT_APDU_CHANNEL";
+ case RIL_REQUEST_GET_RADIO_CAPABILITY: return "RIL_REQUEST_GET_RADIO_CAPABILITY";
+ case RIL_REQUEST_SET_RADIO_CAPABILITY: return "RIL_REQUEST_SET_RADIO_CAPABILITY";
+ case RIL_REQUEST_SET_UICC_SUBSCRIPTION: return "SET_UICC_SUBSCRIPTION";
+ case RIL_REQUEST_ALLOW_DATA: return "ALLOW_DATA";
+ case RIL_REQUEST_GET_HARDWARE_CONFIG: return "GET_HARDWARE_CONFIG";
+ case RIL_REQUEST_SIM_AUTHENTICATION: return "SIM_AUTHENTICATION";
+ case RIL_REQUEST_GET_DC_RT_INFO: return "GET_DC_RT_INFO";
+ case RIL_REQUEST_SET_DC_RT_INFO_RATE: return "SET_DC_RT_INFO_RATE";
+ case RIL_REQUEST_SET_DATA_PROFILE: return "SET_DATA_PROFILE";
+ case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
+ case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
+ case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
+ case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
+ case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS";
+ case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
+ case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
+ case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD";
+ case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
+ case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
+ case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
+ case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
+ case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
+ case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
+ case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
+ case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL";
+ case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
+ case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
+ case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
+ case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
+ case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS";
+ case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_NEW_BROADCAST_SMS";
+ case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL";
+ case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED";
+ case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE";
+ case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING";
+ case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS";
+ case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC";
+ case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW";
+ case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE";
+ case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE";
+ case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED";
+ case RIL_UNSOL_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED";
+ case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE";
+ case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED";
+ case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED";
+ case RIL_UNSOL_CELL_INFO_LIST: return "UNSOL_CELL_INFO_LIST";
+ case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: return "RESPONSE_IMS_NETWORK_STATE_CHANGED";
+ case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: return "UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED";
+ case RIL_UNSOL_SRVCC_STATE_NOTIFY: return "UNSOL_SRVCC_STATE_NOTIFY";
+ case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "HARDWARE_CONFIG_CHANGED";
+ case RIL_UNSOL_DC_RT_INFO_CHANGED: return "UNSOL_DC_RT_INFO_CHANGED";
+ case RIL_REQUEST_SHUTDOWN: return "SHUTDOWN";
+ case RIL_UNSOL_RADIO_CAPABILITY: return "RIL_UNSOL_RADIO_CAPABILITY";
+ case RIL_REQUEST_SET_TRM: return "RIL_REQUEST_SET_TRM";
+ case RIL_REQUEST_SET_IMS_ENABLE:return "RIL_REQUEST_SET_IMS_ENABLE";
+ case RIL_REQUEST_SET_AUDIO_PATH: return "SET_AUDIO_PATH";
+ case RIL_REQUEST_HANGUP_ALL: return "HANGUP_ALL";
+ case RIL_REQUEST_FORCE_RELEASE_CALL: return "FORCE_RELEASE_CALL";
+ case RIL_REQUEST_EMERGENCY_DIAL: return "RIL_REQUEST_EMERGENCY_DIAL";
+ case RIL_REQUEST_SET_ECC_SERVICE_CATEGORY: return "RIL_REQUEST_SET_ECC_SERVICE_CATEGORY";
+ case RIL_REQUEST_SET_ECC_LIST: return "RIL_REQUEST_SET_ECC_LIST";
+ case RIL_REQUEST_AT_COMMAND_WITH_PROXY: return "AT_COMMAND_WITH_PROXY";
+ case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION: return "RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION";
+ case RIL_REQUEST_SET_CLIP: return "RIL_REQUEST_SET_CLIP";
+ case RIL_REQUEST_GET_COLP: return "RIL_REQUEST_GET_COLP";
+ case RIL_REQUEST_SET_COLP: return "RIL_REQUEST_SET_COLP";
+ case RIL_REQUEST_GET_COLR: return "RIL_REQUEST_GET_COLR";
+ case RIL_REQUEST_ADD_IMS_CONFERENCE_CALL_MEMBER: return "ADD_IMS_CONFERENCE_CALL_MEMBER";
+ case RIL_REQUEST_REMOVE_IMS_CONFERENCE_CALL_MEMBER: return "REMOVE_IMS_CONFERENCE_CALL_MEMBER";
+ case RIL_REQUEST_CONFERENCE_DIAL: return "CONFERENCE_DIAL";
+ case RIL_REQUEST_DIAL_WITH_SIP_URI: return "DIAL_WITH_SIP_URI";
+ case RIL_REQUEST_HOLD_CALL: return "HOLD_CALL";
+ case RIL_REQUEST_RESUME_CALL: return "RESUME_CALL";
+ case RIL_UNSOL_ECONF_SRVCC_INDICATION : return "ECONF_SRVCC_INDICATION";
+ case RIL_UNSOL_ECONF_RESULT_INDICATION : return "ECONF_RESULT_INDICATION";
+ case RIL_UNSOL_MAL_AT_INFO : return "UNSOL_MAL_AT_INFO";
+ case RIL_REQUEST_MODEM_POWEROFF: return "MODEM_POWEROFF";
+ case RIL_REQUEST_MODEM_POWERON: return "MODEM_POWERON";
+ case RIL_REQUEST_WRITE_SMS_TO_SIM: return "WRITE_SMS_TO_SIM";
+ case RIL_REQUEST_QUERY_ICCID: return "RIL_REQUEST_QUERY_ICCID";
+ case RIL_UNSOL_TX_POWER: return "RIL_UNSOL_TX_POWER";
+ case RIL_UNSOL_NETWORK_INFO: return "RIL_UNSOL_NETWORK_INFO";
+ case RIL_REQUEST_DELETE_SMS_ON_SIM: return "DELETE_SMS_ON_SIM";
+ case RIL_REQUEST_SET_IMSCFG: return "RIL_REQUEST_SET_IMSCFG";
+#ifdef ECALL_SUPPORT
+ case RIL_REQUEST_ECALL_FAST_MAKE_ECALL: return "ECALL_FAST_MAKE_ECALL";
+ case RIL_REQUEST_ECALL_SET_IVS: return "RIL_REQUEST_ECALL_SET_IVS";
+ case RIL_REQUEST_ECALL_SET_PSAP: return "RIL_REQUEST_ECALL_SET_PSAP";
+ case RIL_REQUEST_ECALL_MAKE_ECALL: return "RIL_REQUEST_ECALL_MAKE_ECALL";
+ case RIL_REQUEST_ECALL_IVS_PUSH_MSD: return "RIL_REQUEST_ECALL_IVS_PUSH_MSD";
+ case RIL_REQUEST_ECALL_PSAP_PULL_MSD: return "RIL_REQUEST_ECALL_PSAP_PULL_MSD";
+ case RIL_UNSOL_ECALL_MSDHACK : return "ECALL_MSDHACK";
+ case RIL_REQUEST_ECALL_SET_MSD: return "RIL_REQUEST_ECALL_SET_MSD";
+ case RIL_REQUEST_ECALL_CTRL_SEQUENCE: return "ECALL_SET_CTRL_SEQUENCE";
+ case RIL_UNSOL_ECALL_INDICATIONS : return "ECALL_INDICATIONS";
+ case RIL_REQUEST_ECALL_RESET_IVS: return "RIL_REQUEST_ECALL_RESET_IVS";
+ case RIL_REQUEST_ECALL_SET_PRI: return "RIL_REQUEST_ECALL_SET_PRI";
+ case RIL_REQUEST_ECALL_SET_TEST_NUM: return "RIL_REQUEST_ECALL_SET_TEST_NUM";
+ case RIL_REQUEST_ECALL_SET_RECONF_NUM: return "RIL_REQUEST_ECALL_SET_RECONF_NUM";
+ case RIL_REQUEST_SYNC_DATA_SETTINGS_TO_MD: return "RIL_REQUEST_SYNC_DATA_SETTINGS_TO_MD";
+ case RIL_REQUEST_ECALL_SET_NAD_DEREGISTRATION_TIME: return "RIL_REQUEST_ECALL_SET_NAD_DEREGISTRATION_TIME";
+ case RIL_REQUEST_ECALL_SET_REGISTRATION_STATE: return "RIL_REQUEST_ECALL_SET_REGISTRATION_STATE";
+#endif /*ECALL_SUPPORT*/
+#ifdef KEEP_ALIVE
+ case RIL_REQUEST_START_KEEPALIVE_PRO: return "RIL_REQUEST_START_KEEPALIVE_PRO";
+ case RIL_REQUEST_STOP_KEEPALIVE_PRO: return "RIL_REQUEST_STOP_KEEPALIVE_PRO";
+ case RIL_UNSOL_KEEPALIVE_STATUS_PRO: return "RIL_UNSOL_KEEPALIVE_STATUS_PRO";
+#endif /*KEEP_ALIVE*/
+ case RIL_REQUEST_SEND_USSI: return "SEND_USSI";
+ case RIL_REQUEST_CANCEL_USSI: return "CANCEL_USSI";
+ case RIL_REQUEST_GET_SMS_SIM_MEM_STATUS: return "GET_SMS_SIM_MEM_STATUS";
+ case RIL_UNSOL_SIP_CALL_PROGRESS_INDICATOR: return "RIL_UNSOL_SIP_CALL_PROGRESS_INDICATOR";
+ case RIL_REQUEST_REPORT_AIRPLANE_MODE: return "RIL_REQUEST_REPORT_AIRPLANE_MODE";
+ case RIL_REQUEST_SET_ECC_NUM: return "RIL_REQUEST_SET_ECC_NUM";
+ case RIL_REQUEST_GET_ECC_NUM: return "RIL_REQUEST_GET_ECC_NUM";
+ case RIL_UNSOL_ECC_NUM: return "RIL_UNSOL_ECC_NUM";
+ case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS_WITH_ACT: return "RIL_REQUEST_QUERY_AVAILABLE_NETWORKS_WITH_ACT";
+ case RIL_REQUEST_GSM_GET_BROADCAST_LANGUAGE: return "RIL_REQUEST_GSM_GET_BROADCAST_LANGUAGE";
+ case RIL_REQUEST_GSM_SET_BROADCAST_LANGUAGE: return "RIL_REQUEST_GSM_SET_BROADCAST_LANGUAGE";
+ case RIL_UNSOL_CALL_INFO_INDICATION: return "RIL_UNSOL_CALL_INFO_INDICATION";
+ case RIL_REQUEST_MODIFY_APN: return "RIL_REQUEST_MODIFY_APN";
+ case RIL_REQUEST_RESET_APN: return "RIL_REQUEST_RESET_APN";
+ case RIL_REQUEST_QUERY_SIM_RETRY_COUNT: return "RIL_REQUEST_QUERY_SIM_RETRY_COUNT";
+ case RIL_REQUEST_QUERY_EID: return "RIL_REQUEST_QUERY_EID";
+ case LYNQ_REQUEST_SET_DTMF_VOLUME: return "RIL_REQUEST_SET_DTMF_VOLUME";
+ case LYNQ_REQUEST_SET_SPEECH_VOLUME: return "RIL_REQUEST_SET_SPEECH_VOLUME";
+ case LYNQ_REQUEST_GET_SPEECH_VOLUME: return "RIL_REQUEST_GET_SPEECH_VOLUME";
+ case LYNQ_REQUEST_RECORD: return "RIL_REQUEST_RECORD";
+ /*warren add for t800 ril service 2022/1/22 start*/
+ case LYNQ_REQUEST_WRITE_SMS_TO_MEMORY: return "LYNQ_REQUEST_WRITE_SMS_TO_MEMORY";
+ case LYNQ_REQUEST_READ_SMS_FROM_MEMORY: return "LYNQ_REQUEST_READ_SMS_FROM_MEMORY";
+ case LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY: return "LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY";
+ case LYNQ_REQUEST_LIST_SMS_FROM_MEMORY: return "LYNQ_REQUEST_LIST_SMS_FROM_MEMORY";
+ case LYNQ_REQUEST_SET_DEFAULT_SIM_ALL:return "SET_DEFAULT_SIM_ALL";
+ case LYNQ_REQUEST_CHANGE_SCREEN_STATE:return "LYNQ_REQUEST_CHANGE_SCREEN_STATE";/*jb.qi add for two sim sleep 2022/9/19*/
+ case LYNQ_REQUEST_CHANGE_RADIO:return "LYNQ_REQUEST_CHANGE_RADIO";/*lei add for factory test of sleep 2022/9/19*/
+ /*warren add for t800 ril service 2022/1/22 end*/
+ default: return "<unknown request>";
+ }
+}
+
+
diff --git a/src/lynq/lib/liblynq-sms/lynq_module_socket.h b/src/lynq/lib/liblynq-sms/lynq_module_socket.h
new file mode 100755
index 0000000..aabac32
--- /dev/null
+++ b/src/lynq/lib/liblynq-sms/lynq_module_socket.h
@@ -0,0 +1,22 @@
+#ifndef LYNQ_MODULE_SOCKET_H
+#define LYNQ_MODULE_SOCKET_H
+
+using ::android::Parcel;
+
+int lynq_set_test_network(const int test_mode);
+
+extern int g_module_Global_uToken;
+extern int g_wait_time;
+int lynq_send_common_request(Parcel*& p, int time_out, int request_id, int argc, const char* format,...);
+int lynq_start_all_urc_socket_thread();
+void lynq_close_all_urc_socket_thread();
+int lynq_start_all_rc_socket_thread();
+void lynq_close_all_rc_socket_thread();
+
+const char * requestToString(int request);
+
+void urc_msg_process(Parcel *p);
+bool is_support_urc(int urc_id);
+bool is_support_request(int req_id);
+
+#endif
diff --git a/src/lynq/lib/liblynq-sms/lynq_sms.cpp b/src/lynq/lib/liblynq-sms/lynq_sms.cpp
new file mode 100755
index 0000000..46f2119
--- /dev/null
+++ b/src/lynq/lib/liblynq-sms/lynq_sms.cpp
@@ -0,0 +1,364 @@
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <binder/Parcel.h>
+#include <log/log.h>
+#include <cutils/jstring.h>
+#include <pthread.h>
+#include "liblog/lynq_deflog.h"
+#include <sys/time.h>
+#include <string.h>
+#include <vendor-ril/telephony/ril.h>
+#include <vendor-ril/telephony/mtk_ril_sp.h>
+#include <vendor-ril/telephony/mtk_ril_ivt.h>
+#include "lynq_sms.h"
+#include "lynq_module_common.h"
+#include "lynq_module_socket.h"
+
+#define CALL_OFF (0)
+#define CALL_ON (1)
+#define USER_LOG_TAG "LYNQ_SMS"
+
+using ::android::Parcel;
+
+#define MAX_SMS_BUF 1024
+
+int sms_storage_index = 0;
+
+/**
+ * @brief mark call initialization state
+ * 0: deinit state
+ * 1: init state
+ */
+int g_module_init_flag = 0;
+
+//static lynq_call_list_e_t s_call_lists[LYNQ_CALL_MAX]={};
+//static bool s_call_list_loop = 0;
+//static pthread_t s_call_list_loop_tid = -1;
+static pthread_mutex_t s_notice_new_sms_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_notice_new_sms_cond = PTHREAD_COND_INITIALIZER;
+
+//static int s_module_isDial = 0;
+//static pthread_mutex_t call_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
+//static pthread_cond_t call_state_change_cond = PTHREAD_COND_INITIALIZER;
+//static int s_CallId = 0;
+//static pthread_mutex_t s_call_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
+//static pthread_cond_t s_call_state_change_cond = PTHREAD_COND_INITIALIZER;
+
+
+static char *strdupReadString(Parcel* &p) {
+ size_t stringlen;
+ const char16_t *s16;
+ s16 = p->readString16Inplace(&stringlen);
+ return strndup16to8(s16, stringlen);
+}
+
+void lynqNoticeGetModuleNewSms()
+{
+ pthread_mutex_lock(&s_notice_new_sms_mutex);
+ pthread_cond_signal(&s_notice_new_sms_cond);
+ pthread_mutex_unlock(&s_notice_new_sms_mutex);
+
+}
+
+void lynqNoticeWaitModuleNewSms()
+{
+ pthread_mutex_lock(&s_notice_new_sms_mutex);
+ pthread_cond_wait(&s_notice_new_sms_cond, &s_notice_new_sms_mutex);
+ pthread_mutex_unlock(&s_notice_new_sms_mutex);
+}
+
+int lynq_sms_init(int uToken)
+{
+ if(g_module_init_flag != MODULE_CLOSED)
+ {
+ LYERRLOG("module state is %d",g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ if(uToken <0){
+ LYERRLOG("uToken is less than 0",uToken);
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+ g_module_init_flag = MODULE_SWITCHING;
+
+ LYLOGSET(LOG_DEBUG);
+ LYLOGEINIT(USER_LOG_TAG);
+
+ g_module_Global_uToken = uToken;
+
+ int ret = lynq_start_all_urc_socket_thread();
+ if(ret != RESULT_OK)
+ {
+ LYERRLOG("init socket urc fail!!!");
+ g_module_init_flag = MODULE_CLOSED;
+ return LYNQ_E_INNER_ERROR;
+ }
+
+ ret = lynq_start_all_rc_socket_thread();
+ if(ret !=RESULT_OK)
+ {
+ LYERRLOG("init socket client fail!!!");
+ lynq_close_all_urc_socket_thread();
+ g_module_init_flag = MODULE_CLOSED;
+ return LYNQ_E_INNER_ERROR;
+ }
+ g_module_init_flag = MODULE_RUNNING;
+ return RESULT_OK;
+}
+
+/*
+Converts an array to a hexadecimal string
+*/
+void ArrayToStr(unsigned char *Buff, unsigned int BuffLen, char *OutputStr)
+{
+ int i = 0;
+ char TempBuff[MAX_SMS_BUF] = {0};
+ char strBuff[MAX_SMS_BUF] = {0};
+ if(sizeof(Buff) < BuffLen)
+ {
+ LYERRLOG("BuffLen is error\n");
+ return;
+ }
+ for(i = 0; i<BuffLen;i++)
+ {
+ sprintf(TempBuff,"%02x",(unsigned char)Buff[i]);
+ strncat(strBuff,TempBuff,BuffLen*2);
+ }
+ strncpy(OutputStr, strBuff, BuffLen*2);
+ return;
+}
+
+int lynq_send_sms(char telephony_num[TELEPHONE_NUM_LEN], int charset, char *msg, int msglen)
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ Parcel* p=NULL;
+ if(charset == 1)//means 8 bit
+ {
+ char msg_e_b[msglen*2+1] = {0};// +1 for end of string.*2:A char array contains two elements of a string for each value
+ ArrayToStr(msg, msglen, msg_e_b);
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SEND_SMS,3,"%s %d %s",telephony_num, charset, msg_e_b);
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("%s 8bit send error %d",__func__,__LINE__);
+ return ret;
+ }
+ delete p;
+ return RESULT_OK;
+ }
+ else//other bit
+ {
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SEND_SMS,3,"%s %d %s",telephony_num, charset, msg);
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("%s 7bit send error %d",__func__,__LINE__);
+ return ret;
+ }
+ delete p;
+ return RESULT_OK;
+ }
+}
+
+int lynq_read_sms(int index,int *status,int *charset,char smsc[SMSC_MAX_LEN],int *smscLen,int *smslen,char message[MSG_MAX_LEN],char teleNum[TELEPHONE_NUM_LEN],int *numLen,int *current,int *total)
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_READ_SMS_FROM_MEMORY,1,"%d",index);
+ if(ret!=0)
+ {
+ return ret;
+ }
+ LYDBGLOG("LYNQ_REQUEST_READ_SMS_FROM_MEMORY SUCCESS!");
+ p->readInt32(&index);
+ p->readInt32(status);
+ p->readInt32(charset);
+ /*lei add for gws 2022/5/12*/
+ p->readInt32(current);
+ p->readInt32(total);
+ /*lei add for gws 2022/5/12*/
+ char *phone_num = NULL;
+ phone_num = strdupReadString(p);
+ *numLen = strlen(phone_num);
+ strcpy(teleNum, phone_num);
+ char *smscenter = NULL;
+ smscenter = strdupReadString(p);
+ *smscLen = strlen(smscenter);
+ strcpy(smsc,smscenter);
+ char *msg = NULL;
+ msg = strdupReadString(p);
+ *smslen = strlen(msg);
+ strcpy(message,msg);
+ free(phone_num);
+ free(smscenter);
+ free(msg);
+ delete p;
+ return RESULT_OK;
+}
+
+int lynq_get_smsc_address(char service_num[SMSC_MAX_LEN])
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_GET_SMSC_ADDRESS,0,"");
+ if(ret!=0)
+ {
+ return ret;
+ }
+ LYDBGLOG("lynq_get_smsc_address SUCCESS!");
+ char *temp = strdupReadString(p);
+ strcpy(service_num, temp);
+ free(temp);
+ delete p;
+ return RESULT_OK;
+}
+
+int lynq_wait_receive_new_sms(int *handle)
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ if(handle==NULL)
+ {
+ LYERRLOG("handle is null!!!");
+ return LYNQ_E_NULL_ANONALY;
+ }
+ lynqNoticeWaitModuleNewSms();
+ *handle = sms_storage_index;
+ return RESULT_OK;
+}
+
+int lynq_set_smsc_address(const char* service_num)
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SET_SMSC_ADDRESS,1,"%s", service_num);
+
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("%s 8bit send error %d",__func__,__LINE__);
+ return ret;
+ }
+ LYDBGLOG("lynq_set_smsc_address SUCCESS!");
+ delete p;
+ return RESULT_OK;
+}
+
+int lynq_list_sms(char index_list[SMS_NUM_MAX])
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_LIST_SMS_FROM_MEMORY,0,"");
+ if(ret!=0)
+ {
+ return ret;
+ }
+ LYDBGLOG("lynq_list_sms SUCCESS!");
+ char *temp = strdupReadString(p);
+ strcpy(index_list, temp);
+ free(temp);
+ delete p;
+ return RESULT_OK;
+}
+
+int lynq_delete_sms(int index)
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY,1,"%d", index);
+
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("%s 8bit send error %d",__func__,__LINE__);
+ return ret;
+ }
+ LYDBGLOG("lynq_delete_sms SUCCESS!");
+ delete p;
+ return RESULT_OK;
+}
+
+bool is_support_urc(int urc_id)
+{
+ switch(urc_id)
+ {
+ case RIL_UNSOL_RESPONSE_NEW_SMS:
+ return true;
+ default:
+ return false;
+ }
+}
+
+int lynq_sms_deinit(void)
+{
+ if (g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("module state is %d",g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ g_module_init_flag = MODULE_SWITCHING;
+ lynq_close_all_urc_socket_thread();
+ lynq_close_all_rc_socket_thread();
+ g_module_init_flag = MODULE_CLOSED;
+ return RESULT_OK;
+}
+
+void urc_msg_process(Parcel *p)
+{
+ int resp_type;
+ int urcid;
+ int slot_id;
+
+ int size=p->dataSize();
+ p->readInt32(&resp_type);
+ p->readInt32(&urcid);
+ p->readInt32(&slot_id);
+ LYINFLOG("%s urc id = %d, slot_id = %d, size is %d, msg is %s",__func__, urcid,slot_id,size,requestToString(urcid));
+ switch (urcid)
+ {
+ case RIL_UNSOL_RESPONSE_NEW_SMS://new sms received
+ {
+ LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d",resp_type,urcid,slot_id);
+ char *msg = NULL;
+ int index = 0;
+ msg = strdupReadString(p);
+ p->readInt32(&index);
+ sms_storage_index = index;
+ lynqNoticeGetModuleNewSms();
+ free(msg);
+ break;
+ }
+ default:
+ break;
+ }
+}
+
diff --git a/src/lynq/lib/liblynq-sms/makefile b/src/lynq/lib/liblynq-sms/makefile
index 9daf449..e5dedab 100755
--- a/src/lynq/lib/liblynq-sms/makefile
+++ b/src/lynq/lib/liblynq-sms/makefile
@@ -5,79 +5,60 @@
-std=gnu++14 \
-g -Os \
-flto \
+ -DRIL_SHLIB \
+ -DATCI_PARSE \
-fPIC \
+ -DKEEP_ALIVE \
+ -DECALL_SUPPORT \
-fpermissive \
-$(warning ################# C2K support: $(RAT_CONFIG_C2K_SUPPORT))
-ifeq ($(strip $(RAT_CONFIG_C2K_SUPPORT)), yes)
- LOCAL_CFLAGS += -DC2K_SUPPORT
-endif
-ifeq ($(strip $(MTK_MULTI_SIM_SUPPORT)), dsds)
- LOCAL_CFLAGS += -DANDROID_SIM_COUNT_2 \
- -DANDROID_MULTI_SIM \
- -DMODE_DSDS
-endif
-
-ifeq ($(strip $(MTK_MULTI_SIM_SUPPORT)), dsss)
- LOCAL_CFLAGS += -DMODE_DSSS
-endif
-
-$(warning ################# TARGET_PLATFORM: $(TARGET_PLATFORM))
-ifeq ($(strip $(TARGET_PLATFORM)), mt2731)
-#$(warning #################add for debug $(ROOT), $(includedir))
-$(warning ################# TARGET_PLATFORM_MT2731)
- LOCAL_CFLAGS += -DTARGET_PLATFORM_MT2731 \
- -DMD_93_SUPPORT
-else ifeq ($(strip $(TARGET_PLATFORM)), mt2635)
-$(warning ################# TARGET_PLATFORM_MT2635)
- LOCAL_CFLAGS += -DTARGET_PLATFORM_MT2635 \
- -DMD_90_SUPPORT
-endif
-
-$(warning ################# RITA ROOT: $(ROOT),includedir:$(includedir))
+$(warning ################# lynq data demo ROOT: $(ROOT),includedir:$(includedir))
LOCAL_PATH = .
LOCAL_C_INCLUDES = \
-I. \
-I$(LOCAL_PATH)/include/libsms \
- -I$(ROOT)$(includedir)/vendor-ril \
+ -I$(ROOT)$(includedir)/logger \
-I$(ROOT)$(includedir)/liblog \
+ -I$(ROOT)$(includedir)/vendor-ril \
+ -I$(ROOT)$(includedir)/lynq_shm \
LOCAL_LIBS := \
-L. \
-ldl \
- -lpthread \
- -lbinder \
- -lutils \
+ -lstdc++ \
+ -llog \
-lcutils \
+ -lutils \
+ -lbinder \
+ -lpthread \
-llynq-log \
+ -llynq-shm \
-SOURCES = $(wildcard *.c wildcard *.h src/*.cpp)
+SOURCES = $(wildcard *.cpp)
EXECUTABLE = liblynq-sms.so
-OBJECTS=$(SOURCES:.c=.o)
+OBJECTS=$(SOURCES:.cpp=.o)
.PHONY: build clean install pack_rootfs
-
all: build
$(EXECUTABLE): $(OBJECTS)
$(CXX) -shared -Wl,--no-undefined $(OBJECTS) $(LOCAL_LIBS) $(LOCAL_CFLAGS) $(LOCAL_C_INCLUDES) -o $@
-%.o : %.c
- $(CC) $(LOCAL_C_INCLUDES) $(LOCAL_CFLAGS) $(LOCAL_LIBS) -o $@ -c $<
+%.o : %.cpp
+ $(CXX) $(LOCAL_C_INCLUDES) $(LOCAL_CFLAGS) $(LOCAL_LIBS) -o $@ -c $<
build: $(EXECUTABLE)
$(warning ########## build $(EXECUTABLE) ##########)
-
install:
mkdir -p $(ROOT)$(base_libdir)/
install $(EXECUTABLE) $(ROOT)$(base_libdir)/
-
+ mkdir -p $(ROOT)$(includedir)/$(NAME)/sdk
pack_rootfs:
mkdir -p $(PACK_INITRAMFS_TO)$(base_libdir)/
cp -af $(EXECUTABLE) $(PACK_INITRAMFS_TO)$(base_libdir)/
@@ -85,7 +66,7 @@
mkdir -p $(PACK_TO)$(base_libdir)/
cp -af $(EXECUTABLE) $(PACK_TO)$(base_libdir)/
$(CROSS)strip $(PACK_TO)$(base_libdir)/$(EXECUTABLE)
-
.PHONY: clean
clean:
$(RM) $(OBJECTS) $(EXECUTABLE)
+ -find . -name "*.o" -delete
diff --git a/src/lynq/lib/liblynq-sms/src/lynq_sms.cpp b/src/lynq/lib/liblynq-sms/src/lynq_sms.cpp
deleted file mode 100755
index fbf1b64..0000000
--- a/src/lynq/lib/liblynq-sms/src/lynq_sms.cpp
+++ /dev/null
@@ -1,597 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <binder/Parcel.h>
-#include <sys/socket.h>
-#include <netdb.h>
-#include <arpa/inet.h>
-#include <string.h>
-#include <errno.h>
-#include <unistd.h>
-#include <cutils/jstring.h>
-#include "lynq_sms.h"
-#include <vendor-ril/telephony/ril.h>
-#include <liblog/lynq_deflog.h>
-#include <sys/types.h>
-#define LYNQ_REQUEST_VENDOR_BASE 8000
-#define LYNQ_URC_VENDOR_BASE 9000
-#define LYNQ_AT_SNED (LYNQ_REQUEST_VENDOR_BASE +1)
-#define LYNQ_REQUEST_WRITE_SMS_TO_MEMORY (LYNQ_REQUEST_VENDOR_BASE +4)
-#define LYNQ_REQUEST_READ_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 5)
-#define LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 6)
-#define LYNQ_REQUEST_LIST_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 7)
-using ::android::Parcel;
-
-
-#define MAX_SMS_BUF 5120
-#define SERVER_PORT 8088
-#define SERVER_URC_PORT 8086
-#define SERVER_IP "127.0.0.1"
-#define USER_LOG_TAG "LYNQ_SMS"
-typedef struct{
- int uToken;
- int request;
- int paramLen;
- char param[1024*8];
-}lynq_client_t;
-
-typedef struct {
- int sock_fd;
- struct sockaddr_in addrto;
- struct sockaddr_in addrfrom;
-}sms_instance_t;
-
-
-enum{
- SMS_OK = 0,
- SMS_FAIL,
- SMS_PARAM_ERR
-};
-
-typedef struct
-{
- int index; /*the index of sms in memory,0-255 */
- int status; /* 0:read, 1:unread */
- int charset; /* 0:7bit, 1:8bit, 2:16bit(chinese) */
- char smsc[SMSC_MAX_LEN]; /* smsc address */
- int smscLen; /* smsc string length */
- int smslen; /* the length of sms,the maximum length shall not exceed the length specified in 3GGP protocol(160/70) */
- char message[MSG_MAX_LEN]; /* sms content */
- char teleNum[TELEPHONE_NUM_LEN]; /* telephony number */
- int numLen; /* telephony number strings length */
- /*lei add for gsw 2022/5/12*/
- int current; /* Long and short letter after the split letter subscript */
- int total; /* The total number of short creeds after the separation of long and short letters */
- /*lei add for gsw 2022/5/12*/
-}lynq_sms_msg_info_t;
-
-typedef struct{
- int index; /*the index of sms in memory,0-255 */
- int status; /* 0:read, 1:unread */
- uint64_t timestamp; /* reciced message timestamp */
- char telephone_num[TELEPHONE_NUM_LEN]; /* sender telephone number */
-}lynq_sms_info_t;
-
-typedef struct{
- int num_msg; /* numbers of messsage */
- lynq_sms_info_t lynq_sms_info[STORAGE_SMS_MAX_SIZE]; /* message information */
-}lynq_sms_list_info_t;
-
-static sms_instance_t sms_instance;
-int urc_recive_status = 1;
-static pthread_mutex_t s_receive_sms_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t s_receive_sms_cond = PTHREAD_COND_INITIALIZER;
-pthread_t sms_recv_pid = 0;
-int GuToken = 0;
-int sms_storage_index = 0;
-int urc_sock_fd = -1;
-/**g_lynq_sms_init_flag
-* @brief mark sms initialization state
-* 0:Uninitialized
-* 1:initialized
-*/
-static int g_lynq_sms_init_flag = 0;
-/**g_lynq_sms_sendto_mutex
-* @brief mark sms send request mutex
-*/
-static pthread_mutex_t g_lynq_sms_sendto_mutex;
-
-static char *strdupReadString(Parcel &p) {
- size_t stringlen;
- const char16_t *s16;
-
- s16 = p.readString16Inplace(&stringlen);
-
- return strndup16to8(s16, stringlen);
-}
-
-static int sms_server_init(void)
-{
- int ret = SMS_OK;
-
- bzero(&sms_instance, sizeof(sms_instance));
- if ((sms_instance.sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1){
- LYERRLOG("socket error:%s\n", strerror(errno));
- ret = SMS_FAIL;
- }
- struct timeval timeOut;
- timeOut.tv_sec = 60;
- timeOut.tv_usec = 0;
- if (setsockopt(sms_instance.sock_fd, SOL_SOCKET, SO_RCVTIMEO, &timeOut, sizeof(timeOut)) < 0)
- {
- LYERRLOG("time out setting failed\n");
- return -1;
- }
- sms_instance.addrto.sin_family=AF_INET;
- sms_instance.addrto.sin_addr.s_addr = inet_addr(SERVER_IP);
- sms_instance.addrto.sin_port=htons(SERVER_PORT);
- sms_instance.addrfrom.sin_family=AF_INET;
- sms_instance.addrfrom.sin_addr.s_addr = inet_addr(SERVER_IP);
- sms_instance.addrfrom.sin_port=htons(SERVER_PORT);
- pthread_mutex_init(&g_lynq_sms_sendto_mutex, NULL);
-
- return ret;
-}
-
-int send_buff_to_service(char *buff, int length)
-{
- int addr_len = sizeof(sms_instance.addrto);
- int ret = 0;
- ret = sendto(sms_instance.sock_fd, buff, length, 0, (struct sockaddr *)&sms_instance.addrto, addr_len);
-
- return ret;
-}
-int waitReceiveNewSms()
-{
- int ret = 0;
- pthread_mutex_lock(&s_receive_sms_mutex);
- ret = pthread_cond_wait(&s_receive_sms_cond,&s_receive_sms_mutex);
- pthread_mutex_unlock(&s_receive_sms_mutex);
- return ret;
-}
-void sendSignalNewSms()
-{
- pthread_mutex_lock(&s_receive_sms_mutex);
- pthread_cond_signal(&s_receive_sms_cond);
- pthread_mutex_unlock(&s_receive_sms_mutex);
- return;
-}
-int lynq_wait_receive_new_sms(int *handle)
-{
- if(g_lynq_sms_init_flag == 0)
- {
- return -1;
- }
- if(handle==NULL)
- {
- LYERRLOG("handle is null!!!");
- return -1;
- }
- waitReceiveNewSms();
- *handle = sms_storage_index;
- return 0;
-}
-int recvfrom_server(void *resp, int id)
-{
- char recv_buf[4096] = {0};
- int recv_len = 0;
- int len = sizeof(struct sockaddr_in);
- Parcel resp_parcel; // = new Parcel();
- int32_t resp_type = 0;
- int32_t token = 0;
- int32_t request = 0;
- int32_t slot_id = 0;
- int32_t error = -1;
- while (request != id)
- {
- recv_len = recvfrom(sms_instance.sock_fd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr*)&sms_instance.addrfrom, (socklen_t*)&len);
- LYDBGLOG("##################recv length:%d\n", recv_len);
- if(recv_len <= 0){
- LYERRLOG("recvform error: %s\n", strerror(errno));
- return SMS_FAIL;
- }
- resp_parcel.setData((uint8_t *)recv_buf,recv_len);
- resp_parcel.setDataPosition(0);
- if(resp_parcel.dataAvail() > 0)
- {
- resp_parcel.readInt32(&resp_type);
- resp_parcel.readInt32(&token);
- resp_parcel.readInt32(&request);
- resp_parcel.readInt32(&slot_id);
- resp_parcel.readInt32(&error);
- }
- }
- LYDBGLOG("resp data: %d,%d, %d,%d\n", resp_type, request, slot_id, error);
- switch(request)
- {
- case RIL_REQUEST_SEND_SMS:
- case RIL_REQUEST_SET_SMSC_ADDRESS:
- if(0 != error)
- {
- LYDBGLOG("request:%d failure,Error code:%d",request,error);
- }
- break;
-
- case RIL_REQUEST_GET_SMSC_ADDRESS:
- if(0 != error)
- {
- LYDBGLOG("request:%d failure,Error code:%d",request,error);
- }
- else
- {
- char *temp = strdupReadString(resp_parcel);
- memcpy(resp, temp, strlen(temp));
- free(temp);
- }
- break;
- case LYNQ_REQUEST_READ_SMS_FROM_MEMORY:
- if(0 != error)
- {
- LYDBGLOG("request:%d failure,Error code:%d",request,error);
- }
- else
- {
- LYDBGLOG("LYNQ_REQUEST_READ_SMS_FROM_MEMORY SUCCESS!");
- int index = 0;
- int status = 0;
- char *phone_num = NULL;
- char *smsc = NULL;
- char *msg = NULL;
- int charset = 0;
- lynq_sms_msg_info_t * sms_info = (lynq_sms_msg_info_t *)resp;
- resp_parcel.readInt32(&sms_info->index);
- resp_parcel.readInt32(&sms_info->status);
- resp_parcel.readInt32(&sms_info->charset);
- /*lei add for gws 2022/5/12*/
- resp_parcel.readInt32(&sms_info->current);
- resp_parcel.readInt32(&sms_info->total);
- /*lei add for gws 2022/5/12*/
- phone_num = strdupReadString(resp_parcel);
- smsc = strdupReadString(resp_parcel);
- msg = strdupReadString(resp_parcel);
- memcpy(sms_info->smsc, smsc, strlen(smsc));
- memcpy(sms_info->message, msg, strlen(msg));
- memcpy(sms_info->teleNum, phone_num, strlen(phone_num));
- sms_info->smscLen = strlen(smsc);
- sms_info->smslen = strlen(msg);
- sms_info->numLen = strlen(phone_num);
- free(phone_num);
- free(smsc);
- free(msg);
- }
- break;
-
- case LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY:
- if(0 != error)
- {
- LYDBGLOG("request:%d failure,Error code:%d",request,error);
- }
- break;
-
- case LYNQ_REQUEST_LIST_SMS_FROM_MEMORY:
- if(0 != error)
- {
- LYDBGLOG("request:%d failure,Error code:%d",request,error);
- }else{
- int temp = 0;
- char *chartemp = NULL;
- chartemp = strdupReadString(resp_parcel);
- temp = strlen(chartemp);
- if((temp > 0) && (temp <= SMS_NUM_MAX))
- {
- memcpy((char*)resp,chartemp,temp);
- }
- free(chartemp);
- }
- break;
-
- default:
- LYERRLOG("not support id: %d\n", request);
- break;
- }
-
- return error;
-}
-
-void * handle_urc(void *p)
-{
- int ret = SMS_OK;
- char recv_buf[8192] = {0};
- Parcel resp;
- int len = sizeof(struct sockaddr_in);
- if ((urc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1){
- LYERRLOG("socket error:%s\n", strerror(errno));
- ret = SMS_FAIL;
- }
- int opt = 1;
- ret = setsockopt(urc_sock_fd,SOL_SOCKET,SO_BROADCAST,&opt,sizeof(opt));
- ret = setsockopt(urc_sock_fd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
-
- struct sockaddr_in server;
- server.sin_family=AF_INET;
- server.sin_addr.s_addr = htonl(INADDR_ANY);
- server.sin_port=htons(SERVER_URC_PORT);
- ret = bind(urc_sock_fd ,(struct sockaddr*)&server, sizeof(server));
- while(urc_recive_status)
- {
- int slot_id = 0;
- char *phone_num = NULL;
- char *smsc = NULL;
- char *msg = NULL;
- int charset = 0;
- int resp_type = 0;
- int unsol = 0;
- int index = 0;
- ret = recvfrom(urc_sock_fd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr*)&server, (socklen_t*)&len);
- LYDBGLOG("urc recv length: %d\n", ret);
- if(ret <= 0)
- {
- LYERRLOG("recvform error: %s\n", strerror(errno));
- continue;
- }
- resp.setData((uint8_t *)recv_buf,ret);
- resp.setDataPosition(0);
- if(resp.dataAvail() > 0) {
- resp.readInt32(&resp_type);
- resp.readInt32(&unsol);
- resp.readInt32(&slot_id);
- }
- LYERRLOG("resp_type%d,unsol=%d,slot_id=%d",resp_type,unsol,slot_id);
- if(RIL_UNSOL_RESPONSE_NEW_SMS == unsol)
- {
- msg = strdupReadString(resp);
- resp.readInt32(&index);
- sms_storage_index = index;
- //sms_urc_callback(slot_id, phone_num, smsc, msg, charset);
- sendSignalNewSms();
- free(msg);
- }
- }
-}
-
-int lynq_sms_init(int uToken)
-{
- //Check whether sms has been initialized,0:Uninitialized,1:initialized
- if(g_lynq_sms_init_flag == 1)
- {
- LYERRLOG("sms has init!!!");
- //return error code 9000 (LYNQ_E_CONFLICT)
- return 9000;
- }
- g_lynq_sms_init_flag = 1;
- int ret = sms_server_init();
- GuToken = uToken;
- LYLOGSET(LOG_INFO);
- LYLOGEINIT(USER_LOG_TAG);
- urc_recive_status = 1;
- pthread_create(&sms_recv_pid, NULL, handle_urc, NULL);
- LYERRLOG("lynq_sms_init ret: %d\n", ret);
- return ret;
-}
-
-int lynq_sms_deinit(void)
-{
- int ret = 0;
- //Check whether sms has been Uninitialized,0:Uninitialized,1:initialized
- if(g_lynq_sms_init_flag == 0)
- {
- LYERRLOG("sms has deinit!!!");
- //return error code 9000 (LYNQ_E_CONFLICT)
- return 9000;
- }
- urc_recive_status = 0;
- g_lynq_sms_init_flag = 0;
- if(sms_recv_pid > 0)
- {
- ret = pthread_cancel(sms_recv_pid);
- LYERRLOG("pthread cancel ret = %d",ret);
- ret = pthread_join(sms_recv_pid,NULL);
- LYERRLOG("pthread join ret = %d",ret);
- }
-
- if(sms_instance.sock_fd > 0)
- {
- close(sms_instance.sock_fd);
- LYERRLOG("sms_instance.sock_fd");
- close(urc_sock_fd);
- LYERRLOG("URC sock_fd close");
- }
- return 0;
-}
-
-void ArrayToStr(unsigned char *Buff, unsigned int BuffLen, char *OutputStr)
-{
- int i = 0;
- char TempBuff[MAX_SMS_BUF] = {0};
- char strBuff[MAX_SMS_BUF] = {0};
- if(sizeof(Buff) < BuffLen)
- {
- LYERRLOG("BuffLen is error\n");
- return;
- }
- for(i = 0; i<BuffLen;i++)
- {
- sprintf(TempBuff,"%02x",(unsigned char)Buff[i]);
- strncat(strBuff,TempBuff,BuffLen*2);
- }
- strncpy(OutputStr, strBuff, BuffLen*2);
- return;
-}
-
-int lynq_send_sms(char telephony_num[TELEPHONE_NUM_LEN], int charset, char *msg, int msglen)
-{
- if(g_lynq_sms_init_flag == 0)
- {
- return -1;
- }
- lynq_client_t client;
- int ret = SMS_OK;
- if (NULL == msg)
- {
- LYERRLOG("input msg is null!!!");
- return -1;
- }
- if (strlen(msg) == 0)
- {
- LYERRLOG("msg is null,plz input msg");
- }
- client.request = RIL_REQUEST_SEND_SMS;
- client.uToken = GuToken;
- client.paramLen = 3;
- bzero(client.param, 8*1024);
- if(charset == 1)//means 8 bit
- {
- char msg_e_b[msglen*2+1] = {0};// +1 for end of string.*2:A char array contains two elements of a string for each value
- ArrayToStr(msg, msglen, msg_e_b);
- sprintf(client.param, "%s %d %s\n", telephony_num, charset, msg_e_b);
- }
- else
- {
- sprintf(client.param, "%s %d %s\n", telephony_num, charset, msg);
- }
- pthread_mutex_lock(&g_lynq_sms_sendto_mutex);
- ret = send_buff_to_service((char *)&client, sizeof(client));
- ret = recvfrom_server(NULL, RIL_REQUEST_SEND_SMS);
- pthread_mutex_unlock(&g_lynq_sms_sendto_mutex);
-
- return ret;
-}
-
-int lynq_read_sms(int index,int *status,int *charset,char smsc[SMSC_MAX_LEN],int *smscLen,int *smslen,char message[MSG_MAX_LEN],char teleNum[TELEPHONE_NUM_LEN],int *numLen,int *current,int *total)
-{
- if(g_lynq_sms_init_flag == 0)
- {
- return -1;
- }
- lynq_client_t client;
- lynq_sms_msg_info_t sms_msg_info;
- int lenTemp = -1;
- int ret = SMS_OK;
- client.request = LYNQ_REQUEST_READ_SMS_FROM_MEMORY;
- client.uToken = GuToken;
- client.paramLen = 1;
- bzero(client.param, 8*1024);
- sprintf(client.param, "%d", index);
- pthread_mutex_lock(&g_lynq_sms_sendto_mutex);
- ret = send_buff_to_service((char *)&client, sizeof(client));
- ret = recvfrom_server((void *)&sms_msg_info, LYNQ_REQUEST_READ_SMS_FROM_MEMORY);
- pthread_mutex_unlock(&g_lynq_sms_sendto_mutex);
- if(ret == 0)
- {
- *charset = sms_msg_info.charset;
- *status = sms_msg_info.status;
- *smslen = sms_msg_info.smslen;
- *smscLen = sms_msg_info.smscLen;
- *numLen = sms_msg_info.numLen;
- *current = sms_msg_info.current;
- *total = sms_msg_info.total;
- if((*smscLen > 0) && (*smscLen < SMSC_MAX_LEN))
- {
- memcpy(smsc,sms_msg_info.smsc,*smscLen);
- smsc[*smscLen] = '\0';
- }
- if((*smslen > 0) && (*smslen < MSG_MAX_LEN))
- {
- memcpy(message,sms_msg_info.message,*smslen);
- message[*smslen] = '\0';
- }
- if((*numLen > 0) && (*numLen < TELEPHONE_NUM_LEN))
- {
- memcpy(teleNum,sms_msg_info.teleNum,*numLen);
- teleNum[*numLen] = '\0';
- }
- }
- return ret;
-}
-
-int lynq_get_smsc_address(char service_num[SMSC_MAX_LEN])
-{
- if(g_lynq_sms_init_flag == 0)
- {
- return -1;
- }
- if(NULL == service_num)
- {
- return -1;
- }
- int ret = SMS_OK;
- lynq_client_t client;
-
- client.request = RIL_REQUEST_GET_SMSC_ADDRESS;
- client.uToken = GuToken;
- client.paramLen = 0;
- pthread_mutex_lock(&g_lynq_sms_sendto_mutex);
- ret = send_buff_to_service((char *)&client, sizeof(client));
- ret = recvfrom_server(service_num, RIL_REQUEST_GET_SMSC_ADDRESS);
- pthread_mutex_unlock(&g_lynq_sms_sendto_mutex);
-
- return ret;
-}
-
-int lynq_set_smsc_address(const char* service_num)
-{
- if(g_lynq_sms_init_flag == 0)
- {
- return -1;
- }
- if(NULL == service_num)
- {
- return -1;
- }
- if(strlen(service_num) == 0)
- {
- return -1;
- }
- lynq_client_t client;
- int ret = SMS_OK;
-
- client.request = RIL_REQUEST_SET_SMSC_ADDRESS;
- client.uToken = GuToken;
- client.paramLen = 1;
- bzero(client.param, 8*1024);
- sprintf(client.param, "%s", service_num);
- pthread_mutex_lock(&g_lynq_sms_sendto_mutex);
- send_buff_to_service((char *)&client, sizeof(client));
- ret = recvfrom_server(NULL, RIL_REQUEST_SET_SMSC_ADDRESS);
- pthread_mutex_unlock(&g_lynq_sms_sendto_mutex);
-
- return ret;
-}
-
-int lynq_list_sms(char index_list[SMS_NUM_MAX])
-{
- if(g_lynq_sms_init_flag == 0)
- {
- return -1;
- }
- lynq_client_t client;
- int ret = SMS_OK;
- client.request = LYNQ_REQUEST_LIST_SMS_FROM_MEMORY;
- client.uToken = GuToken;
- client.paramLen = 0;
- pthread_mutex_lock(&g_lynq_sms_sendto_mutex);
- ret = send_buff_to_service((char *)&client, sizeof(client));
- ret = recvfrom_server((void *)index_list, LYNQ_REQUEST_LIST_SMS_FROM_MEMORY);
- pthread_mutex_unlock(&g_lynq_sms_sendto_mutex);
- return ret;
-}
-
-int lynq_delete_sms(int index)
-{
- if(g_lynq_sms_init_flag == 0)
- {
- return -1;
- }
- lynq_client_t client;
- int ret = SMS_OK;
- client.request = LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY;
- client.uToken = GuToken;
- client.paramLen = 1;
- bzero(client.param, 8*1024);
- sprintf(client.param, "%d", index);
- pthread_mutex_lock(&g_lynq_sms_sendto_mutex);
- ret = send_buff_to_service((char *)&client, sizeof(client));
- ret = recvfrom_server(NULL, LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY);
- pthread_mutex_unlock(&g_lynq_sms_sendto_mutex);
- return ret;
-}
diff --git a/src/lynq/lib/liblynq-systime/src/lynq_systime.c b/src/lynq/lib/liblynq-systime/src/lynq_systime.c
index 29bf676..46ec442 100755
--- a/src/lynq/lib/liblynq-systime/src/lynq_systime.c
+++ b/src/lynq/lib/liblynq-systime/src/lynq_systime.c
@@ -66,7 +66,7 @@
system(date);
system(time);
-
+ system("hwclock -w -f /dev/rtc0");
return 0;
}
diff --git a/src/lynq/lib/liblynq-uci/lynq_uci.config b/src/lynq/lib/liblynq-uci/lynq_uci.config
index 86f578c..5b7c208 100755
--- a/src/lynq/lib/liblynq-uci/lynq_uci.config
+++ b/src/lynq/lib/liblynq-uci/lynq_uci.config
@@ -26,3 +26,6 @@
config lynq_rndis 'lynq_rndis'
option initiate '0'
+
+config rndis_status 'rndis'
+ option status '0'
diff --git a/src/lynq/lib/liblynq-wifi6/libwifi6.c b/src/lynq/lib/liblynq-wifi6/libwifi6.c
index 78c756e..d0c3c32 100755
--- a/src/lynq/lib/liblynq-wifi6/libwifi6.c
+++ b/src/lynq/lib/liblynq-wifi6/libwifi6.c
@@ -60,7 +60,14 @@
const char * state_scan_result = "CTRL-EVENT-SCAN-RESULTS";
const char * STATE_COMPLETED = "COMPLETED";
-static struct wpa_ctrl * g_lynq_wpa_ctrl[2] = {0};
+struct local_wpa_ctrl{
+ struct wpa_ctrl *ctrl;
+ pthread_mutex_t mutex;
+};
+
+static pthread_mutex_t s_check_wpa_ctrl_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static struct local_wpa_ctrl * g_lynq_wpa_ctrl[2] = {0};
//you.chen add for tv-box start
volatile int g_gbw_enabled = 0;
@@ -76,6 +83,50 @@
int net_no;
}curr_status_info;
+static int local_wpa_ctrl_request(struct local_wpa_ctrl *ctrl, const char *cmd, size_t cmd_len,
+ char *reply, size_t *reply_len,
+ void (*msg_cb)(char *msg, size_t len))
+{
+ int ret;
+ if (ctrl->ctrl == NULL) {
+ printf("local_wpa_ctrl_request ctrl is null\n");
+ return -1;
+ }
+ pthread_mutex_lock(&ctrl->mutex);
+ ret = wpa_ctrl_request(ctrl->ctrl, cmd, cmd_len, reply, reply_len, msg_cb);
+ pthread_mutex_unlock(&ctrl->mutex);
+ return ret;
+}
+
+static struct local_wpa_ctrl * inner_get_wpa_ctrl(int index) {
+ int repeat_cnt;
+ struct local_wpa_ctrl *lynq_wpa_ctrl = NULL;
+ pthread_mutex_lock(&s_check_wpa_ctrl_mutex);
+ printf("inner_get_wpa_ctrl\n");
+ for (repeat_cnt = 0; repeat_cnt < 5 && NULL == g_lynq_wpa_ctrl[index]; repeat_cnt++) {
+ pthread_mutex_unlock(&s_check_wpa_ctrl_mutex);
+// printf("wait enable finish\n");
+ usleep(500 * 1000);
+ pthread_mutex_lock(&s_check_wpa_ctrl_mutex);
+ }
+ if (NULL == g_lynq_wpa_ctrl[index]) {
+ printf("NULL == g_lynq_wpa_ctrl[index]\n");
+ goto out_addr;
+ }
+ if (NULL == g_lynq_wpa_ctrl[index]->ctrl) {
+ g_lynq_wpa_ctrl[index]->ctrl = wpa_ctrl_open(CTRL_PATH[index]);
+ if (NULL == g_lynq_wpa_ctrl[index]->ctrl) {
+ printf("wpa_ctrl_open fail\n");
+ goto out_addr;
+ }
+ pthread_mutex_init(&g_lynq_wpa_ctrl[index]->mutex, NULL);
+ }
+ lynq_wpa_ctrl = g_lynq_wpa_ctrl[index];
+out_addr:
+ pthread_mutex_unlock(&s_check_wpa_ctrl_mutex);
+ return lynq_wpa_ctrl;
+}
+
#define PRINT_AND_RETURN_VALUE(str,value) \
{\
perror((str));\
@@ -93,23 +144,17 @@
#define CHECK_WPA_CTRL(index) int ret = 0;\
size_t reply_len = MAX_RET; \
char cmd_reply[MAX_RET]={0}; \
- struct wpa_ctrl *lynq_wpa_ctrl = NULL; \
+ struct local_wpa_ctrl *lynq_wpa_ctrl = NULL; \
do{ \
- if (NULL == g_lynq_wpa_ctrl[index]) { \
- g_lynq_wpa_ctrl[index] = wpa_ctrl_open(CTRL_PATH[index]); \
- if (NULL == g_lynq_wpa_ctrl[index]) { \
- printf("wpa_ctrl_open fail\n"); \
- return -1; \
- } \
- } \
- lynq_wpa_ctrl = g_lynq_wpa_ctrl[index]; \
+ lynq_wpa_ctrl = inner_get_wpa_ctrl(index); \
+ if (NULL == lynq_wpa_ctrl) return -1; \
}while(0)
#define DO_REQUEST(cmd_str) do { \
reply_len = MAX_RET;\
cmd_reply[0] = '\0'; \
printf("to call [%s]\n", cmd_str); \
- ret = wpa_ctrl_request(lynq_wpa_ctrl, cmd_str, strlen(cmd_str), cmd_reply, &reply_len, NULL); \
+ ret = local_wpa_ctrl_request(lynq_wpa_ctrl, cmd_str, strlen(cmd_str), cmd_reply, &reply_len, NULL); \
if (ret != 0) { \
printf("call "#cmd_str" fail %d\n", ret); \
return ret; \
@@ -130,6 +175,7 @@
}while (0)
+static int exec_cmd(const char *str_cmd, char * str_cmd_ret, size_t max_len);
static void APWatcherThreadProc() {
size_t len = MAX_RET;
@@ -264,6 +310,13 @@
{
int ret = 0;
int i;
+ pthread_mutex_lock(&s_check_wpa_ctrl_mutex);
+
+ if (g_lynq_wpa_ctrl[0] != NULL && g_lynq_wpa_ctrl[1] != NULL) {
+ goto out_enable;
+ }
+
+ printf("lynq_wifi_enable1\n");
const char * cmd_check_service =
"state=`systemctl is-active wg870_drv_insmod.service`\n"
"[ \"\"$state == \"active\" ] && exit 0\n"
@@ -275,7 +328,8 @@
ret = system(cmd_check_service);
if (ret != 0) {
printf("service state %d\n", ret);
- return -1;
+ ret = -1;
+ goto out_enable;
}
for (i=0; i<10; i++) {
@@ -286,7 +340,8 @@
}
if (i >= 10) {
- return -1;
+ ret = -1;
+ goto out_enable;
}
//@todo delete add temp check for socket avilable start (20220606)
@@ -300,7 +355,8 @@
if (i >= 60)
{
- return -1;
+ ret = -1;
+ goto out_enable;
}
//@todo delete add temp check for socket avilable end (20220606)
@@ -318,14 +374,16 @@
if (g_ap_watcher_pid == 0 ) {
ret=pthread_create(&g_ap_watcher_pid,NULL,APWatcherThreadProc,NULL);
if(ret<0){
- return -1;
+ ret = -1;
+ goto out_enable;
}
}
if (g_sta_watcher_pid == 0 ) {
ret=pthread_create(&g_sta_watcher_pid,NULL,STAWatcherThreadProc,NULL);
if(ret<0){
- return -1;
+ ret = -1;
+ goto out_enable;
}
}
@@ -336,11 +394,18 @@
}
}
+ g_lynq_wpa_ctrl[0] = malloc(sizeof (struct local_wpa_ctrl));
+ g_lynq_wpa_ctrl[1] = malloc(sizeof (struct local_wpa_ctrl));
+ memset(g_lynq_wpa_ctrl[0], 0 , sizeof(struct local_wpa_ctrl));
+ memset(g_lynq_wpa_ctrl[1], 0 , sizeof(struct local_wpa_ctrl));
+out_enable:
+ pthread_mutex_unlock(&s_check_wpa_ctrl_mutex);
return ret;
}
int lynq_wifi_disable(void)
{
+ pthread_mutex_lock(&s_check_wpa_ctrl_mutex);
g_ap_watcher_stop_flag = 1;
g_sta_watcher_stop_flag = 1;
if (g_ap_watcher_pid != 0)
@@ -356,11 +421,95 @@
g_lynq_wpa_ctrl[0] = NULL;
g_lynq_wpa_ctrl[1] = NULL;
system("systemctl stop wg870_drv_insmod.service");
- return 0;
+ pthread_mutex_unlock(&s_check_wpa_ctrl_mutex);
+ return 0;
+}
+
+static inline char inner_convert_char(char in)
+{
+ if (in >= '0' && in <= '9')
+ {
+ return in - '0';
+ }
+ else if (in >= 'a' && in <= 'f')
+ {
+ return in - 'a' + 10;
+ }
+ else if (in >= 'A' && in <= 'F')
+ {
+ return in - 'A' + 10;
+ }
+ else
+ {
+ return '\xff';
+ }
+}
+
+static inline void inner_copy_ssid(char * out_ssid, const char * ssid, size_t out_ssid_len)
+{
+ char *p;
+ size_t pos = 0;
+ if (NULL == out_ssid)
+ return;
+ //printf("input ssid=[%s]\n", ssid);
+ memset(out_ssid, 0, out_ssid_len);
+ if (NULL == ssid)
+ return;
+ p = strchr(ssid, '\\');
+ if (NULL == p)
+ {
+ strncpy(out_ssid, ssid, out_ssid_len);
+ //printf(" first %s\n", out_ssid);
+ }
+ else
+ {
+ pos = p - ssid;
+ memcpy(out_ssid, ssid, pos);
+ //printf("pos %lu -- %s\n", pos, out_ssid);
+ for(; pos < out_ssid_len; pos ++)
+ {
+ if (p[0] == '\0')
+ {
+ //printf(" out %s\n", out_ssid);
+ return;
+ }
+ else if (p[0] != '\\')
+ {
+ out_ssid[pos] = p[0];
+ p += 1;
+ }
+ else if (p[1] == 'x' || p[1] == 'X')
+ {
+ out_ssid[pos] = inner_convert_char(p[2]) << 4 | inner_convert_char(p[3]);
+ p += 4;
+ }
+ else if (p[1] == '\\')
+ {
+ out_ssid[pos] = '\\';
+ p += 2;
+ }
+ else if (p[1] == 't')
+ {
+ out_ssid[pos] = '\t';
+ p += 2;
+ }
+ else if (p[1] == 'r')
+ {
+ out_ssid[pos] = '\r';
+ p += 2;
+ }
+ else if (p[1] == 'n')
+ {
+ out_ssid[pos] = '\n';
+ p += 2;
+ }//todo find a better way to convert?
+ }
+ }
+ //printf(" out %s\n", out_ssid);
}
static int inner_get_param(int interface, int net_no, char* param_name, char * out_put) {
-
+ int i, ssid_len;
char lynq_cmd_get[128]={0};
if (out_put == NULL) {
@@ -387,7 +536,33 @@
}
// printf("reply len %d, %08x\n", reply_len, (int)out_put);
- memcpy(out_put, cmd_reply, reply_len + 1);
+ if (strcmp(param_name, "ssid") == 0)
+ {
+ if (cmd_reply[0] == '\"') {
+ ssid_len = reply_len - 1;
+ memcpy(out_put, cmd_reply + 1, ssid_len);
+ if (out_put[ssid_len-1] == '\"')
+ {
+ out_put[ssid_len-1] = '\0';
+ }
+ else
+ {
+ out_put[ssid_len] = '\0';
+ }
+ }
+ else{
+ ssid_len = reply_len / 2;
+ for(i=0; i<ssid_len; i++)
+ {
+ out_put[i] = inner_convert_char(cmd_reply[i*2]) << 4 | inner_convert_char(cmd_reply[i*2 + 1]);
+ }
+ out_put[ssid_len] = '\0';
+ }
+ }
+ else
+ {
+ memcpy(out_put, cmd_reply, reply_len + 1);
+ }
return 0;
}
@@ -410,123 +585,26 @@
return ret;
}
-static void trim_space(char * p, int count) {
- char * begin = p;
- p += count;
- printf("%C-%C||\n", *begin, *p);
- while (p >= begin ) {
- if (*p == ' ') {
- *p-- = '\0';
- }
- else {
- break;
- }
- }
-}
-
-static int get_ip_mac_list(char * mac_list[128], char * ip_list[128]) {
- FILE * fp;
- int len, ret;
- int count, count_words, index;
- int mac_start, mac_end;
- int ip_start, ip_end;
- char *split_lines[128] = {0};
- char *buff;
- const char * ip_header = "IP address";
- const char * mac_header = "HW address";
- const char * zero_mac = "00:00:00:00:00:00";
-
- fp = fopen("/proc/net/arp", "rb");
- if (NULL == fp) {
- printf("open file fail\n");
- return -1;
- }
-
- buff = alloca(MAX_RET);
- fseek(fp, 0, SEEK_SET);
- len = fread(buff, 1, MAX_RET, fp);
- fclose(fp);
- if (len <= 0) {
- printf("read file fail\n");
+static int inner_get_ip_by_mac(const char * mac, char * ip, int ip_len)
+{
+ char * p;
+ int ret = 0;
+ char cmd[256]={0};
+ if (NULL == mac || NULL == ip)
return -1;
+ memset(ip, 0, ip_len);
+ sprintf(cmd, "ip neigh | grep \"lladdr\" | grep \"tether\" | grep \"%s\" | head -1 | awk '{print $1}'", mac);
+ ret = exec_cmd(cmd, ip, ip_len);
+ p = strchr(ip, '\n');
+ if (NULL != p)
+ {
+ *p = '\0';
}
- printf("file : %s\n", buff);
-
- count = lynq_split(buff, len, '\n', split_lines);
- printf("----- %s\n", split_lines[0]);
-
- mac_end = 0;
- count_words = strlen(split_lines[0]);
- if (strstr(split_lines[0], mac_header) != NULL) {
- mac_start = strstr(split_lines[0], mac_header) - split_lines[0];
- mac_end = mac_start + strlen(mac_header) + 1;
- while (mac_end < count_words) {
- if (split_lines[0][mac_end] != ' ') {
- break;
- }
- mac_end++;
- }
- }
-
- ip_end = 0;
- if (strstr(split_lines[0], ip_header) != NULL) {
- ip_start = strstr(split_lines[0], ip_header) - split_lines[0];
- ip_end = ip_start + strlen(ip_header) + 1;
- while (ip_end < count_words) {
- if (split_lines[0][ip_end] != ' ') {
- break;
- }
- ip_end++;
- }
- }
-
- if (mac_end == 0 || ip_end == 0) {
- return 0;
- }
-
- ret = 0;
- for(index = 1;index < count; index++) {
- if (memcmp(split_lines[index] + mac_start, zero_mac, strlen(zero_mac)) == 0) {
- continue;
- }
- mac_list[ret] = malloc(mac_end - mac_start + 1);
- ip_list[ret] = malloc(ip_end - ip_start + 1);
- memcpy(mac_list[ret], split_lines[index] + mac_start, mac_end - mac_start);
- memcpy(ip_list[ret], split_lines[index] + ip_start, ip_end - ip_start);
- trim_space(mac_list[ret], mac_end - mac_start - 1);
- trim_space(ip_list[ret], ip_end - ip_start - 1);
- ret++;
- }
-
+ printf("inner_get_ip_by_mac %s\n", ip);
return ret;
}
-static void free_ip_mac_list_mem(char ** mac_list, int mac_cnt, char ** ip_list, int ip_cnt)
-{
- int i;
- if (mac_list != NULL && mac_cnt > 0) {
- for(i = 0; i< mac_cnt; i++)
- {
- if (NULL != mac_list[i])
- {
- free(mac_list[i]);
- mac_list[i] = NULL;
- }
- }
- }
- if (ip_list != NULL && ip_cnt > 0) {
- for(i = 0; i< mac_cnt; i++)
- {
- if (NULL != ip_list[i])
- {
- free(ip_list[i]);
- ip_list[i] = NULL;
- }
- }
- }
-}
-
-static int get_hostname_by_ip(char *ip, char *hostname) {
+static int inner_get_hostname_by_ip(char *ip, char *hostname) {
struct in_addr addr ={0};
struct hostent *ht;
@@ -534,6 +612,7 @@
return -1;
}
+ *hostname = '\0';
if (inet_aton(ip, &addr) == 0) {
printf("---inet_aton fail\n");
return -1;
@@ -557,6 +636,7 @@
int count, index, words_count;
char * split_lines[128]= {0};
char * split_words[128] = {0};
+ char local_ssid[128] = {0};
const char *lynq_wifi_list_networks = "LIST_NETWORKS";
CHECK_WPA_CTRL(ap_sta);
@@ -571,7 +651,8 @@
for(index=1; index < count; index++) {
words_count = lynq_split(split_lines[index], strlen(split_lines[index]), '\t', split_words);
if (words_count > 2) {
- if (ssid == NULL || strcmp(split_words[1], ssid) == 0) {
+ inner_copy_ssid(local_ssid, split_words[1], sizeof (local_ssid));
+ if (ssid == NULL || strcmp(local_ssid, ssid) == 0) {
net_no_list[ret++] = atoi(split_words[0]);
}
}
@@ -677,6 +758,9 @@
else if (strstr( flag, "NONE") != NULL) {
return LYNQ_WIFI_AUTH_OPEN;
}
+ else if (strcmp( flag, "[ESS]") == 0) {
+ return LYNQ_WIFI_AUTH_OPEN;
+ }
}
return -1;
@@ -713,6 +797,7 @@
const char * FLAG_FREQ = "freq=";
const char * FLAG_STATE = "wpa_state=";
const char * FLAG_ID = "id=";
+ const char * FLAG_IPADDR = "ip_address=";
char *split_lines[128] = {0};
CHECK_WPA_CTRL(interface);
@@ -731,13 +816,13 @@
if (curr_state->ap != NULL) {
p = strstr(split_lines[i], FLAG_SBSID);
if (p != NULL) {
- strcpy(curr_state->ap->ap_mac, p + strlen(FLAG_SBSID));
+ strncpy(curr_state->ap->ap_mac, p + strlen(FLAG_SBSID), sizeof(curr_state->ap->ap_mac));
ret = 0;
continue;
}
p = strstr(split_lines[i], FLAG_SSID);
if (p != NULL) {
- strcpy(curr_state->ap->ap_ssid, p + strlen(FLAG_SSID));
+ inner_copy_ssid(curr_state->ap->ap_ssid, p + strlen(FLAG_SSID), sizeof (curr_state->ap->ap_ssid));
ret = 0;
continue;
}
@@ -754,6 +839,12 @@
ret = 0;
continue;
}
+ p = strstr(split_lines[i], FLAG_IPADDR);
+ if (p != NULL) {
+ strncpy(curr_state->ap->ap_ip, p + strlen(FLAG_IPADDR), sizeof(curr_state->ap->ap_ip));
+ ret = 0;
+ continue;
+ }
} // end if (ap != NULL)
if (curr_state->state != NULL) {
p = strstr(split_lines[i], FLAG_STATE);
@@ -806,19 +897,8 @@
int lynq_wifi_ap_ssid_get(lynq_wifi_index_e idx, char* ap_ssid)
{
- int len;
CHECK_IDX(idx, CTRL_AP);
- if (0 != inner_get_param(CTRL_AP, AP_NETWORK_0, "ssid", ap_ssid))
- return -1;
- len = strlen(ap_ssid);
- if (ap_ssid[0] == '\"') {
- memmove(ap_ssid, ap_ssid + 1, len - 1);
- len -= 1;
- }
- if (len > 0 && ap_ssid[len-1] == '\"') {
- ap_ssid[len-1] = '\0';
- }
- return 0;
+ return inner_get_param(CTRL_AP, AP_NETWORK_0, "ssid", ap_ssid);
}
/*****
@@ -832,34 +912,40 @@
*
* */
static int lynq_check_set_frequency(int input_frequency){
- static int legitimate_frequency[21]={2412,2417,2422,2427,2432,2437,2442,2447,2452,2457,2462,2467,2472,5180,5200,5220,5240,5745,5765,5785,5805,5825};
- int i = 0;
- int flag_check = 0;
- for(i=0 ;i<= 21; i++){
- if(input_frequency == legitimate_frequency[i]){
- flag_check = 1;
+ int legitimate_frequency[]={2412,2417,2422,2427,2432,2437,2442,2447,2452,2457,2462,2467,2472,5180,5200,5220,5240,5745,5765,5785,5805,5825};
+ int i;
+ int arr_len = sizeof(legitimate_frequency) / sizeof(int);
+
+ for(i = 0; i < arr_len; i++)
+ {
+ if(input_frequency == legitimate_frequency[i])
break;
- }
}
- if(flag_check == 1){
- printf("input frequency in range\n");
- }else{
- printf("input frequency is eero--->%d,please check it\n",input_frequency);
+
+ if(i == arr_len)
+ {
+ printf("input frequency is eero--->%d,please check it\n", input_frequency);
return -1;
}
+
return 0;
}
int lynq_wifi_ap_frequency_set(lynq_wifi_index_e idx,int lynq_wifi_frequency)
{
+ int check;
char lynq_wifi_frequency_cmd[128]={0};
char lynq_cmd_mode[128]={0};
char lynq_cmd_slect[128]={0};
//@do check input frequency
- if((lynq_check_set_frequency(lynq_wifi_frequency)) != 0){
+ check = lynq_check_set_frequency(lynq_wifi_frequency);
+ if(check != 0)
+ {
+ printf("do check frequency error\n");
return -1;
}
- if (lynq_check_network_number(idx, CTRL_AP, AP_NETWORK_0) != 0) {
+ if (lynq_check_network_number(idx, CTRL_AP, AP_NETWORK_0) != 0)
+ {
return -1;
}
@@ -1425,10 +1511,11 @@
int lynq_sta_ssid_password_get(lynq_wifi_index_e idx, ap_info_s *ap, char *password) { // @todo
FILE * fp;
- int len, ret, network_len;
+ int len, ret, network_len, i, ssid_len;
int count, index;
char *split_lines[128] = {0};
- char *buff, *p;
+ char *buff, *p, *ssid, *ssid_end_flag;
+ char tmp_ssid[128]={0};
network_len = 0;
p = NULL;
@@ -1468,9 +1555,28 @@
break;
}
- if (strstr(p, ap->ap_ssid) != NULL) {
- break;
+ ssid = strstr(p, "ssid=");
+ if (ssid != NULL) {
+ ssid += strlen("ssid=");
+ if (ssid[0] == '\"') {
+ if (memcmp(ssid + 1, ap->ap_ssid, strlen(ap->ap_ssid)) == 0 && ssid[strlen(ap->ap_ssid) + 1] == '\"')
+ break;
+ }
+ else{
+ ssid_end_flag = strstr(ssid, "\n");
+ if (ssid_end_flag != NULL)
+ {
+ ssid_len = (ssid_end_flag - ssid) / 2;
+ for(i=0; i<ssid_len; i++)
+ {
+ tmp_ssid[i] = inner_convert_char(ssid[i*2]) << 4 | inner_convert_char(ssid[i*2 + 1]);
+ }
+ if (memcmp(tmp_ssid, ap->ap_ssid, ssid_len) == 0)
+ break;
+ }
+ }
}
+
}
if (index >= len || NULL == p || network_len <= 0) {
@@ -1577,7 +1683,7 @@
curr_state.state = NULL;
if (0 == inner_get_status_info(CTRL_STA, &curr_state)) {
- strcpy(sta_ssid, ap_info.ap_ssid);
+ strncpy(sta_ssid, ap_info.ap_ssid, sizeof (ap_info.ap_ssid));
return 0;
}
@@ -1662,6 +1768,7 @@
best_scan_index = j;
best_rssi = scan_list[j].rssi;
}
+ strncpy(save_list[i].base_info.ap_mac, scan_list[j].mac, sizeof (save_list[i].base_info.ap_mac));
break;
}
}
@@ -1669,6 +1776,7 @@
if (best_index >= 0) {
memcpy(&info->base_info, &save_list[best_index].base_info, sizeof (ap_info_s));
+ inner_get_ip_by_mac( info->base_info.ap_mac, info->base_info.ap_ip, sizeof (info->base_info.ap_ip));
info->status = LYNQ_WIFI_AP_STATUS_DISABLE;
info->rssi = best_rssi;
ret = 0;
@@ -1839,44 +1947,52 @@
int lynq_wifi_sta_start(lynq_wifi_index_e idx)
{
- const char *lynq_reconfigure_cmd = "wpa_cli -iwpa_wlan0_cmd -p/var/run/ IFNAME=wlan0 RECONFIGURE /data/wifi/wg870/wpa_supplicant.conf";
- const char *lynq_reconnect_cmd = "RECONNECT";
+// const char *lynq_reconfigure_cmd = "wpa_cli -iwpa_wlan0_cmd -p/var/run/ IFNAME=wlan0 RECONFIGURE /data/wifi/wg870/wpa_supplicant.conf";
+// const char *lynq_reconnect_cmd = "RECONNECT";
+ const char *lynq_enable_sta_cmd = "wpa_cli -iwpa_wlan0_cmd -p/var/run/ IFNAME=wlan0 enable_net all";
+ const char *lynq_reconnect_cmd = "wpa_cli -iwpa_wlan0_cmd -p/var/run/ IFNAME=wlan0 reconnect";
+// const char *lynq_first_sta_cmd = "wpa_cli -iwpa_wlan0_cmd -p/var/run/ IFNAME=wlan0 remove_net all";
CHECK_IDX(idx, CTRL_STA);
CHECK_WPA_CTRL(CTRL_STA);
system("connmanctl enable wifi");
- if (system("ifconfig | grep -q wlan0") != 0) {
+ if (system("ifconfig | grep -q wlan0") != 0)
+ {
return -1;
}
- DO_OK_FAIL_REQUEST(cmd_remove_all);
- system(lynq_reconfigure_cmd);
- DO_OK_FAIL_REQUEST(lynq_reconnect_cmd);
-
+// DO_OK_FAIL_REQUEST(cmd_remove_all);
+// system(lynq_first_sta_cmd);
+// system(lynq_reconfigure_cmd);
+// DO_OK_FAIL_REQUEST(lynq_reconnect_cmd);
+ system(lynq_enable_sta_cmd);
+ system(lynq_reconnect_cmd);
+// DO_OK_FAIL_REQUEST(lynq_reconnect_cmd);
return 0;
}
int lynq_wifi_sta_stop(lynq_wifi_index_e idx)
{
- char lynq_disable_network_cmd[MAX_CMD];
- curr_status_info curr_state;
- ap_info_s ap_info;
+// char lynq_disable_network_cmd[MAX_CMD];
+// curr_status_info curr_state;
+// ap_info_s ap_info;
+ const char * lynq_disable_sta_cmd = "wpa_cli -iwpa_wlan0_cmd -p/var/run/ IFNAME=wlan0 disable_net all";
CHECK_IDX(idx, CTRL_STA);
CHECK_WPA_CTRL(CTRL_STA);
- curr_state.ap = &ap_info;
- curr_state.state = NULL;
+// curr_state.ap = &ap_info;
+// curr_state.state = NULL;
- if (0 != inner_get_status_info(CTRL_STA, &curr_state) || curr_state.net_no < 0) {
- return 0;
- }
+// if (0 != inner_get_status_info(CTRL_STA, &curr_state) || curr_state.net_no < 0) {
+// return 0;
+// }
- sprintf(lynq_disable_network_cmd, "DISABLE_NETWORK %d", curr_state.net_no);
- DO_OK_FAIL_REQUEST(lynq_disable_network_cmd);
-
+// sprintf(lynq_disable_network_cmd, "DISABLE_NETWORK %d", curr_state.net_no);
+// DO_OK_FAIL_REQUEST(lynq_disable_network_cmd);
+ system(lynq_disable_sta_cmd);
DO_OK_FAIL_REQUEST(cmd_save_config);
return 0;
@@ -1924,12 +2040,11 @@
int lynq_get_ap_device_list(lynq_wifi_index_e idx, ap_info_s **ap, device_info_s ** list,int * len)
{
- int ip_count, index, i, line_count;
+ int index, line_count;
+ device_info_s *dev_info;
const char *lynq_first_sta_cmd = "STA-FIRST";
char lynq_next_sta_cmd[MAX_CMD];
char *bssid[1024] = {0};
- char *mac_list[128] = {0};
- char *ip_list[128] = {0};
char *split_lines[128] = {0};
CHECK_IDX(idx, CTRL_AP);
@@ -1954,9 +2069,6 @@
lynq_get_interface_ip(idx, (*ap)->ap_ip);
lynq_ap_password_get(idx, (*ap)->psw);
- ip_count = get_ip_mac_list(mac_list, ip_list);
- printf("get count %d\n", ip_count);
-
DO_REQUEST(lynq_first_sta_cmd);
index = 0;
@@ -1971,7 +2083,7 @@
sprintf(lynq_next_sta_cmd, "STA-NEXT %s", split_lines[0]);
reply_len = MAX_RET;
cmd_reply[0] = '\0';
- ret = wpa_ctrl_request(lynq_wpa_ctrl, lynq_next_sta_cmd, strlen(lynq_next_sta_cmd), cmd_reply, &reply_len, NULL);
+ ret = local_wpa_ctrl_request(lynq_wpa_ctrl, lynq_next_sta_cmd, strlen(lynq_next_sta_cmd), cmd_reply, &reply_len, NULL);
if (ret != 0 || memcmp(cmd_reply, "FAIL", 4) == 0) {
printf("run %s fail \n", lynq_next_sta_cmd);
break;
@@ -1982,20 +2094,15 @@
*list = malloc(sizeof(device_info_s) * (*len));
for (index=0; index < *len; index++) {
- strcpy((*list)[index].sta_mac, bssid[index]);
- for(i=0;i < ip_count; i++ ) {
- if (strcmp(bssid[index], mac_list[i]) == 0) {
- strcpy((*list)[index].sta_ip, ip_list[i]);
- break;
- }
- }
- get_hostname_by_ip((*list)[index].sta_ip, list[index]->hostname);
- (*list)[index].status = LYNQ_WIFI_STATUS_CONNECT;
+ dev_info = &(*list)[index];
+ memset(dev_info, 0, sizeof(device_info_s));
+ strncpy(dev_info->sta_mac, bssid[index], sizeof (dev_info->sta_mac));
+ inner_get_ip_by_mac(dev_info->sta_mac, dev_info->sta_ip, sizeof (dev_info->sta_ip));
+ inner_get_hostname_by_ip(dev_info->sta_ip, dev_info->hostname);
+ dev_info->status = LYNQ_WIFI_STATUS_CONNECT;
free(bssid[index]);
}
- free_ip_mac_list_mem(mac_list, 128, ip_list, 128);
-
return 0;
}
@@ -2043,7 +2150,7 @@
p->band = convert_band_from_freq(atoi(split_words[1]));
p->rssi = -1 * atoi( split_words[2]);
p->auth = convert_max_auth_from_flag(split_words[3]);
- strcpy(p->ssid, split_words[4]);
+ inner_copy_ssid(p->ssid, split_words[4], sizeof (p->ssid));
}
return 0;
@@ -2090,10 +2197,9 @@
int lynq_get_sta_saved_ap(lynq_wifi_index_e idx, saved_ap_info_s ** list, int * len)
{
- int count, index, ssid_len;
+ int count, index;
int net_no_list[128];
char freq[16];
- char *ssid_ptr;
if (list == NULL || len == NULL) {
printf("bad param\n");
@@ -2114,17 +2220,6 @@
for (index=0; index < count; index++) {
printf("to get ssid %d\n", index);
inner_get_param(CTRL_STA, net_no_list[index], "ssid", (*list)[index].base_info.ap_ssid);
-
- ssid_ptr = (*list)[index].base_info.ap_ssid;
- ssid_len = strlen(ssid_ptr);
- if (ssid_ptr[0] == '\"') {
- memmove(ssid_ptr, ssid_ptr + 1, ssid_len - 1);
- ssid_len -= 1;
- }
- if (ssid_len > 0 && ssid_ptr[ssid_len - 1] == '\"') {
- ssid_ptr[ssid_len - 1] = '\0';
- }
-
inner_get_param(CTRL_STA, net_no_list[index], "bssid", (*list)[index].base_info.ap_mac);
inner_get_network_auth(CTRL_STA, net_no_list[index], &(*list)[index].base_info.auth);
if (inner_get_param(CTRL_STA, net_no_list[index], "frequency", freq) == 0) {
@@ -2262,7 +2357,7 @@
// reply_len = MAX_RET;
// cmd_reply[0] = '\0';
// printf("to call [%s]\n", cmd_str);
-// ret = wpa_ctrl_request(s_lynq_wpa_ctrl, cmd_str, strlen(cmd_str), cmd_reply, &reply_len, NULL);
+// ret = local_wpa_ctrl_request(s_lynq_wpa_ctrl, cmd_str, strlen(cmd_str), cmd_reply, &reply_len, NULL);
// if (ret != 0) {
// printf("call ##cmd_str fail %d\n", ret);
// return ret;
@@ -2390,6 +2485,7 @@
}
}
}
+ freeifaddrs(ifaddr_header);
return -1;
}
@@ -2503,11 +2599,7 @@
int lynq_get_connect_ap_ip(lynq_wifi_index_e idx, char *ip)
{
- int index;
- int ip_count = 0;
char bssid[1024] = {0};
- char *mac_list[128] = {0};
- char *ip_list[128] = {0};
if (ip == NULL)
{
@@ -2522,24 +2614,7 @@
return -1;
}
- ip_count = get_ip_mac_list(mac_list, ip_list);
-
- for (index=0; index < ip_count; index++)
- {
- if (strcmp(bssid, mac_list[index]) == 0)
- {
- strcpy(ip, ip_list[index]);
-
- free_ip_mac_list_mem(mac_list, 128, ip_list, 128);
-
- return 0;
- }
- }
-
- printf("not found\n");
- free_ip_mac_list_mem(mac_list, 128, ip_list, 128);
-
- return -1;
+ return inner_get_ip_by_mac(bssid, ip, 32); //better input by user
}
int lynq_ap_connect_num(int sta_number)