Squashed 'LYNQ_PUBLIC/' content from commit 79d8f932f
git-subtree-dir: LYNQ_PUBLIC
git-subtree-split: 79d8f932fb4ebc4b5aec6c5ace97634912394272
Change-Id: If2527ba937f56fe989487bf71e996f7cfd9fbe61
diff --git a/common_src/framework/lynq-framework-service/src/common.cpp b/common_src/framework/lynq-framework-service/src/common.cpp
new file mode 100644
index 0000000..469eee5
--- /dev/null
+++ b/common_src/framework/lynq-framework-service/src/common.cpp
@@ -0,0 +1,803 @@
+ /*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <string.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include<fcntl.h>
+#include<sys/stat.h>
+#include<sys/types.h>
+#include<unistd.h>
+#include <assert.h>
+#include <log/log.h>
+#include <vendor-ril/telephony/ril.h>
+#include <string>
+#include <mutex>
+#include <vector>
+#include <cutils/properties.h>
+
+#include "Radio_capability_switch_util.h"
+#include "common.h"
+#include "Phone_utils.h"
+#include "utils.h"
+#include "data.h"
+#include "cc.h"
+
+static pthread_mutex_t s_DataMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_DataCond = PTHREAD_COND_INITIALIZER;
+
+#undef LOG_TAG
+#define LOG_TAG "DEMO_COMMON"
+
+typedef enum {
+ STATE_IN_SERVICE =0,
+ STATE_OUT_OF_SERVICE =1,
+ STATE_EMERGENCY_ONLY =2,
+ STATE_POWER_OFF =3
+} Service_State;
+
+RfDesenseTxTest* m_RfDesense;
+static RIL_CardStatus_v6* cur_CardS_Status[2] = {NULL, NULL};
+static RIL_RadioCapability radio_capability[2];
+
+static int cur_voice_radio_tech[2] = {RADIO_TECH_UNKNOWN, RADIO_TECH_UNKNOWN};
+
+static int reg_voice_service_state[2] = {0, 0};
+static int reg_data_service_state[2] = {0, 0};
+static int reg_data_radio_tech[2] = {RADIO_TECH_UNKNOWN, RADIO_TECH_UNKNOWN};
+static int reg_voice_radio_tech[2] = {RADIO_TECH_UNKNOWN, RADIO_TECH_UNKNOWN};
+static int preferred_network_type[2] = {Phone_utils::PREFERRED_NETWORK_MODE, Phone_utils::PREFERRED_NETWORK_MODE};
+static int radio_status[2] = {RADIO_STATE_UNAVAILABLE, RADIO_STATE_UNAVAILABLE};
+static std::vector<int> call_state[2];
+
+static int default_sim_all = RIL_SOCKET_1;
+static int default_sim_all_except_data = RIL_SOCKET_1;
+static int default_sim_voice = RIL_SOCKET_1;
+static int default_sim_data = RIL_SOCKET_1;
+static int default_sim_sms = RIL_SOCKET_1;
+static bool isNeedReconnect = false;
+
+static std::int32_t token = 0;
+static std::mutex g_mutex;
+
+static int regCodeToRadioTechnology(int request, int code, int slot);
+
+void update_call_state(void *response, size_t responselen, int slot) {
+ int num = responselen / sizeof(RIL_Call *);
+ if(num == 0) {
+ call_state[slot].clear();
+ RLOGD("[SIM%d]clear call state", slot);
+ } else {
+ call_state[slot].clear();
+ for (int i = 0 ; i < num ; i++) {
+ RIL_Call *p_cur = ((RIL_Call **) response)[i];
+ /* each call info */
+ call_state[slot].push_back(p_cur->state);
+ RLOGD("[SIM%d][id:%d]update_call_state: %d", slot,p_cur->index, p_cur->state);
+ if(p_cur->isMT) {
+ resetMute();
+ }
+ }
+ }
+}
+
+int is_call_state_idle(int slot) {
+ bool is_idle = true;
+ if(!call_state[slot].empty()) {
+ is_idle = false;
+ }
+ RLOGD("[SIM%d]is_call_state_idle: %d", slot, is_idle);
+ return is_idle;
+}
+
+void update_preferred_network_type(int type, int slot) {
+ RLOGD("[SIM%d]update_preferred_network_type: %d", slot, type);
+ preferred_network_type[slot] = type;
+}
+
+int get_preferred_network_type(int slot) {
+ return preferred_network_type[slot];
+}
+
+static int needBlockReq(int request)
+{
+#ifdef ENABLE_BLOCK_FEATURE
+ return 1;
+#endif
+
+ switch (request){
+ case RIL_REQUEST_RADIO_POWER: return 1;
+ case RIL_REQUEST_SET_IMS_ENABLE: return 1;
+ //case RIL_REQUEST_DATA_REGISTRATION_STATE: return 1;
+ default: return 0;
+ }
+ return 0;
+}
+
+static int setupToken(int token, int mode, int block)
+{
+ switch (mode){
+ case INIT:
+ token |= INIT_TOKEN_MARK;
+ break;
+ case UDP:
+ token |= RIL_TOKEN_MARK;
+ break;
+ case ATCI:
+ token |= ATCI_TOKEN_MARK;
+ break;
+ case RSPD:
+ token |= RSP_DISP_TOKEN_MARK;
+ break;
+ case OTHER:
+ token |= OTHER_TOKEN_MARK;
+ break;
+ default:
+ break;
+ }
+
+ if(block)
+ token |= BLOCK_MARK;
+
+ return token;
+}
+
+bool isDataConnectEnable(int slot) {
+ char value[PROPERTY_VALUE_MAX] = {0};
+ utils::getMSimProperty(slot,PROP_DEFAULT_DATA_SIM_STATUS, value);
+ if(atoi(value) == 1) {
+ return true;
+ }
+ return false;
+}
+
+void updataDataConnectState(int slot, bool state) {
+ utils::setMSimProperty(slot,PROP_DEFAULT_DATA_SIM_STATUS, const_cast<char*>(state ? "1":"0"));
+}
+
+std::int32_t GenerateToken(int mode, int request) {
+ g_mutex.lock();
+ if (token +1 == TOKEN_MODE) {
+ token = 1;
+ } else {
+ token++;
+ }
+ std::int32_t t= 0;
+ t = setupToken(token,mode,needBlockReq(request));
+ g_mutex.unlock();
+ return t;
+}
+
+RequestInfo* creatRILInfoAndInit(int request, int mode, RIL_SOCKET_ID soc_id)
+{
+ RequestInfo *pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
+ if(pRI ==NULL){
+ RLOGE("%s,memory alloc error!",__func__);
+ return NULL;
+ }
+ android::initRequestInfo(pRI,request,mode, soc_id);
+ return pRI;
+}
+
+void set_default_sim_all_except_data(int slot_id) {
+ RLOGD("set_default_sim_all excpet data: %d", slot_id);
+ default_sim_all_except_data = slot_id;
+ set_default_sim_voice(slot_id);
+ set_default_sim_sms(slot_id);
+}
+
+int get_default_sim_all_except_data() {
+ return default_sim_all_except_data;
+}
+
+void set_default_sim_all(int slot_id){
+ RLOGD("set_default_sim_all: %d", slot_id);
+ default_sim_all = slot_id;
+ set_default_sim_all_except_data(slot_id);
+ set_default_sim_data(slot_id);
+}
+
+int get_default_sim_all(){
+ return default_sim_all;
+}
+
+void set_default_sim_voice(int slot_id){
+ RLOGD("set_default_sim_voice: %d", slot_id);
+ default_sim_voice = slot_id;
+}
+
+int get_default_sim_voice(){
+ return default_sim_voice;
+}
+
+void set_default_sim_data(int slot) {
+ RLOGD("set_default_sim_data: %d", slot);
+ pthread_mutex_lock(&s_DataMutex);
+ if(get_default_sim_data() != slot) {
+ if(isDataConnectEnable(get_default_sim_data())) {
+ isNeedReconnect = true;
+ deactivateDataCall(0,NULL,(RIL_SOCKET_ID)0,NULL);
+ RLOGD("set_default_sim_data, wait deactive data call done");
+ pthread_cond_wait(&s_DataCond, &s_DataMutex);
+ RLOGD("set_default_sim_data, deactive data call done");
+ }
+ RLOGD("set_default_sim_data, set prop");
+ default_sim_data = slot;
+ utils::mtk_property_set(PROP_DEFAULT_DATA_SIM, std::to_string(default_sim_data + 1).c_str());
+ while(!isRadioAvailable(RIL_SOCKET_ID(slot))) {
+ sleep(1);
+ RLOGD("[SIM%d]set_default_sim_data(RIL_REQUEST_SET_RADIO_CAPABILITY): wait radio available", slot);
+ }
+ syncDataSettings(RIL_SOCKET_ID(slot));
+ if(utils::is_support_dsds()) {
+ Radio_capability_switch_util::sendRadioCapabilityRequest(slot);
+ }
+ }
+ pthread_mutex_unlock(&s_DataMutex);
+}
+
+bool isNeedConnect() {
+ return isNeedReconnect;
+}
+
+void resetConnect() {
+ isNeedReconnect = false;
+}
+int get_default_sim_data_for_switch() {
+ return default_sim_data;
+}
+
+int get_default_sim_data(){
+ default_sim_data = utils::mtk_property_get_int32(PROP_DEFAULT_DATA_SIM, 1) -1;
+ return default_sim_data;
+}
+
+void set_default_sim_sms(int slot_id){
+ RLOGD("set_default_sim_sms: %d", slot_id);
+ default_sim_sms = slot_id;
+}
+
+int get_default_sim_sms() {
+ return default_sim_sms;
+}
+
+static int regCodeToServiceState(int request,int code, int slot);
+
+const char * radioStateToString(RIL_RadioState s) {
+ switch (s) {
+ case RADIO_STATE_OFF:
+ return "RADIO_OFF";
+ case RADIO_STATE_UNAVAILABLE:
+ return "RADIO_UNAVAILABLE";
+ case RADIO_STATE_SIM_NOT_READY:
+ return "RADIO_SIM_NOT_READY";
+ case RADIO_STATE_SIM_LOCKED_OR_ABSENT:
+ return "RADIO_SIM_LOCKED_OR_ABSENT";
+ case RADIO_STATE_SIM_READY:
+ return "RADIO_SIM_READY";
+ case RADIO_STATE_RUIM_NOT_READY:
+ return "RADIO_RUIM_NOT_READY";
+ case RADIO_STATE_RUIM_READY:
+ return "RADIO_RUIM_READY";
+ case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:
+ return "RADIO_RUIM_LOCKED_OR_ABSENT";
+ case RADIO_STATE_NV_NOT_READY:
+ return "RADIO_NV_NOT_READY";
+ case RADIO_STATE_NV_READY:
+ return "RADIO_NV_READY";
+ case RADIO_STATE_ON:
+ return "RADIO_ON";
+ default:
+ return "<unknown state>";
+ }
+}
+
+const char *rilSocketIdToString(RIL_SOCKET_ID socket_id) {
+ switch (socket_id) {
+ case RIL_SOCKET_1:
+ return "RIL_SOCKET_1";
+#if (SIM_COUNT >= 2)
+ case RIL_SOCKET_2:
+ return "RIL_SOCKET_2";
+#endif
+#if (SIM_COUNT >= 3)
+ case RIL_SOCKET_3:
+ return "RIL_SOCKET_3";
+#endif
+#if (SIM_COUNT >= 4)
+ case RIL_SOCKET_4:
+ return "RIL_SOCKET_4";
+#endif
+ default:
+ return "not a valid RIL";
+ }
+}
+
+void update_radio_capa(RIL_RadioCapability* cap, int slot) {
+ memset(&radio_capability[slot], 0, sizeof(RIL_RadioCapability));
+ if(cap != NULL) {
+ strcpy(radio_capability[slot].logicalModemUuid,cap->logicalModemUuid);
+ radio_capability[slot].phase = cap->phase;
+ radio_capability[slot].rat = cap->rat;
+ radio_capability[slot].session = cap->session;
+ radio_capability[slot].status = cap->status;
+ radio_capability[slot].version = cap->version;
+ }
+}
+
+RIL_RadioCapability get_radio_capa(int slot) {
+ return radio_capability[slot];
+}
+
+void update_voice_radio_tech(int code, int slot) {
+ cur_voice_radio_tech[slot] = code;
+}
+
+int get_voice_radio_tech(int slot){
+ return cur_voice_radio_tech[slot];
+}
+
+void updateCardStatusV6(RIL_CardStatus_v6 *card_status,int slot)
+{
+ if(cur_CardS_Status[slot] != NULL) {
+ RLOGD("[slot%d]updateCardStatusV6", slot);
+ for(int i = 0; i < cur_CardS_Status[slot]->num_applications; i++) {
+ free(cur_CardS_Status[slot]->applications[i].aid_ptr);
+ cur_CardS_Status[slot]->applications[i].aid_ptr = NULL;
+ free(cur_CardS_Status[slot]->applications[i].app_label_ptr);
+ cur_CardS_Status[slot]->applications[i].app_label_ptr = NULL;
+ }
+ free(cur_CardS_Status[slot]);
+ cur_CardS_Status[slot] = NULL;
+ }
+ cur_CardS_Status[slot] = (RIL_CardStatus_v6 *)calloc(1, sizeof(RIL_CardStatus_v6));
+ memset(cur_CardS_Status[slot], 0, sizeof(RIL_CardStatus_v6));
+ cur_CardS_Status[slot]->card_state = card_status->card_state;
+ cur_CardS_Status[slot]->cdma_subscription_app_index = card_status->cdma_subscription_app_index;
+ cur_CardS_Status[slot]->gsm_umts_subscription_app_index = card_status->gsm_umts_subscription_app_index;
+ cur_CardS_Status[slot]->ims_subscription_app_index = card_status->ims_subscription_app_index;
+ cur_CardS_Status[slot]->num_applications = card_status->num_applications;
+ cur_CardS_Status[slot]->universal_pin_state = card_status->universal_pin_state;
+ RLOGD("[slot%d]updateCardStatusV6 card_state: %d, cdma_index: %d, gsm_index: %d, "
+ "ims_index: %d, num_applications: %d, universal_pin_state: %d",
+ slot,
+ cur_CardS_Status[slot]->card_state,
+ cur_CardS_Status[slot]->cdma_subscription_app_index,
+ cur_CardS_Status[slot]->gsm_umts_subscription_app_index,
+ cur_CardS_Status[slot]->ims_subscription_app_index,
+ cur_CardS_Status[slot]->num_applications,
+ cur_CardS_Status[slot]->universal_pin_state);
+ if(card_status)
+ {
+ for(int i = 0; i < card_status->num_applications; i++) {
+ cur_CardS_Status[slot]->applications[i].app_state = card_status->applications[i].app_state;
+ cur_CardS_Status[slot]->applications[i].app_type = card_status->applications[i].app_type;
+ cur_CardS_Status[slot]->applications[i].perso_substate = card_status->applications[i].perso_substate;
+ cur_CardS_Status[slot]->applications[i].pin1 = card_status->applications[i].pin1;
+ cur_CardS_Status[slot]->applications[i].pin1_replaced = card_status->applications[i].pin1_replaced;
+ cur_CardS_Status[slot]->applications[i].pin2 = card_status->applications[i].pin2;
+ cur_CardS_Status[slot]->applications[i].aid_ptr = strdup(card_status->applications[i].aid_ptr);
+ cur_CardS_Status[slot]->applications[i].app_label_ptr = strdup(card_status->applications[i].app_label_ptr);
+ }
+ } else {
+ RLOGD("[slot%d]updateCardStatusV6: sim card message is null", slot);
+ }
+}
+
+char* getAid(int slot)
+{
+ char* aid = "";
+ int index = -1;
+ if(cur_CardS_Status[slot] != NULL){
+ if(Phone_utils::get_phone_type(slot) == Phone_utils::PHONE_TYPE_CDMA) {
+ index = cur_CardS_Status[slot]->cdma_subscription_app_index;
+ } else {
+ index = cur_CardS_Status[slot]->gsm_umts_subscription_app_index;
+ }
+ if(index >= 0 && index < cur_CardS_Status[slot]->num_applications) {
+ aid = cur_CardS_Status[slot]->applications[index].aid_ptr;
+ }
+ }
+ RLOGD("[slot%d] index: %d, getAid: %s", slot, index, aid);
+ return aid;
+}
+
+void update_reg_voice_service_state(int request, char *code, int slot, int32_t token)
+{
+ if((reg_voice_service_state[slot] != atoi(code)) || ((token&RIL_TOKEN_MARK) == RIL_TOKEN_MARK)) {
+ reg_voice_service_state[slot] = atoi(code);
+ regCodeToServiceState(request, atoi(code), slot);
+ }
+}
+
+void update_reg_voice_radio_tech(int request, int code, int slot, int32_t token) {
+ if((reg_voice_radio_tech[slot] != code) || ((token&RIL_TOKEN_MARK) == RIL_TOKEN_MARK)){
+ reg_voice_radio_tech[slot] = code;
+ regCodeToRadioTechnology(request, code, slot);
+ }
+}
+
+void update_reg_data_service_state(int request, char *code,int slot, int32_t token)
+{
+ if((reg_data_service_state[slot] != atoi(code)) || ((token&RIL_TOKEN_MARK) == RIL_TOKEN_MARK)) {
+ reg_data_service_state[slot] = atoi(code);
+ regCodeToServiceState(request, atoi(code), slot);
+ }
+}
+
+void update_reg_data_radio_tech(int request, int code, int slot, int32_t token){
+ if((reg_data_radio_tech[slot] != code) || ((token&RIL_TOKEN_MARK) == RIL_TOKEN_MARK)) {
+ reg_data_radio_tech[slot] = code;
+ regCodeToRadioTechnology(request, code, slot);
+ }
+}
+
+void registerRadioOn(RfDesenseTxTest* rf){
+ if(!m_RfDesense) {
+ m_RfDesense = rf;
+ }
+}
+
+void unregisterRadioOn() {
+ if(m_RfDesense) {
+ m_RfDesense == NULL;
+ }
+}
+
+void registerRadioOffOrNotAvailable(RfDesenseTxTest* rf){
+ if(!m_RfDesense) {
+ m_RfDesense = rf;
+ }
+}
+
+void unregisterRadioOffOrNotAvailable() {
+ if(m_RfDesense) {
+ m_RfDesense == NULL;
+ }
+}
+
+void registerOnUnsolOemHookRaw(RfDesenseTxTest* rf){
+ if(!m_RfDesense) {
+ m_RfDesense = rf;
+ }
+}
+
+void unregisterOnUnsolOemHookRaw(){
+ if(m_RfDesense) {
+ m_RfDesense == NULL;
+ }
+}
+
+void register_response_oem_hook_raw(RfDesenseTxTest* rf){
+ if(!m_RfDesense) {
+ m_RfDesense = rf;
+ }
+}
+
+void unregister_response_oem_hook_raw(){
+ if(m_RfDesense) {
+ m_RfDesense == NULL;
+ }
+}
+
+void updateRadioStatus(int newValue ,RIL_SOCKET_ID soc_id)
+{
+ RLOGD("updateRadioStatus oldState: %d, newState: %d", radio_status[soc_id], newValue);
+ bool newOn = (newValue == RADIO_STATE_ON);
+ bool oldOn = (radio_status[soc_id] == RADIO_STATE_ON);
+ bool newAvaiable = (newValue != RADIO_STATE_UNAVAILABLE);
+ bool oldAvaiable = (radio_status[soc_id] != RADIO_STATE_UNAVAILABLE);
+ if (newOn && !oldOn) {
+ RLOGD("RadioStateOn");
+ //printf("[SIM%d] radio on\n",soc_id +1);
+ if(m_RfDesense){
+ m_RfDesense->emRadioStateOn();
+ }
+ }
+
+ if ((!newOn || !newAvaiable) && !((!oldOn || !oldAvaiable))) {
+ RLOGD("RadioStateOfforNotAvailable");
+ //printf("[SIM%d] radio off or not available\n",soc_id +1);
+ if(m_RfDesense){
+ m_RfDesense->emRadioStateOfforNotAvailable();
+ }
+ }
+ if(newValue != radio_status[soc_id]) {
+ radio_status[soc_id] = newValue;
+ }
+}
+
+bool isRadioOn(RIL_SOCKET_ID soc_id)
+{
+ return radio_status[soc_id] == RADIO_STATE_ON;
+}
+
+bool isRadioAvailable(RIL_SOCKET_ID soc_id)
+{
+ return radio_status[soc_id] != RADIO_STATE_UNAVAILABLE;
+}
+
+static int regCodeToServiceState(int request,int code, int slot)
+{
+ RLOGD("[slot%d]regCodeToServiceState %d, request: %s",slot, code, android::requestToString(request));
+ switch (code)
+ {
+ case 0:
+ case 2: // 2 is "searching"
+ case 3: // 3 is "registration denied"
+ case 4: // 4 is "unknown" no vaild in current baseband
+ case 10:// same as 0, but indicates that emergency call is possible.
+ case 12:// same as 2, but indicates that emergency call is possible.
+ case 13:// same as 3, but indicates that emergency call is possible.
+ case 14:// same as 4, but indicates that emergency call is possible.
+ {
+ if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
+ printf("[QUERY][VOICE REG_STATUS][SIM%d] The current service state is OUT OF SERVICE\n", slot);
+ } else {
+ printf("[QUERY][DATA REG_STATUS][SIM%d] The current service state is OUT OF SERVICE\n", slot);
+ }
+ return STATE_OUT_OF_SERVICE;
+ }
+
+ case 1:
+ case 5:
+ {
+ if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
+ printf("[QUERY][VOICE REG_STATUS][SIM%d] The current service state is IN SERVICE\n", slot);
+ } else {
+ printf("[QUERY][DATA REG_STATUS][SIM%d] The current service state is IN SERVICE\n", slot);
+ }
+ return STATE_IN_SERVICE;
+ }
+
+ default:
+ {
+ if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
+ printf("[QUERY][VOICE REG_STATUS][SIM%d] Unexpected service state %d\n", slot, code);
+ } else {
+ printf("[QUERY][DATA REG_STATUS][SIM%d] Unexpected service state %d\n", slot, code);
+ }
+ RLOGW("[SIM%d]regCodeToServiceState: unexpected service state %d", slot, code);
+ return STATE_OUT_OF_SERVICE;
+ }
+ }
+}
+
+static int regCodeToRadioTechnology(int request, int code, int slot) {
+ RLOGD("[slot%d]regCodeToRadioTechnology %d, request: %s",slot, code, android::requestToString(request));
+ switch(code) {
+ case RADIO_TECH_LTE:
+ {
+ if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
+ printf("[QUERY][VOICE REG_STATUS][SIM%d] The registered radio technology is 4G\n", slot);
+ } else {
+ printf("[QUERY][DATA REG_STATUS][SIM%d] The registered radio technology is 4G\n", slot);
+ }
+ break;
+ }
+ case RADIO_TECH_GSM:
+ case RADIO_TECH_GPRS:
+ case RADIO_TECH_EDGE:
+ case RADIO_TECH_IS95A:
+ case RADIO_TECH_IS95B:
+ case RADIO_TECH_1xRTT:
+ {
+ if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
+ printf("[QUERY][VOICE REG_STATUS][SIM%d] The registered radio technology is 2G\n", slot);
+ } else {
+ printf("[QUERY][DATA REG_STATUS][SIM%d] The registered radio technology is 2G\n", slot);
+ }
+ break;
+ }
+ case RADIO_TECH_UMTS:
+ case RADIO_TECH_HSDPA:
+ case RADIO_TECH_HSUPA:
+ case RADIO_TECH_HSPA:
+ case RADIO_TECH_EHRPD:
+ case RADIO_TECH_HSPAP:
+ case RADIO_TECH_TD_SCDMA:
+ case RADIO_TECH_EVDO_0:
+ case RADIO_TECH_EVDO_A:
+ case RADIO_TECH_EVDO_B:
+ {
+ if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
+ printf("[QUERY][VOICE REG_STATUS][SIM%d] The registered radio technology is 3G\n", slot);
+ } else {
+ printf("[QUERY][DATA REG_STATUS][SIM%d] The registered radio technology is 3G\n", slot);
+ }
+ break;
+ }
+#ifdef TELEMATIC_5G_SUPPORT
+ case RADIO_TECH_NR://5G
+ {
+ if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
+ printf("[QUERY][VOICE REG_STATUS][SIM%d] The registered radio technology is 5G\n", slot);
+ } else {
+ printf("[QUERY][DATA REG_STATUS][SIM%d] The registered radio technology is 5G\n", slot);
+ }
+ break;
+ }
+#endif
+ case RADIO_TECH_UNKNOWN:
+ {
+ if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
+ printf("[QUERY][VOICE REG_STATUS][SIM%d] The registered radio technology is unknown\n", slot);
+ } else {
+ printf("[QUERY][DATA REG_STATUS][SIM%d] The registered radio technology is unknown\n", slot);
+ }
+ break;
+ }
+ default:
+ {
+ if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
+ printf("[QUERY][VOICE REG_STATUS][SIM%d] %d is unexpected value\n",slot, code);
+ } else {
+ printf("[QUERY][DATA REG_STATUS][SIM%d] %d is unexpected value\n",slot, code);
+ }
+ }
+ }
+ return 0;
+}
+
+int get_reg_data_radio_tech(int slot) {
+ return reg_data_radio_tech[slot];
+}
+
+int get_reg_voice_radio_tech(int slot) {
+ return reg_voice_radio_tech[slot];
+}
+
+#ifdef ECALL_SUPPORT
+void ConvertMsd(const char *msdChar, unsigned char *msd) {
+ unsigned int n, x;
+
+ for (n = 0; n < MSD_MAX_LENGTH; n++) {
+ if (sscanf(&msdChar[n<<1], "%2x", &x) == 1) {
+ msd[n] = x;
+ } else {
+ RLOGE("invalid MSD characters");
+ break;
+ }
+ }
+}
+#endif /*ECALL_SUPPORT*/
+
+bool isFinalResponseErrorEx(char* str) {
+ AtLine atline(str, NULL);
+ return (atline.isFinalResponseErrorEx(0) == 1 ? true : false);
+}
+
+int get_atci_sim(){
+ return utils::mtk_property_get_int32(ATCI_SIM, 0);
+}
+
+static char *findNextChar(char *p, char c, int length)
+{
+ char *ptr = p;
+ int i = 0;
+ while (i++ < length)
+ {
+ if (*ptr++ == c)
+ return ptr;
+ }
+ return NULL;
+}
+
+static int getGMTval(char *pdata)
+{
+ char *ptr;
+ ptr = findNextChar(pdata, '+', strlen(pdata));
+ if (ptr == NULL)
+ {
+ ptr = findNextChar(pdata, '-', strlen(pdata));
+ if (ptr == NULL)
+ {
+ return 0;
+ }
+ }
+ return atoi(ptr);
+}
+
+static void adjustGMT2LocalTime(struct tm *src, int dGMTval)
+{
+ time_t t1, t2;
+ struct tm * ptm;
+ char buf[255];
+ int dShiftSec;
+
+ dShiftSec = dGMTval * 15 * 60;
+ t1 = mktime(src);
+ t2 = (time_t)(t1 + dShiftSec);
+ ptm = gmtime(&t2);
+
+ memcpy(src, ptm, sizeof(struct tm));
+}
+
+void updateSystemTime(const void *data, int datalen)
+{
+ char strTime[32];
+ struct tm tm;
+ time_t t;
+ int dGMTval;
+
+ if (data == NULL || datalen <= 0)
+ return;
+
+ memset(strTime, 0, sizeof(strTime));
+ strcat(strTime, "20");
+ strcat(strTime, (const char *)data);
+
+ dGMTval = getGMTval(strTime);
+ memset(&tm, 0, sizeof(struct tm));
+ strptime(strTime, "%Y/%m/%d,%H:%M:%S", &tm);
+
+ adjustGMT2LocalTime(&tm, dGMTval);
+
+ t = mktime(&tm);
+ stime(&t);
+
+ return;
+}
+void notifyDataSignal() {
+ RLOGE("notifyDataSignal()");
+ pthread_mutex_lock(&s_DataMutex);
+ pthread_cond_broadcast(&s_DataCond);
+ pthread_mutex_unlock(&s_DataMutex);
+}
+
+bool mtkItTest(const char* data) {
+ std::string str("");
+ str.append(data);
+ RLOGD("%s, data: %s", __FUNCTION__, str.c_str());
+ std::vector<std::string> all;
+ RequestInfo* pRI = NULL;
+ utils::tokenize(str, ',', all);
+ if(all[0] != std::string("TEST")) {
+ return false;
+ }
+ android::Parcel p;
+ size_t pos = p.dataPosition();
+ for(int i = 1 ; i < all.size(); i++) {
+ std::string str = all[i];
+ RLOGD("%s, all[%d]: %s", __FUNCTION__, i, str.c_str());
+ std::vector<std::string> items;
+ utils::tokenize(str, '=', items);
+ if(items.size() == 2) {
+ if(items[0] == std::string("INT")) {
+ int para = std::stoi(items[1]);
+ p.writeInt32(para);
+ } else if(items[0] == std::string("STR")) {
+ writeStringToParcel(p, items[1].c_str());
+ } else if(items[0] == std::string("REQ")) {
+ int request = std::stoi(items[1]);
+ pRI = creatRILInfoAndInit(request, UDP, (RIL_SOCKET_ID) ((0)));
+ }
+ } else {
+ RLOGD("%s, too many \"=\"");
+ }
+ }
+ if(pRI && pRI->pCI) {
+ p.setDataPosition(pos);
+ pRI->pCI->dispatchFunction(p, pRI);
+ } else {
+ if(pRI) {
+ free(pRI);
+ pRI = NULL;
+ }
+ }
+ return true;
+}