| #include "gsw_nw_interface.h" | |
| #include <dlfcn.h> | |
| #include <time.h> | |
| #include <pthread.h> | |
| //mbtk include | |
| #define LYNQ_AIR_PLANE_MODE_OFF 1 //at+cfun = 1 | |
| #define LYNQ_AIR_PLANE_MODE_ON 4 // at+cfun = 4 | |
| #define LYNQ_AIR_CFUN_MODE_OFF 0 // at+cfun = 0 | |
| #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) | |
| #define FPLMN_STRING_LENGTH 120 | |
| #define ENTRY_LENGTH 6 | |
| #define FPLMN_ARRAY_SIZE (FPLMN_STRING_LENGTH / 6) + 1 | |
| #ifndef FALSE | |
| #define FALSE (0) | |
| #endif | |
| #ifndef TRUE | |
| #define TRUE (!FALSE) | |
| #endif | |
| typedef unsigned int uint32; | |
| typedef unsigned char uint8; | |
| typedef unsigned short uint16; | |
| typedef void (*mbtk_info_callback_func)(const void* data, int data_len); | |
| typedef enum | |
| { | |
| MBTK_DEV_MODEM_MIN_FUN, //Modem 最小功能 | |
| MBTK_DEV_MODEM_FULL_FUN, //Modem 全功能 | |
| MBTK_DEV_MODEM_DISABLE_RECEIVE_RF_CIRCUITS = 3, //Modem 禁用射频接收电路 | |
| MBTK_DEV_MODEM_DISABLE_TRANSMIT_AND_RECEIVE_RF_CIRCUITS, //Modem禁用射频发射和接收电路 | |
| MBTK_DEV_MODEM_DISABLE_SIM, //Modem 禁用(U)SIM 卡 | |
| MBTK_DEV_MODEM_TURN_OFF_FULL_SECONDARY_RECEIVE, //Modem 完全禁用辅助接收 | |
| }MBTK_DEV_MODEM_FUNCTION; | |
| typedef enum | |
| { | |
| MBTK_CELL_TYPE_GSM = 0, | |
| MBTK_CELL_TYPE_UMTS, | |
| MBTK_CELL_TYPE_LTE | |
| } mbtk_cell_type_enum; | |
| typedef struct | |
| { | |
| MBTK_DEV_MODEM_FUNCTION fun; | |
| int rst; | |
| } mbtk_modem_info_t; | |
| typedef struct | |
| { | |
| int client_fd; | |
| pthread_t read_thread_id; | |
| int exit_fd[2]; | |
| bool is_waitting; | |
| pthread_cond_t cond; | |
| pthread_mutex_t mutex; | |
| pthread_mutex_t send_mutex; | |
| // Temp response data. | |
| uint16 info_err; | |
| uint16 data_len; | |
| void *data; | |
| //mbtk wyq for server_ready_status add start | |
| char server_ready_status; | |
| //mbtk wyq for server_ready_status add end | |
| mbtk_info_callback_func net_state_cb; | |
| mbtk_info_callback_func call_state_cb; | |
| mbtk_info_callback_func sms_state_cb; | |
| mbtk_info_callback_func radio_state_cb; | |
| mbtk_info_callback_func sim_state_cb; | |
| mbtk_info_callback_func pdp_state_cb; | |
| //add signal by xr | |
| mbtk_info_callback_func signal_state_cb; | |
| } mbtk_info_handle_t; | |
| typedef struct | |
| { | |
| // LTE server cell: tac, PCI, dlEuarfcn, ulEuarfcn, band | |
| // LTE cell: phyCellId,euArfcn,rsrp,rsrq | |
| // WCDMA server cell: lac, ci, arfcn | |
| // WCDMA cell: lac, ci, arfcn | |
| // GSM server cell: lac, ci, arfcn, bsic | |
| // GSM cell: | |
| uint32 value1; | |
| uint32 value2; | |
| uint32 value3; | |
| uint32 value4; | |
| uint32 value5; | |
| uint32 value6; | |
| uint32 value7; | |
| uint32 value8; | |
| uint32 value9; | |
| uint32 value10; | |
| } __attribute__((packed)) mbtk_cell_info_t; | |
| typedef struct | |
| { | |
| uint8 net_pref; // mbtk_net_pref_enum | |
| uint16 gsm_band; // mbtk_gsm_band_enum | |
| uint16 umts_band; // mbtk_umts_band_enum | |
| uint32 tdlte_band; // mbtk_tdlte_band_enum | |
| uint32 fddlte_band; // mbtk_fddlte_band_enum | |
| uint32 lte_ext_band; // mbtk_lte_ext_band_enum | |
| } __attribute__((packed)) mbtk_band_info_t; | |
| typedef struct list_arraynode | |
| { | |
| void *data; | |
| struct list_arraynode *next; | |
| } list_arraynode_t; | |
| typedef struct list_treenode | |
| { | |
| list_arraynode_t *data; | |
| int count; | |
| struct list_treenode *left; | |
| struct list_treenode *right; | |
| } list_treenode_t; | |
| typedef int (*list_sort_func)(void *data1, void *data2); | |
| typedef void (*list_free_func)(void *data); | |
| typedef struct list_node | |
| { | |
| uint32 size; | |
| list_sort_func sort_func; | |
| list_free_func free_func; | |
| uint32 cur_index; | |
| list_arraynode_t *cur_array_data; | |
| list_arraynode_t array_data; | |
| list_treenode_t tree_data; | |
| } list_node_t; | |
| /* | |
| 0: GSM | |
| 1: GSM Compact | |
| 2: UTRAN | |
| 3: GSM w/EGPRS | |
| 4: UTRAN w/HSDPA | |
| 5: UTRAN w/HSUPA | |
| 6: UTRAN w/HSDPA and HSUPA | |
| 7: E-UTRAN | |
| 8: UTRAN HSPA+ | |
| */ | |
| typedef enum { | |
| MBTK_RADIO_TECH_GSM = 0, | |
| MBTK_RADIO_TECH_GSM_COMPACT, | |
| MBTK_RADIO_TECH_UTRAN, | |
| MBTK_RADIO_TECH_GSM_EGPRS, | |
| MBTK_RADIO_TECH_UTRAN_HSDPA, | |
| MBTK_RADIO_TECH_UTRAN_HSUPA, | |
| MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA, | |
| MBTK_RADIO_TECH_E_UTRAN, // LTE | |
| MBTK_RADIO_TECH_UTRAN_HSPA | |
| } mbtk_radio_technology_enum; | |
| typedef struct | |
| { | |
| /* | |
| 0: automatic | |
| 1: manual | |
| */ | |
| uint8 net_sel_mode; | |
| /* | |
| 0: GSM | |
| 1: GSM Compact | |
| 2: UTRAN | |
| 3: GSM w/EGPRS | |
| 4: UTRAN w/HSDPA | |
| 5: UTRAN w/HSUPA | |
| 6: UTRAN w/HSDPA and HSUPA | |
| 7: E-UTRAN | |
| 8: UTRAN HSPA+ | |
| 0xFF: Unused | |
| */ | |
| uint8 net_type; | |
| //uint8 plmn[10]; // 46000 | |
| /* | |
| 0: unknown | |
| 1: available | |
| 2: current | |
| 3: forbidden | |
| */ | |
| uint8 net_state; | |
| uint32 plmn; | |
| } __attribute__((packed)) mbtk_net_info_t; | |
| typedef enum | |
| { | |
| MBTK_NET_REG_STATE_NON = 0, | |
| MBTK_NET_REG_STATE_HOME, | |
| MBTK_NET_REG_STATE_SEARCHING, | |
| MBTK_NET_REG_STATE_DENIED, | |
| MBTK_NET_REG_STATE_UNKNOWN, | |
| MBTK_NET_REG_STATE_ROAMING, | |
| MBTK_NET_REG_STATE_SMS_ONLY, | |
| MBTK_NET_REG_STATE_ROAMING_SMS, | |
| MBTK_NET_REG_STATE_ATTACHED_EMERGENCY, | |
| MBTK_NET_REG_STATE_CSFB_HOME, | |
| MBTK_NET_REG_STATE_CSFB_ROAMING, | |
| MBTK_NET_REG_STATE_EMERGENCY_ONLY | |
| } mbtk_net_reg_state_enum; | |
| typedef struct | |
| { | |
| uint8 call_state;// mbtk_net_reg_state_enum | |
| uint8 data_state;// mbtk_net_reg_state_enum | |
| uint8 ims_state;// mbtk_net_reg_state_enum | |
| uint8 type; // mbtk_radio_technology_enum | |
| uint16 lac; | |
| uint32 ci; | |
| } __attribute__((packed)) mbtk_net_reg_info_t; | |
| typedef struct | |
| { | |
| uint8 type; // mbtk_radio_technology_enum | |
| uint8 rssi; // 0: 113 dBm or less | |
| // 1: 111 dBm | |
| // 2��30: 109��53 dBm | |
| // 31: 51 dBm or greater | |
| // 99: not known or not detectable | |
| uint8 rxlev;// 0:rssi < -110 dBm | |
| // 1: -110 dBm �� rssi < -109 dBm | |
| // 2: -109 dBm �� rssi < -108 dBm | |
| // ...... | |
| // 61: -50 dBm �� rssi < -49 dBm | |
| // 62: -49 dBm �� rssi < -48 dBm | |
| // 63: -48 dBm �� rssi | |
| // 99: not known or not detectable | |
| uint8 ber; // 0...7 as RXQUAL values in the table in 3GPP TS 45.008 [20] subclause 8.2.4 | |
| // 99 not known or not detectable | |
| uint8 rscp; // 0: rscp < -120 dBm | |
| // 1: -120 dBm �� rscp < -119 dBm | |
| // 2: -119 dBm �� rscp < -118 dBm | |
| // ...... | |
| // 94: -27 dBm �� rscp < -26 dBm | |
| // 95: -26 dBm �� rscp < -25 dBm | |
| // 96: - 25 dBm �� rscp | |
| // 255: not known or not detectable | |
| uint8 ecno; // 0: Ec/Io < -24 dB | |
| // 1: -24 dB �� Ec/Io < -23.5 dB | |
| // 2: -23.5 dB �� Ec/Io < -23 dB | |
| // ...... | |
| // 47: -1 dB �� Ec/Io < -0.5 dB | |
| // 48: -0.5 dB �� Ec/Io < 0 dB | |
| // 49: 0 dB �� Ec/Io | |
| // 255: not known or not detectable | |
| uint8 rsrq; // 0: rsrq < -19.5 dB | |
| // 1: -19.5 dB �� rsrq < -19 dB | |
| // 2: -19 dB �� rsrq < -18.5 dB | |
| // ...... | |
| // 32: -4 dB �� rsrq < -3.5 dB | |
| // 33: -3.5 dB �� rsrq < -3 dB | |
| // 34: -3 dB �� rsrq | |
| // 255: not known or not detectable | |
| uint8 rsrp; // 0: rsrp < -140 dBm | |
| // 1: -140 dBm �� rsrp < -139 dBm | |
| // 2: -139 dBm �� rsrp < -138 dBm | |
| // ...... | |
| // 95: -46 dBm �� rsrp < -45 dBm | |
| // 96: -45 dBm �� rsrp < -44 dBm | |
| // 97: -44 dBm �� rsrp | |
| // 255: not known or not detectable | |
| } __attribute__((packed)) mbtk_signal_info_t; | |
| typedef struct{ | |
| uint8_t mode; | |
| uint32_t oosPhase[3]; //单位为秒 | |
| } mbtk_oos_info; | |
| typedef struct | |
| { | |
| /* Configuration parameters for MCM network full band network scan when OOS (out of service)*/ | |
| int t_min; | |
| int t_step; | |
| int t_max; | |
| }GSW_NW_OOS_CONFIG_INFO_T; | |
| #define GSW_HAL_FAIL GSW_HAL_NORMAL_FAIL | |
| #define GSW_HAL_MEM_INVAILD GSW_HAL_ARG_INVALID | |
| #define lib_mbtk_path "/lib/libmbtk_lib.so" | |
| mbtk_info_handle_t* nw_info_handle = NULL; | |
| static GSW_NW_ServingInfoHandlePtr serving_cb; | |
| static GSW_NW_SigInfoHandlePtr sig_cb; | |
| static GSW_NW_RejectCauseHandlePtr reject_cb; | |
| static GSW_NW_ModemStateHandlePtr modem_cb; | |
| static void *dlHandle_mbtk; | |
| int nw_init_flag = 0; | |
| int mode = -1; | |
| int fplmn_max_length = 0; | |
| gsw_nw_plmn_list_t gsw_nw_plmn_list; | |
| char fplmn_array[FPLMN_ARRAY_SIZE][7]; | |
| int fplmn_index = 0; | |
| static mbtk_info_handle_t* (*mbtk_info_handle_get)(void); | |
| static int (*mbtk_info_handle_free)(mbtk_info_handle_t** handle); | |
| int (*mbtk_net_sel_mode_get)(mbtk_info_handle_t* handle, mbtk_net_info_t *net); | |
| int (*mbtk_net_reg_get)(mbtk_info_handle_t* handle, mbtk_net_reg_info_t *reg); | |
| int (*mbtk_cell_get)(mbtk_info_handle_t* handle, mbtk_cell_type_enum *type, list_node_t **cell_list); | |
| int (*mbtk_get_modem_fun)(mbtk_info_handle_t* handle, int* fun); | |
| static int (*mbtk_set_modem_fun)(mbtk_info_handle_t* handle, mbtk_modem_info_t *info); | |
| int (*mbtk_current_band_get)(mbtk_info_handle_t* handle, mbtk_band_info_t *band); | |
| int (*mbtk_current_band_set)(mbtk_info_handle_t* handle, const mbtk_band_info_t *band); | |
| int (*mbtk_net_signal_get)(mbtk_info_handle_t* handle, mbtk_signal_info_t *signal); | |
| int (*mbtk_wakeup_state_set)(mbtk_info_handle_t* handle, uint32 wakeup_state); | |
| int (*mbtk_signal_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb); | |
| int (*mbtk_net_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb); | |
| int (*mbtk_fplmn_get)(mbtk_info_handle_t *handle, void *fplmn); | |
| int (*mbtk_fplmn_set)(mbtk_info_handle_t *handle, void *fplmn); | |
| int (*mbtk_radio_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb); | |
| int (*mbtk_oos_get)(mbtk_info_handle_t* handle, mbtk_oos_info *oos_info); | |
| int (*mbtk_oos_set)(mbtk_info_handle_t* handle, mbtk_oos_info *oos_info); | |
| static void (*mbtk_log)(int level, const char *format, ...); | |
| static void (*mbtk_log_init)(char *path, char *tag); | |
| #ifndef LOG_ERR_LEVEL | |
| #define LOG_ERR_LEVEL 3 /* error conditions */ | |
| #endif | |
| #ifndef LOG_WARN_LEVEL | |
| #define LOG_WARN_LEVEL 4 /* warning conditions */ | |
| #endif | |
| #ifndef LOG_INFO_LEVEL | |
| #define LOG_INFO_LEVEL 6 /* informational */ | |
| #endif | |
| #ifndef LOG_DEBUG_LEVEL | |
| #define LOG_DEBUG_LEVEL 7 /* debug-level messages */ | |
| #endif | |
| #ifndef LOG_VERBOSE_LEVEL | |
| #define LOG_VERBOSE_LEVEL 8 | |
| #endif | |
| #define LOGV(fmt, args ...) \ | |
| do{ \ | |
| char *file_ptr_1001 = __FILE__; \ | |
| char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \ | |
| char line_1001[10] = {0}; \ | |
| sprintf(line_1001, "%d", __LINE__); \ | |
| while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \ | |
| if(*ptr_1001 == '/') \ | |
| break; \ | |
| ptr_1001--; \ | |
| } \ | |
| mbtk_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \ | |
| } while(0) | |
| #define LOGI(fmt, args...) \ | |
| do{ \ | |
| char *file_ptr_1001 = __FILE__; \ | |
| char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \ | |
| char line_1001[10] = {0}; \ | |
| sprintf(line_1001, "%d", __LINE__); \ | |
| while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \ | |
| if(*ptr_1001 == '/') \ | |
| break; \ | |
| ptr_1001--; \ | |
| } \ | |
| mbtk_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \ | |
| } while(0) | |
| #define LOGD(fmt, args...) \ | |
| do{ \ | |
| char *file_ptr_1001 = __FILE__; \ | |
| char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \ | |
| char line_1001[10] = {0}; \ | |
| sprintf(line_1001, "%d", __LINE__); \ | |
| while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \ | |
| if(*ptr_1001 == '/') \ | |
| break; \ | |
| ptr_1001--; \ | |
| } \ | |
| mbtk_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \ | |
| } while(0) | |
| #define LOGW(fmt, args...) \ | |
| do{ \ | |
| char *file_ptr_1001 = __FILE__; \ | |
| char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \ | |
| char line_1001[10] = {0}; \ | |
| sprintf(line_1001, "%d", __LINE__); \ | |
| while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \ | |
| if(*ptr_1001 == '/') \ | |
| break; \ | |
| ptr_1001--; \ | |
| } \ | |
| mbtk_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \ | |
| } while(0) | |
| #define LOGE(fmt, args...) \ | |
| do{ \ | |
| char *file_ptr_1001 = __FILE__; \ | |
| char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \ | |
| char line_1001[10] = {0}; \ | |
| sprintf(line_1001, "%d", __LINE__); \ | |
| while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \ | |
| if(*ptr_1001 == '/') \ | |
| break; \ | |
| ptr_1001--; \ | |
| } \ | |
| mbtk_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \ | |
| } while(0) | |
| typedef struct | |
| { | |
| char *lynq_operator_l; | |
| char *lynq_operator_s; | |
| uint32 lynq_mcc_mnc; | |
| } lynq_operator_mcc_mnc_t; | |
| static lynq_operator_mcc_mnc_t lynq_operator_mcc_mnc[] = | |
| { | |
| {"China Mobile","CMCC",46000}, | |
| {"China Unicom","CU",46001}, | |
| {"China Mobile","CMCC",46002}, | |
| {"China Telecom","CT",46003}, | |
| {"China Mobile","CMCC",46004}, | |
| {"China Telecom","CT",46005}, | |
| {"China Unicom","CU",46006}, | |
| {"China Mobile","CMCC",46007}, | |
| {"China Mobile","CMCC",46008}, | |
| {"China Unicom","CU",46009}, | |
| {"China Telecom","CT",46011} | |
| }; | |
| //GSW include | |
| typedef enum prefer_mode | |
| { | |
| GSW_PREFER_MODE_GSW = 1, /**<2G only*/ | |
| GSW_PREFER_MODE_WCDMA = 2, /**< 3G only*/ | |
| GSW_PREFER_MODE_WCDMA_GSM = 3, /**< 3G/2G*/ | |
| GSW_PREFER_MODE_LTE = 4, /**< 4G only*/ | |
| GSW_PREFER_MODE_NR5G = 5, /**< 5G only*/ | |
| GSW_PREFER_MODE_NR5G_LTE = 8, /**< 5G/4G*/ | |
| GSW_PREFER_MODE_LTE_WCDMA_GSM = 9, /**< 4G/3G/2G*/ | |
| GSW_PREFER_MODE_NR5G_LTE_WCDMA_GSM = 32, /**< 5G/4G/3G/2G*/ | |
| } PREFER_MODE_E; | |
| static int mbtk_nw_api_import() | |
| { | |
| dlHandle_mbtk = dlopen(lib_mbtk_path, RTLD_NOW); | |
| if (dlHandle_mbtk == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_log_init = (void (*)(char *path, char *tag))dlsym(dlHandle_mbtk, "mbtk_log_init"); | |
| if (mbtk_log_init == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_log = (void (*)(int level, const char *format, ...))dlsym(dlHandle_mbtk, "mbtk_log"); | |
| if (mbtk_log == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_info_handle_get = (mbtk_info_handle_t* (*)(void))dlsym(dlHandle_mbtk, "mbtk_info_handle_get"); | |
| if (mbtk_info_handle_get == NULL) | |
| { | |
| LOGE("mbtk_info_handle_get dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_info_handle_free = (int (*)(mbtk_info_handle_t** handle))dlsym(dlHandle_mbtk, "mbtk_info_handle_free"); | |
| if (mbtk_info_handle_free == NULL) | |
| { | |
| LOGE("mbtk_info_handle_free dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_net_sel_mode_get = (int (*)(mbtk_info_handle_t* handle, mbtk_net_info_t *net))dlsym(dlHandle_mbtk, "mbtk_net_sel_mode_get"); | |
| if (mbtk_net_sel_mode_get == NULL) | |
| { | |
| LOGE("mbtk_net_sel_mode_get dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_net_reg_get = (int (*)(mbtk_info_handle_t* handle, mbtk_net_reg_info_t *reg))dlsym(dlHandle_mbtk, "mbtk_net_reg_get"); | |
| if (mbtk_net_reg_get == NULL) | |
| { | |
| LOGE("mbtk_net_reg_get dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_get_modem_fun = (int (*)(mbtk_info_handle_t* handle, int* fun))dlsym(dlHandle_mbtk, "mbtk_get_modem_fun"); | |
| if (mbtk_get_modem_fun == NULL) | |
| { | |
| LOGE("mbtk_get_modem_fun dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_set_modem_fun = (int (*)(mbtk_info_handle_t* handle, mbtk_modem_info_t *info))dlsym(dlHandle_mbtk, "mbtk_set_modem_fun"); | |
| if (mbtk_set_modem_fun == NULL) | |
| { | |
| LOGE("mbtk_set_modem_fun dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_current_band_get = (int (*)(mbtk_info_handle_t* handle, mbtk_band_info_t *band))dlsym(dlHandle_mbtk, "mbtk_current_band_get"); | |
| if (mbtk_current_band_get == NULL) | |
| { | |
| LOGE("mbtk_current_band_get dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_current_band_set = (int (*)(mbtk_info_handle_t* handle, const mbtk_band_info_t *band))dlsym(dlHandle_mbtk, "mbtk_current_band_set"); | |
| if (mbtk_current_band_set == NULL) | |
| { | |
| LOGE("mbtk_current_band_set dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_net_signal_get = (int (*)(mbtk_info_handle_t* handle, mbtk_signal_info_t *signal))dlsym(dlHandle_mbtk, "mbtk_net_signal_get"); | |
| if (mbtk_net_signal_get == NULL) | |
| { | |
| LOGE("mbtk_net_signal_get dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_wakeup_state_set = (int (*)(mbtk_info_handle_t* handle, uint32 wakeup_state))dlsym(dlHandle_mbtk, "mbtk_wakeup_state_set"); | |
| if (mbtk_wakeup_state_set == NULL) | |
| { | |
| LOGE("mbtk_wakeup_state_set dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_cell_get = (int (*)(mbtk_info_handle_t* handle, mbtk_cell_type_enum *type, list_node_t **cell_list))dlsym(dlHandle_mbtk, "mbtk_cell_get"); | |
| if (mbtk_cell_get == NULL) | |
| { | |
| LOGE("mbtk_cell_get dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_signal_state_change_cb_reg = (int (*)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb))dlsym(dlHandle_mbtk, "mbtk_signal_state_change_cb_reg"); | |
| if (mbtk_signal_state_change_cb_reg == NULL) | |
| { | |
| LOGE("mbtk_signal_state_change_cb_reg dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_net_state_change_cb_reg = (int (*)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb))dlsym(dlHandle_mbtk, "mbtk_net_state_change_cb_reg"); | |
| if (mbtk_net_state_change_cb_reg == NULL) | |
| { | |
| LOGE("mbtk_net_state_change_cb_reg dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_fplmn_get = (int(*)(mbtk_info_handle_t *handle, void *fplmn))dlsym(dlHandle_mbtk, "mbtk_fplmn_get"); | |
| if (mbtk_fplmn_get == NULL) | |
| { | |
| LOGE("mbtk_fplmn_get dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_fplmn_set = (int(*)(mbtk_info_handle_t *handle, void *fplmn))dlsym(dlHandle_mbtk, "mbtk_fplmn_set"); | |
| if (mbtk_fplmn_set == NULL) | |
| { | |
| LOGE("mbtk_fplmn_get dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_radio_state_change_cb_reg = (int (*)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb))dlsym(dlHandle_mbtk, "mbtk_radio_state_change_cb_reg"); | |
| if (mbtk_radio_state_change_cb_reg == NULL) | |
| { | |
| LOGE("mbtk_radio_state_change_cb_reg dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_oos_get = (int (*)(mbtk_info_handle_t* handle, mbtk_oos_info *oos))dlsym(dlHandle_mbtk, "mbtk_oos_get"); | |
| if (mbtk_oos_get == NULL) | |
| { | |
| LOGE("mbtk_oos_get dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_oos_set = (int (*)(mbtk_info_handle_t* handle, mbtk_oos_info *oos))dlsym(dlHandle_mbtk, "mbtk_oos_set"); | |
| if (mbtk_oos_set == NULL) | |
| { | |
| LOGE("mbtk_oos_set dlsym fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |
| void list_first(list_node_t *list) | |
| { | |
| if (list) { | |
| list->cur_index = 0; | |
| list->cur_array_data = list->array_data.next; | |
| } | |
| } | |
| void* list_next(list_node_t *list) | |
| { | |
| if (list) { | |
| list_arraynode_t *node = list->cur_array_data; | |
| if (node) { | |
| LOGE("node is not null\n"); | |
| list->cur_array_data = list->cur_array_data->next; | |
| list->cur_index++; | |
| return node->data; | |
| } else { | |
| LOGE("node is null\n"); | |
| return NULL; | |
| } | |
| } else { | |
| LOGE("list is null\n"); | |
| return NULL; | |
| } | |
| } | |
| void list_free(list_node_t *list) | |
| { | |
| if (list) { | |
| list_arraynode_t *node = &(list->array_data); // Head node | |
| list_arraynode_t *node_temp = NULL; | |
| while (node->next) { | |
| node_temp = node->next; | |
| node->next = node->next->next; | |
| if (list->free_func) { | |
| list->free_func(node_temp->data); | |
| } else { | |
| free(node_temp->data); | |
| } | |
| free(node_temp); | |
| } | |
| free(list); | |
| } | |
| } | |
| static int gsw_rssi_to_csq(int rssi) | |
| { | |
| LOGD("rssi = %d\n",rssi); | |
| if(rssi >= -113 && rssi <= -51) | |
| { | |
| return (rssi + 113) / 2; | |
| } | |
| else | |
| { | |
| return 99; | |
| } | |
| } | |
| static int gsw_rscp_to_csq(int rscp) | |
| { | |
| LOGD("rscp = %d\n",rscp); | |
| if(rscp <= -25 && rscp > -120) | |
| { | |
| return rscp + 120; | |
| } | |
| else | |
| { | |
| return 255; | |
| } | |
| } | |
| static int gsw_rsrp_to_csq(int rsrp) | |
| { | |
| LOGD("rsrp = %d\n",rsrp); | |
| if(rsrp <= -44 && rsrp > -140) | |
| { | |
| return rsrp + 140; | |
| } | |
| else | |
| { | |
| return 255; | |
| } | |
| } | |
| static int rscp_convert_to_dBm(int rscp) | |
| { | |
| if(rscp <= 96 && rscp >= 0) | |
| { | |
| return rscp - 120; | |
| } | |
| else | |
| { | |
| return -25; | |
| } | |
| } | |
| static int8_t rssi_convert_to_dBm(uint8 rssi) | |
| { | |
| if(rssi <= 31) | |
| { | |
| return rssi * 2 - 113; | |
| } | |
| else | |
| { | |
| return -125; | |
| } | |
| } | |
| static int16_t rsrp_convert_to_dBm(uint8 rsrp) | |
| { | |
| if(rsrp <= 96) | |
| { | |
| return rsrp - 140; | |
| } | |
| else | |
| { | |
| return -44; | |
| } | |
| } | |
| static int16_t rsrq_convert_to_dB(uint8 rsrq) | |
| { | |
| if(rsrq >= 1 && rsrq <= 34) | |
| { | |
| return (rsrq + 1) / 2 - 20; | |
| } | |
| else | |
| { | |
| return -20; | |
| } | |
| } | |
| static int16_t ecno_convert_to_dB(uint8 ecno) | |
| { | |
| if(ecno >= 48) | |
| { | |
| return 0; | |
| } | |
| else if(ecno == 255) | |
| { | |
| return 255; | |
| } | |
| else | |
| { | |
| return 48 - ecno; | |
| } | |
| } | |
| static int convert_reg_state(int reg_state_t) | |
| { | |
| LOGD("reg_state_t = %d\n",reg_state_t); | |
| int reg_state = 0; | |
| switch (reg_state_t) | |
| { | |
| case MBTK_NET_REG_STATE_NON: | |
| { | |
| reg_state = GSW_NETWORK_REG_NOT_REGISTERED; | |
| break; | |
| } | |
| case MBTK_NET_REG_STATE_HOME: | |
| { | |
| reg_state = GSW_NETWORK_REG_REGISTERED; | |
| break; | |
| } | |
| case MBTK_NET_REG_STATE_SEARCHING: | |
| { | |
| reg_state = GSW_NETWORK_REG_NOT_REGISTERED_SEARCHING; | |
| break; | |
| } | |
| case MBTK_NET_REG_STATE_DENIED: | |
| { | |
| reg_state = GSW_NETWORK_REG_REGISTRATION_DENIED; | |
| break; | |
| } | |
| case MBTK_NET_REG_STATE_UNKNOWN: | |
| { | |
| reg_state = GSW_NETWORK_REG_REGISTRATION_UNKNOWN; | |
| break; | |
| } | |
| case MBTK_NET_REG_STATE_ROAMING: | |
| { | |
| reg_state = GSW_NETWORK_REG_REGISTRATION_ROAMING; | |
| break; | |
| } | |
| case MBTK_NET_REG_STATE_SMS_ONLY: | |
| case MBTK_NET_REG_STATE_ROAMING_SMS: | |
| case MBTK_NET_REG_STATE_ATTACHED_EMERGENCY: | |
| case MBTK_NET_REG_STATE_CSFB_HOME: | |
| case MBTK_NET_REG_STATE_CSFB_ROAMING: | |
| case MBTK_NET_REG_STATE_EMERGENCY_ONLY: | |
| { | |
| reg_state = GSW_NETWORK_REG_LIMITED_SERVICE; | |
| break; | |
| } | |
| } | |
| return reg_state; | |
| } | |
| static int convert_net_mode(int net_mode) | |
| { | |
| LOGD("net_mode = %d\n",net_mode); | |
| switch(net_mode) | |
| { | |
| case MBTK_RADIO_TECH_GSM: | |
| case MBTK_RADIO_TECH_GSM_COMPACT: | |
| case MBTK_RADIO_TECH_GSM_EGPRS: | |
| { | |
| return GSW_NETWORK_RADIO_GSM; | |
| } | |
| case MBTK_RADIO_TECH_UTRAN: | |
| case MBTK_RADIO_TECH_UTRAN_HSDPA: | |
| case MBTK_RADIO_TECH_UTRAN_HSUPA: | |
| case MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA: | |
| case MBTK_RADIO_TECH_UTRAN_HSPA: | |
| { | |
| return GSW_NETWORK_RADIO_UMTS; | |
| } | |
| case MBTK_RADIO_TECH_E_UTRAN: | |
| { | |
| return GSW_NETWORK_RADIO_LTE; | |
| } | |
| default: | |
| { | |
| return GSW_NETWORK_RADIO_NO_SVC; | |
| } | |
| } | |
| return GSW_NETWORK_RADIO_NO_SVC; | |
| } | |
| static int convert_mbtk_net_config(int config) | |
| { | |
| int net_pref = -1; | |
| switch(config) | |
| { | |
| case GSW_PREFER_MODE_GSW: | |
| { | |
| net_pref = 0; | |
| break; | |
| } | |
| case GSW_PREFER_MODE_WCDMA: | |
| { | |
| net_pref = 1; | |
| break; | |
| } | |
| case GSW_PREFER_MODE_WCDMA_GSM: | |
| { | |
| net_pref = 2; | |
| break; | |
| } | |
| case GSW_PREFER_MODE_LTE: | |
| case GSW_PREFER_MODE_NR5G: | |
| case GSW_PREFER_MODE_NR5G_LTE: | |
| { | |
| net_pref = 5; | |
| break; | |
| } | |
| case GSW_PREFER_MODE_LTE_WCDMA_GSM: | |
| case GSW_PREFER_MODE_NR5G_LTE_WCDMA_GSM: | |
| { | |
| net_pref = 15; | |
| break; | |
| } | |
| } | |
| return net_pref; | |
| } | |
| static int convert_gsw_net_config(int config) | |
| { | |
| int net_config = -1; | |
| LOGD("config = %d\n"); | |
| switch (config) | |
| { | |
| case 0: | |
| { | |
| net_config = GSW_PREFER_MODE_GSW; | |
| break; | |
| } | |
| case 1: | |
| { | |
| net_config = GSW_PREFER_MODE_WCDMA; | |
| break; | |
| } | |
| case 2: | |
| { | |
| net_config = GSW_PREFER_MODE_WCDMA_GSM; | |
| break; | |
| } | |
| case 5: | |
| { | |
| net_config = GSW_PREFER_MODE_LTE; | |
| break; | |
| } | |
| case 15: | |
| { | |
| net_config = GSW_PREFER_MODE_LTE_WCDMA_GSM; | |
| break; | |
| } | |
| } | |
| return net_config; | |
| } | |
| //64F010 -> 46001 (64->46,F0->0,10->01) | |
| static void transform_fplmn_str_to_plmn(char *entry) | |
| { | |
| if (strncmp(entry, "FFFFFF", ENTRY_LENGTH) == 0) { | |
| return; //if FFFFFF,means invalid fplmn, do nothing | |
| } | |
| char temp = entry[0]; | |
| entry[0] = entry[1]; | |
| entry[1] = temp; | |
| temp = entry[ENTRY_LENGTH - 2]; | |
| entry[ENTRY_LENGTH - 2] = entry[ENTRY_LENGTH - 1]; | |
| entry[ENTRY_LENGTH - 1] = temp; | |
| memmove(entry + 2, entry + 3, ENTRY_LENGTH - 2); | |
| LOGE("after transform_fplmn_str_to_plmn: %s\n", entry); | |
| //valid fplmn | |
| fplmn_index++; | |
| } | |
| static void extract_mcc_mnc(char *entry, char *mcc, char *mnc) | |
| { | |
| strncpy(mcc,entry,3); | |
| mcc[3] = '\0'; | |
| strncpy(mnc,entry + 3,2); | |
| mnc[2] = '\0'; | |
| LOGE("entry = %s, mcc = %s, mnc = %s\n", entry, mcc, mnc); | |
| } | |
| static void update_fplmn_list(char *fplmn_str) | |
| { | |
| LOGE("fplmn_str = %s\n",fplmn_str); | |
| char temp_fplmn_array[FPLMN_ARRAY_SIZE][7]; | |
| memset(fplmn_array, 0, sizeof(fplmn_array)); | |
| memset(temp_fplmn_array, 0, sizeof(temp_fplmn_array)); | |
| fplmn_index = 0; | |
| int array_length = 0; | |
| for (int i = 0; i < strlen(fplmn_str); i += 6) { | |
| int length = (i + 6 < strlen(fplmn_str)) ? 6 : strlen(fplmn_str) - i; | |
| strncpy(temp_fplmn_array[array_length], fplmn_str + i, length); | |
| temp_fplmn_array[array_length][length] = '\0'; | |
| array_length++; | |
| if (i + 6 >= strlen(fplmn_str)) { | |
| break; | |
| } | |
| } | |
| for (int i = 0; i < array_length; i++) { | |
| LOGE("array[%d] = %s\n", i, temp_fplmn_array[i]); | |
| transform_fplmn_str_to_plmn(temp_fplmn_array[i]); | |
| strncpy(fplmn_array[i], temp_fplmn_array[i], ENTRY_LENGTH); | |
| LOGE("fplmn_array[%d] = %s\n", i, fplmn_array[i]); | |
| } | |
| } | |
| static void format_plmn(char *result, char *plmn_entry) | |
| { | |
| strncpy(result, plmn_entry, strlen(plmn_entry)); | |
| LOGE("result = %s, numStr = %s\n",result, plmn_entry); | |
| if (strlen(result) >= 2) { | |
| char temp = result[0]; | |
| result[0] = result[1]; | |
| result[1] = temp; | |
| } | |
| LOGE("1.result = %s\n",result); | |
| if (strlen(result) >= 3) { | |
| memmove(&result[3], &result[2], strlen(result) - 2 + 1); | |
| result[2] = 'F'; | |
| } | |
| LOGE("2.result = %s\n",result); | |
| if (strlen(result) >= 2) { | |
| char temp = result[strlen(result) - 1]; | |
| result[strlen(result) - 1] = result[strlen(result) - 2]; | |
| result[strlen(result) - 2] = temp; | |
| } | |
| LOGE("3.result = %s\n",result); | |
| } | |
| static void convert_plmn_to_fplmn_str(char *fplmn_str) | |
| { | |
| char temp_fplmn_str[128] = {0}; | |
| char temp[20]; // 临时存储单个格式化后的数字 | |
| int index = 0; | |
| for (int i = 0; i < fplmn_index; i++) { | |
| memset(temp, 0x0, sizeof(temp)); | |
| format_plmn(temp, fplmn_array[i]); | |
| strcat(temp_fplmn_str, temp); | |
| index += strlen(temp); | |
| } | |
| while(index < (6 * fplmn_max_length)) | |
| { | |
| temp_fplmn_str[index++] = 'F'; | |
| } | |
| // 修剪或截断formattedNumbers，确保它不超过6 * fplmn_max_length个字符 | |
| if (index > (6 * fplmn_max_length)) { | |
| temp_fplmn_str[(6 * fplmn_max_length)] = '\0'; | |
| } | |
| LOGE("%s\n", temp_fplmn_str); | |
| strncpy(fplmn_str, temp_fplmn_str, strlen(temp_fplmn_str)); | |
| LOGE("fplmn_str = %s\n", fplmn_str); | |
| } | |
| static int check_index(char *mcc, char *mnc) | |
| { | |
| int i = 0; | |
| for(i = 0; i < fplmn_index; i++) | |
| { | |
| if(strncmp(fplmn_array[i], mcc, 3) == 0 && strncmp(fplmn_array[i] + 3, mnc, 2) == 0) | |
| { | |
| LOGE("index = %d\n", i); | |
| return i; | |
| } | |
| } | |
| LOGE("not find\n"); | |
| return -1; | |
| } | |
| static void remove_fplmn(int index) | |
| { | |
| int write_index = 0; | |
| for (int i = 0; i < fplmn_index; i++) { | |
| if (i != index) { | |
| strncpy(fplmn_array[write_index++], fplmn_array[i], ENTRY_LENGTH); | |
| } | |
| } | |
| fplmn_index--; | |
| } | |
| static void gsw_serving_info_callback_thread() | |
| { | |
| GSW_NW_SERVING_INFO *serving_info = (GSW_NW_SERVING_INFO*)malloc(sizeof(GSW_NW_SERVING_INFO)); | |
| memset(serving_info, 0x0, sizeof(GSW_NW_SERVING_INFO)); | |
| int ret = -1; | |
| ret = gsw_get_nwinfo(serving_info); | |
| if(ret != 0) | |
| { | |
| LOGE("gsw_get_nwinfo failed\n"); | |
| free(serving_info); | |
| return; | |
| } | |
| if(serving_cb) | |
| { | |
| serving_cb(*serving_info); | |
| free(serving_info); | |
| } | |
| } | |
| static void gsw_serving_info_callback(const void* data, int data_len) | |
| { | |
| LOGE("gsw_serving_info_callback start\n"); | |
| if(data && data_len > 0) | |
| { | |
| pthread_t thread; | |
| pthread_create(&thread, NULL, (void*)gsw_serving_info_callback_thread, NULL); | |
| } | |
| else | |
| { | |
| LOGE("data is NULL\n"); | |
| return; | |
| } | |
| } | |
| static void gsw_sig_info_callback(const void* data, int data_len) | |
| { | |
| LOGE("gsw_sig_info_callback start\n"); | |
| if(data && data_len == 8) | |
| { | |
| uint8 *net_data = (uint8*)data; | |
| mbtk_radio_technology_enum type = (mbtk_radio_technology_enum)net_data[0]; | |
| signalStrength_t sig_strength; | |
| memset(&sig_strength, 0x0, sizeof(signalStrength_t)); | |
| sig_strength.gw_sig_valid = 0; | |
| sig_strength.wcdma_sig_valid = 0; | |
| sig_strength.lte_sig_valid = 0; | |
| sig_strength.nr_sig_valid = 0; | |
| if(type == MBTK_RADIO_TECH_GSM || type == MBTK_RADIO_TECH_GSM_COMPACT || \ | |
| type == MBTK_RADIO_TECH_GSM_EGPRS) //GSM | |
| { | |
| sig_strength.gw_sig_valid = 1; | |
| sig_strength.rssi = rssi_convert_to_dBm(net_data[1]); | |
| } | |
| else if(type == MBTK_RADIO_TECH_E_UTRAN) | |
| { | |
| sig_strength.lte_sig_valid = 1; | |
| sig_strength.rsrp = rsrp_convert_to_dBm(net_data[7]); | |
| sig_strength.rsrq = rsrq_convert_to_dB(net_data[6]); | |
| sig_strength.rssnr = -99; | |
| } | |
| else if (type == MBTK_RADIO_TECH_UTRAN || type == MBTK_RADIO_TECH_UTRAN_HSDPA || \ | |
| type == MBTK_RADIO_TECH_UTRAN_HSUPA || type == MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA || \ | |
| type == MBTK_RADIO_TECH_UTRAN_HSPA )//WCDMA | |
| { | |
| sig_strength.wcdma_sig_valid = 1; | |
| sig_strength.rscp = rssi_convert_to_dBm(net_data[1]); | |
| sig_strength.ecno = ecno_convert_to_dB(net_data[5]); | |
| } | |
| if(sig_cb != NULL) | |
| { | |
| sig_cb(sig_strength); | |
| } | |
| } | |
| else | |
| { | |
| LOGE("data is NULL\n"); | |
| } | |
| } | |
| static void gsw_modem_status_event_callback(const void* data, int data_len) | |
| { | |
| LOGE("gsw_modem_status_event_callback start\n"); | |
| gsw_mode_state_e state = GSW_MODEM_STATE_UNKNOWN; | |
| if(data && data_len > 0) | |
| { | |
| uint8 *net_data = (uint8*)data; | |
| LOGE("gsw_modem_status_event_callback,data = %d\n", *net_data); | |
| if(*net_data == 1) | |
| { | |
| state = GSW_MODEM_STATE_ONLINE; | |
| } | |
| else if(*net_data == 0) | |
| { | |
| state = GSW_MODEM_STATE_OFFLINE; | |
| } | |
| if(modem_cb != NULL) | |
| { | |
| modem_cb(state); | |
| } | |
| } | |
| } | |
| static void gsw_reject_callback(GSW_NW_RADIO_ACCESS_TECH_E rat, GSW_SERVICE_DOMAIN_E domain, int cause) | |
| { | |
| LOGE("gsw_reject_callback start,rat = %d,domain = %d,cause = %d\n",rat,domain,cause); | |
| GSW_NW_REJ_CAUSE_E *rej_cause = (GSW_NW_REJ_CAUSE_E*)malloc(sizeof(GSW_NW_REJ_CAUSE_E)); | |
| memset(rej_cause, 0x0, sizeof(GSW_NW_REJ_CAUSE_E)); | |
| rej_cause->rej_cause = cause; | |
| rej_cause->rej_rat = rat; | |
| rej_cause->rej_domain = domain; | |
| if(reject_cb != NULL) | |
| { | |
| LOGE("reject_cb is not NULL\n"); | |
| reject_cb(rej_cause); | |
| } | |
| else | |
| { | |
| LOGE("reject_cb is NULL\n"); | |
| } | |
| free(rej_cause); | |
| LOGE("gsw_reject_callback end\n"); | |
| } | |
| /** | |
| * @brief SDK interface to call back serving info | |
| * @param [in] handle_ptr | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_reg_serving_info_callback(GSW_NW_ServingInfoHandlePtr handle_ptr) | |
| { | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| if(handle_ptr == NULL) | |
| { | |
| LOGE("handle_ptr is NULL\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| serving_cb = handle_ptr; | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief SDK interface to call back sig info | |
| * @param [in] handle_ptr | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_reg_sig_info_callback(GSW_NW_SigInfoHandlePtr handle_ptr) | |
| { | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| if(handle_ptr == NULL) | |
| { | |
| LOGE("handle_ptr is NULL\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| sig_cb = handle_ptr; | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief SDK interface to call back rej cause | |
| * @param [in] handle_ptr | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_reg_rej_cause_callback(GSW_NW_RejectCauseHandlePtr handle_ptr) | |
| { | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| if(handle_ptr == NULL) | |
| { | |
| LOGE("handle_ptr is NULL\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| reject_cb = handle_ptr; | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief network sdk init | |
| * @param [in] token usr id define by who use | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_nw_sdk_init(int token) | |
| { | |
| int ret = -1; | |
| if (nw_init_flag == 1 && nw_info_handle != NULL) | |
| { | |
| return GSW_HAL_SUCCESS; | |
| } | |
| ret = mbtk_nw_api_import(); | |
| if (ret != 0) | |
| { | |
| LOGE("mbtk_nw_api_import fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| nw_info_handle = mbtk_info_handle_get(); | |
| if (nw_info_handle == NULL) | |
| { | |
| LOGE("mbtk_info_handle_get fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| char fplmn[256] = {0}; | |
| ret = mbtk_fplmn_get(nw_info_handle, fplmn); | |
| if(ret != 0) | |
| { | |
| LOGE("mbtk_fplmn_get failed : %d\n",ret); | |
| return GSW_HAL_FAIL; | |
| } | |
| fplmn_max_length = (strlen(fplmn)/6); | |
| LOGE("fplmn = %s, fplmn_max_length = %d\n",fplmn,fplmn_max_length); | |
| ret = mbtk_signal_state_change_cb_reg(nw_info_handle, gsw_sig_info_callback); | |
| if (ret != 0) | |
| { | |
| LOGE("mbtk_signal_state_change_cb_reg fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| ret = mbtk_net_state_change_cb_reg(nw_info_handle, gsw_serving_info_callback); | |
| if (ret != 0) | |
| { | |
| LOGE("mbtk_net_state_change_cb_reg fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| nw_init_flag = 1; | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief network sdk deinit | |
| * @param | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_nw_sdk_deinit(void) | |
| { | |
| int ret = -1; | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| ret = mbtk_info_handle_free(&nw_info_handle); | |
| if(ret != GSW_HAL_SUCCESS) | |
| { | |
| LOGE("mbtk_info_handle_free fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| dlclose(dlHandle_mbtk); | |
| nw_info_handle = NULL; | |
| nw_init_flag = 0; | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief get current network reg info | |
| * @param [out] serving_info struct for network info | |
| * include regstate ps_state opreator name mcc mcn etc | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_get_nwinfo(GSW_NW_SERVING_INFO *serving_info) | |
| { | |
| int ret = -1; | |
| LOGE("gsw_get_nwinfo start\n"); | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| LOGE("nw_sdk_deinit not init\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| LOGE("mbtk_net_reg_get start \n"); | |
| //regstate | |
| mbtk_net_reg_info_t reg; | |
| memset(®, 0x0, sizeof(mbtk_net_reg_info_t)); | |
| ret = mbtk_net_reg_get(nw_info_handle, ®); | |
| if(ret) | |
| { | |
| LOGE("mbtk_net_reg_get fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| LOGE("convert_cs_reg_state\n"); | |
| //cs_state | |
| serving_info->reg_state = convert_reg_state(reg.call_state); | |
| LOGE("convert_ps_reg_state\n"); | |
| //ps_state | |
| serving_info->ps_state = convert_reg_state(reg.data_state); | |
| LOGE("convert_rat_mode\n"); | |
| //reg_rat | |
| serving_info->reg_rat = convert_net_mode(reg.type); | |
| //srv_domain | |
| if(serving_info->reg_state == GSW_NETWORK_REG_REGISTERED || serving_info->reg_state == GSW_NETWORK_REG_REGISTRATION_ROAMING) | |
| { | |
| if(serving_info->ps_state == GSW_NETWORK_REG_REGISTERED || serving_info->ps_state == GSW_NETWORK_REG_REGISTRATION_ROAMING) | |
| { | |
| serving_info->srv_domain = GSW_SRV_DOMAIN_CS_PS; | |
| } | |
| else | |
| { | |
| serving_info->srv_domain = GSW_SRV_DOMAIN_CS_ONLY; | |
| } | |
| } | |
| else if (serving_info->ps_state == GSW_NETWORK_REG_REGISTERED || serving_info->ps_state == GSW_NETWORK_REG_REGISTRATION_ROAMING) | |
| { | |
| serving_info->srv_domain = GSW_SRV_DOMAIN_PS_ONLY; | |
| } | |
| else | |
| { | |
| serving_info->srv_domain = GSW_SRV_DOMAIN_NO_SVC; | |
| //if ps and cs is both not registed, reg_rat seted to GSW_NETWORK_RADIO_NO_SVC | |
| serving_info->reg_rat = GSW_NETWORK_RADIO_NO_SVC; | |
| } | |
| LOGD("roaming_ind\n"); | |
| //roaming_ind | |
| if(serving_info->ps_state == GSW_NETWORK_REG_REGISTRATION_ROAMING) | |
| { | |
| serving_info->roaming_ind = GSW_NETWORK_ROAMING_ON; | |
| } | |
| else | |
| { | |
| serving_info->roaming_ind = GSW_NETWORK_ROAMING_OFF; | |
| } | |
| LOGD("reject\n"); | |
| //reject | |
| if(serving_info->ps_state == GSW_NETWORK_REG_REGISTRATION_DENIED || serving_info->reg_state == GSW_NETWORK_REG_REGISTRATION_DENIED) | |
| { | |
| LOGD("reject_callback\n"); | |
| gsw_reject_callback(serving_info->reg_rat,serving_info->srv_domain,99); | |
| } | |
| LOGD("reg_plmn / operator name\n"); | |
| //reg_plmn / operator name | |
| mbtk_net_info_t net; | |
| memset(&net, 0x0, sizeof(mbtk_net_info_t)); | |
| LOGD("mbtk_net_sel_mode_get start \n"); | |
| ret = mbtk_net_sel_mode_get(nw_info_handle, &net); | |
| LOGD("mbtk_net_sel_mode_get end \n"); | |
| if(ret == 0 && net.plmn > 0) | |
| { | |
| int i = 0; | |
| LOGD("start to find mcc"); | |
| while(i < ARRAY_SIZE(lynq_operator_mcc_mnc)) | |
| { | |
| if(lynq_operator_mcc_mnc[i].lynq_mcc_mnc == net.plmn) | |
| { | |
| LOGD("find mcc\n"); | |
| break; | |
| } | |
| i++; | |
| } | |
| if(i == ARRAY_SIZE(lynq_operator_mcc_mnc)) | |
| { | |
| LOGD("not find mcc"); | |
| strcpy(serving_info->operator_name, "unknown"); | |
| sprintf(serving_info->reg_plmn, "%d", net.plmn); | |
| } | |
| else | |
| { | |
| LOGD("find mcc\n"); | |
| strcpy(serving_info->operator_name, lynq_operator_mcc_mnc[i].lynq_operator_l); | |
| sprintf(serving_info->reg_plmn, "%d", net.plmn); | |
| } | |
| LOGE("operator_name = %s\n", serving_info->operator_name); | |
| LOGE("reg_plmn = %s\n", serving_info->reg_plmn); | |
| } | |
| LOGD("get cell id/tac/lac/sid/nid\n"); | |
| //cell id/tac/lac/sid/nid | |
| mbtk_cell_type_enum cell_type; | |
| if(serving_info->reg_rat == GSW_NETWORK_RADIO_GSM) | |
| { | |
| cell_type = MBTK_CELL_TYPE_GSM; | |
| } | |
| else if(serving_info->reg_rat == GSW_NETWORK_RADIO_UMTS) | |
| { | |
| cell_type = MBTK_CELL_TYPE_UMTS; | |
| } | |
| else | |
| { | |
| cell_type = MBTK_CELL_TYPE_LTE; | |
| } | |
| list_node_t* cell_list = NULL; | |
| LOGD("mbtk_cell_get start\n"); | |
| ret = mbtk_cell_get(nw_info_handle, &cell_type, &cell_list); | |
| if(ret != 0 || cell_list == NULL) | |
| { | |
| LOGE("mbtk_cell_get fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| else | |
| { | |
| LOGE("mbtk_cell_get end,start to get node\n"); | |
| list_first(cell_list); | |
| LOGE("list_first end\n"); | |
| mbtk_cell_info_t* cell = (mbtk_cell_info_t*) list_next(cell_list); | |
| if(cell) | |
| { | |
| LOGE("cell is not null,value2 = %u\n",cell->value2); | |
| switch(cell_type) | |
| { | |
| case MBTK_CELL_TYPE_LTE: | |
| { | |
| LOGE("is lte\n"); | |
| //LOGE("LTE : tac=%x, PCI=%x, dlEuarfcn=%x, ulEuarfcn=%x, band=%x\n", cell->value1, cell->value2, cell->value3, cell->value4, cell->value5); | |
| LOGE("LTE : tac=%d, PCI=%d, dlEuarfcn=%d, ulEuarfcn=%d, band=%d\n", cell->value1, cell->value2, cell->value3, cell->value4, cell->value5); | |
| snprintf(serving_info->tac,sizeof(serving_info->tac),"%d",cell->value1); | |
| strcpy(serving_info->lac,""); | |
| snprintf(serving_info->cell_id,sizeof(serving_info->cell_id),"%d",cell->value8); | |
| break; | |
| } | |
| case MBTK_CELL_TYPE_GSM: | |
| { | |
| LOGE("is gsm\n"); | |
| LOGE("GSM : lac=%d, ci=%d, arfcn=%d, bsic=%d\n", cell->value1, cell->value2, cell->value3, cell->value4); | |
| sprintf(serving_info->lac,"%d",cell->value1); | |
| memset(serving_info->tac,0,sizeof(serving_info->tac)); | |
| sprintf(serving_info->cell_id,"%d",cell->value2); | |
| break; | |
| } | |
| case MBTK_CELL_TYPE_UMTS: | |
| { | |
| LOGE("is wcdma\n"); | |
| LOGE("UMTS : lac=%d, ci=%d, arfcn=%d\n", cell->value1, cell->value2, cell->value3); | |
| sprintf(serving_info->lac,"%d",cell->value1); | |
| memset(serving_info->tac,0,sizeof(serving_info->tac)); | |
| sprintf(serving_info->cell_id,"%d",cell->value2); | |
| break; | |
| } | |
| default: | |
| break; | |
| } | |
| } | |
| else | |
| { | |
| LOGE("cell is null\n"); | |
| } | |
| } | |
| //not support now | |
| serving_info->sid = 0; | |
| serving_info->nid = 0; | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief get current network type | |
| * @param [out] netype as GSW_NW_RADIO_ACCESS_TECH_E type | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_get_netype(int *netype) | |
| { | |
| int ret = -1; | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| //regstate | |
| mbtk_net_reg_info_t reg; | |
| ret = mbtk_net_reg_get(nw_info_handle, ®); | |
| if(ret) | |
| { | |
| LOGE("mbtk_net_reg_get fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| if(reg.data_state == MBTK_NET_REG_STATE_HOME || reg.data_state == MBTK_NET_REG_STATE_ROAMING) | |
| { | |
| *netype = convert_net_mode(reg.type); | |
| } | |
| else | |
| { | |
| *netype = GSW_NETWORK_RADIO_NO_SVC; | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief get radio opmode, as open and close airplane mode | |
| * @param [out] op_mode 1 is radio on, 0 is radio off | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_get_opmode(int *op_mode) | |
| { | |
| int tmp_rf = -1; | |
| int ret = -1; | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| ret = mbtk_get_modem_fun(nw_info_handle, &tmp_rf); | |
| if (ret != 0) | |
| { | |
| LOGE("mbtk_get_modem_fun fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| if(tmp_rf == LYNQ_AIR_CFUN_MODE_OFF) | |
| { | |
| *op_mode = GSW_OP_MODE_LPM; | |
| } | |
| if(tmp_rf == LYNQ_AIR_PLANE_MODE_ON) | |
| { | |
| *op_mode = GSW_OP_MODE_OFFLINE; | |
| } | |
| if(tmp_rf == LYNQ_AIR_PLANE_MODE_OFF) | |
| { | |
| *op_mode = GSW_OP_MODE_ONLINE; | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief set radio opmode, as open and close airplane mode | |
| * @param [in] op_mode 1 is radio on, 0 is radio off | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_set_opmode(int op_mode) | |
| { | |
| mbtk_modem_info_t info; | |
| int rf_mode = -1; | |
| int ret = -1; | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| if(op_mode == GSW_OP_MODE_LPM) | |
| { | |
| rf_mode = LYNQ_AIR_CFUN_MODE_OFF; | |
| } | |
| if(op_mode == GSW_OP_MODE_ONLINE) | |
| { | |
| rf_mode = LYNQ_AIR_PLANE_MODE_OFF; | |
| } | |
| if(op_mode == GSW_OP_MODE_OFFLINE) | |
| { | |
| rf_mode = LYNQ_AIR_PLANE_MODE_ON; | |
| } | |
| if (rf_mode != LYNQ_AIR_PLANE_MODE_ON && rf_mode != LYNQ_AIR_PLANE_MODE_OFF && rf_mode != LYNQ_AIR_CFUN_MODE_OFF) | |
| { | |
| LOGE("Input mode is error!\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| info.fun = rf_mode; | |
| info.rst = 0; | |
| ret = mbtk_set_modem_fun(nw_info_handle, &info); | |
| if (ret != 0) | |
| { | |
| LOGE("gsw_set_opmode fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief get network mode preference of mdm search network scale | |
| * @param [out] mode_pref net_work pref mode: | |
| * enum prefer_mode | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_get_mode_preference(int *mode_pref) | |
| { | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| int ret = -1; | |
| mbtk_band_info_t band; | |
| memset(&band, 0, sizeof(mbtk_band_info_t)); | |
| ret = mbtk_current_band_get(nw_info_handle, &band); | |
| if(ret != 0) | |
| { | |
| LOGE("mbtk_current_band_get fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| *mode_pref = convert_gsw_net_config(band.net_pref); | |
| LOGE("band.net_pref = %d\n", *mode_pref); | |
| if(*mode_pref <= 0) | |
| { | |
| LOGE("no support mode\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief set network mode preference of mdm search network scale | |
| * @param [in] mode_pref net_work pref mode: | |
| * enum prefer_mode | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_set_mode_preference(int mode_pref) | |
| { | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| int ret = -1; | |
| mbtk_band_info_t band; | |
| memset(&band, 0, sizeof(mbtk_band_info_t)); | |
| band.net_pref = convert_mbtk_net_config(mode_pref); | |
| LOGE("band.net_pref = %d\n", band.net_pref); | |
| if(band.net_pref < 0) | |
| { | |
| LOGE("no support mode\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| ret = mbtk_current_band_set(nw_info_handle, &band); | |
| if(ret != 0) | |
| { | |
| LOGE("mbtk_current_band_set fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief get signal csq value | |
| * @param [out] csq_value csq of signalstrengh 0 - 31, 99 invalid | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_get_sig_info(int *csq_value) | |
| { | |
| int ret = -1; | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| mbtk_signal_info_t signal; | |
| memset(&signal, 0x0, sizeof(mbtk_signal_info_t)); | |
| ret = mbtk_net_signal_get(nw_info_handle, &signal); | |
| if(ret != 0) | |
| { | |
| LOGE("mbtk_net_signal_get fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| LOGD("signal.type=%d\n", signal.type); | |
| switch(signal.type) | |
| { | |
| case MBTK_RADIO_TECH_GSM: | |
| case MBTK_RADIO_TECH_GSM_COMPACT: | |
| case MBTK_RADIO_TECH_GSM_EGPRS: | |
| { | |
| LOGD("rssi = %d\n",signal.rssi); | |
| *csq_value = rssi_convert_to_dBm(signal.rssi); | |
| break; | |
| } | |
| case MBTK_RADIO_TECH_E_UTRAN: | |
| { | |
| LOGD("rsrp = %d\n",signal.rsrp); | |
| *csq_value = rsrp_convert_to_dBm(signal.rsrp); | |
| break; | |
| } | |
| case MBTK_RADIO_TECH_UTRAN: | |
| case MBTK_RADIO_TECH_UTRAN_HSDPA: | |
| case MBTK_RADIO_TECH_UTRAN_HSUPA: | |
| case MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA: | |
| case MBTK_RADIO_TECH_UTRAN_HSPA: | |
| { | |
| LOGD("rscp = %d\n",signal.rscp); | |
| *csq_value = rscp_convert_to_dBm(signal.rscp); | |
| break; | |
| } | |
| default: | |
| { | |
| LOGD("[%s] unknown reg type.[%d]\n", __func__, signal.type); | |
| return GSW_HAL_FAIL; | |
| } | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief set nework power mode, for tcam enter standby or exit standby | |
| * @param [in] mode TRUE(1) when enter standby, FALSE(0) after wake up | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_network_set_power_mode(char mode) | |
| { | |
| int ret = -1; | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| if(mode != 0 && mode != 1) | |
| { | |
| LOGE("Input mode is error!\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| if(mode == 1) | |
| { | |
| mode = 6; | |
| } | |
| ret = mbtk_wakeup_state_set(nw_info_handle, mode); | |
| if(ret != 0) | |
| { | |
| LOGE("mbtk_wakeup_state_set fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /** | |
| * @brief convert rsrp rscp rssi to csq value. | |
| * @param [in] netType signal radio tech 2 means 2G 3 mens 3G,4 is 4G,5 is 5G | |
| * @param [in] sigvalue input signal_strength for different nettype | |
| * rsrp for 4G/5G, rscp for 3G, rssi for 2G | |
| * @retval csq | |
| * @retval other: fail | |
| */ | |
| int gsw_sigInfo_to_csq(int netType, int sigValue) | |
| { | |
| switch(netType) | |
| { | |
| case 1: | |
| case 2: | |
| case 3: | |
| case 4: //GSM | |
| { | |
| return gsw_rssi_to_csq(sigValue); | |
| } | |
| case 5: //WCDMA | |
| { | |
| return gsw_rscp_to_csq(sigValue); | |
| } | |
| case 6: //LTE | |
| { | |
| return gsw_rsrp_to_csq(sigValue); | |
| } | |
| default: | |
| { | |
| LOGE("parameter error\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| } | |
| } | |
| /* | |
| * @brief get mobile operator name | |
| @param [out] nw_operator_name_infos get the long and short operator name info | |
| @retval 0: success | |
| @retval 0: other: fail | |
| */ | |
| int gsw_get_mobile_operator_name(gsw_mobile_operator_name *nw_operator_name_infos) | |
| { | |
| char OperatorFN[128]; | |
| char OperatorSH[128]; | |
| char temp[12] = {0}; | |
| mbtk_net_info_t net; | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| if(!mbtk_net_sel_mode_get(nw_info_handle, &net) && net.plmn > 0) | |
| { | |
| LOGE("Net : %d, %d, %d\n", net.net_sel_mode, net.net_type, net.plmn); | |
| int i = 0; | |
| while(i < ARRAY_SIZE(lynq_operator_mcc_mnc)) | |
| { | |
| if(lynq_operator_mcc_mnc[i].lynq_mcc_mnc == net.plmn) | |
| break; | |
| i++; | |
| } | |
| if(i == ARRAY_SIZE(lynq_operator_mcc_mnc)) // No found mcc&mnc | |
| { | |
| strcpy(OperatorFN, "UNKNOWN"); | |
| strcpy(OperatorSH, "UNKNOWN"); | |
| } | |
| else | |
| { | |
| strcpy(OperatorFN, lynq_operator_mcc_mnc[i].lynq_operator_l); | |
| strcpy(OperatorSH, lynq_operator_mcc_mnc[i].lynq_operator_s); | |
| memset(temp,0,12); | |
| memset(nw_operator_name_infos->mcc,0,4); | |
| sprintf(temp, "%d", (lynq_operator_mcc_mnc[i].lynq_mcc_mnc)/100); | |
| strncpy(nw_operator_name_infos->mcc, temp, strlen(temp)); | |
| memset(temp,0,12); | |
| memset(nw_operator_name_infos->mnc,0,4); | |
| sprintf(temp, "%d", (lynq_operator_mcc_mnc[i].lynq_mcc_mnc)%100); | |
| strncpy(nw_operator_name_infos->mnc, temp, strlen(temp)); | |
| } | |
| memset(nw_operator_name_infos->long_eons,0,128); | |
| memcpy(nw_operator_name_infos->long_eons,OperatorFN,strlen(OperatorFN)); | |
| memset(nw_operator_name_infos->short_eons,0,128); | |
| memcpy(nw_operator_name_infos->short_eons,OperatorSH,strlen(OperatorSH)); | |
| return GSW_HAL_SUCCESS; | |
| } | |
| else | |
| { | |
| LOGE("mbtk_net_sel_mode_get fail\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /* | |
| * @brief get current serving cell info | |
| * @param cell_info: [out] struct for current cell info | |
| * include earfcn mcc mnc pci psc tac lac etc. | |
| * @return int: 0 is success, other failed | |
| */ | |
| int gsw_get_cell_info(GSW_NW_CELL_INFO *cell_info) | |
| { | |
| int ret = -1; | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| LOGE("nw_sdk_deinit not init\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| list_node_t* cell_list = NULL; | |
| int neibor_count = 0; | |
| mbtk_cell_type_enum type; | |
| ret = mbtk_cell_get(nw_info_handle, &type, &cell_list); | |
| if(ret || cell_list == NULL) { | |
| LOGE("mbtk_cell_get failed : %d\n", ret); | |
| } else { | |
| list_first(cell_list); | |
| mbtk_cell_info_t* cell = (mbtk_cell_info_t*) list_next(cell_list); | |
| if(cell) { // Current server cell. | |
| switch(type) | |
| { | |
| case 0: | |
| { | |
| LOGD("GSM : lac=%d, ci=%d, arfcn=%d, bsic=%d\n", cell->value1, cell->value2, cell->value3, cell->value4); | |
| char gsm_temp[12] = {0}; | |
| cell_info->rat = GSW_NETWORK_RADIO_GSM; | |
| cell_info->mcc_valid = 1; | |
| snprintf(gsm_temp, sizeof(gsm_temp) ,"%d", cell->value5); | |
| strncpy(cell_info->mcc, gsm_temp, sizeof(cell_info->mcc)); | |
| memset(gsm_temp, 0, sizeof(gsm_temp)); | |
| cell_info->mnc_valid = 1; | |
| snprintf(gsm_temp, sizeof(gsm_temp) ,"%d", cell->value6); | |
| strncpy(cell_info->mnc, gsm_temp, sizeof(cell_info->mnc)); | |
| cell_info->cell_id_valid = 1; | |
| cell_info->cell_id = cell->value2; | |
| cell_info->lac_valid = 1; | |
| cell_info->lac = cell->value1; | |
| cell_info->arfcn_valid = 1; | |
| cell_info->arfcn = cell->value3; | |
| break; | |
| } | |
| case 1: | |
| { | |
| LOGD("UMTS : lac=%d, ci=%d, arfcn=%d\n", cell->value1, cell->value2, cell->value3); | |
| char wcdma_temp[12] = {0}; | |
| cell_info->rat = GSW_NETWORK_RADIO_UMTS; | |
| cell_info->mcc_valid = 1; | |
| snprintf(wcdma_temp, sizeof(wcdma_temp) ,"%d", cell->value4); | |
| strncpy(cell_info->mcc, wcdma_temp, sizeof(cell_info->mcc)); | |
| memset(wcdma_temp, 0, sizeof(wcdma_temp)); | |
| cell_info->mnc_valid = 1; | |
| snprintf(wcdma_temp, sizeof(wcdma_temp) ,"%d", cell->value5); | |
| strncpy(cell_info->mnc, wcdma_temp, sizeof(cell_info->mnc)); | |
| cell_info->lac_valid = 1; | |
| cell_info->lac = cell->value1; | |
| cell_info->cell_id_valid = 1; | |
| cell_info->cell_id = cell->value2; | |
| cell_info->uarfcn_valid = 1; | |
| cell_info->uarfcn = cell->value3; | |
| cell_info->psc_valid = 1; | |
| cell_info->psc = cell->value6; | |
| break; | |
| } | |
| case 2: | |
| { | |
| LOGE("LTE : tac=%d, PCI=%d, dlEuarfcn=%d, ulEuarfcn=%d, band=%d\n", cell->value1, cell->value2, cell->value3, cell->value4, cell->value5); | |
| char lte_temp[12] = {0}; | |
| cell_info->rat = GSW_NETWORK_RADIO_LTE; | |
| cell_info->mcc_valid = 1; | |
| snprintf(lte_temp, sizeof(lte_temp) ,"%X", cell->value6); | |
| strncpy(cell_info->mcc, lte_temp, sizeof(cell_info->mcc)); | |
| memset(lte_temp, 0, sizeof(lte_temp)); | |
| cell_info->mnc_valid = 1; | |
| snprintf(lte_temp, sizeof(lte_temp) ,"%X", cell->value7); | |
| strncpy(cell_info->mnc, lte_temp, sizeof(cell_info->mnc)); | |
| cell_info->tac_valid = 1; | |
| cell_info->tac = cell->value1; | |
| cell_info->pci_valid = 1; | |
| cell_info->pci = cell->value2; | |
| cell_info->earfcn_valid = 1; | |
| cell_info->earfcn = cell->value3; | |
| cell_info->bler_valid = 1; | |
| cell_info->bler = cell->value4; | |
| cell_info->band_valid = 1; | |
| cell_info->band = cell->value5; | |
| cell_info->rsrp_valid = 1; | |
| cell_info->rsrp = cell->value8; | |
| cell_info->rsrq_valid = 1; | |
| cell_info->rsrq = cell->value9; | |
| cell_info->cell_id_valid = 1; | |
| cell_info->cell_id = cell->value10; | |
| break; | |
| } | |
| default: | |
| break; | |
| } | |
| } | |
| while ((cell = (mbtk_cell_info_t*) list_next(cell_list)) && neibor_count < 5) | |
| { | |
| switch(type) | |
| { | |
| //GSM | |
| case 0: | |
| { | |
| } | |
| //WCDMA | |
| case 1: | |
| { | |
| LOGE("CELL : lac=%d, ci=%d, arfcn=%d\n", cell->value1, cell->value2, cell->value3); | |
| //cell_info->ext_info[neibor_count]->lac = cell->value1; | |
| cell_info->ext_info[neibor_count].cell_id_valid = 1; | |
| cell_info->ext_info[neibor_count].cell_id = cell->value2; | |
| cell_info->ext_info[neibor_count].arfcn_valid = 1; | |
| cell_info->ext_info[neibor_count].arfcn = cell->value3; | |
| cell_info->ext_info[neibor_count].rat = cell_info->rat = GSW_NETWORK_RADIO_UMTS; | |
| neibor_count++; | |
| } | |
| //LTE | |
| case 2: | |
| { | |
| LOGE("CELL : phyCellId=%d, euArfcn=%d, rsrp=%d, rsrq=%d\n", cell->value1, cell->value2, cell->value3, cell->value4); | |
| char lte_temp[12] = {0}; | |
| cell_info->ext_info[neibor_count].rat = GSW_NETWORK_RADIO_LTE; | |
| snprintf(lte_temp, sizeof(lte_temp) ,"%X", cell->value6); | |
| strncpy(cell_info->ext_info[neibor_count].mcc, lte_temp, sizeof(cell_info->mcc)); | |
| memset(lte_temp, 0, sizeof(lte_temp)); | |
| snprintf(lte_temp, sizeof(lte_temp) ,"%X", cell->value7); | |
| strncpy(cell_info->ext_info[neibor_count].mnc, lte_temp, sizeof(cell_info->mnc)); | |
| cell_info->ext_info[neibor_count].pci = cell->value1; | |
| cell_info->ext_info[neibor_count].pci_valid = 1; | |
| cell_info->ext_info[neibor_count].arfcn = cell->value2; | |
| cell_info->ext_info[neibor_count].arfcn_valid = 1; | |
| cell_info->ext_info[neibor_count].rsrp = cell->value3; | |
| cell_info->ext_info[neibor_count].rsrp_valid = 1; | |
| cell_info->ext_info[neibor_count].rsrq = cell->value4; | |
| cell_info->ext_info[neibor_count].rsrq_valid = 1; | |
| cell_info->ext_info[neibor_count].cell_id = cell->value5; | |
| cell_info->ext_info[neibor_count].cell_id_valid = 1; | |
| cell_info->ext_info[neibor_count].band = cell->value9; | |
| cell_info->ext_info[neibor_count].band_valid = 1; | |
| cell_info->ext_info[neibor_count].rssi = cell->value10; | |
| cell_info->ext_info[neibor_count].rssi_valid = 1; | |
| neibor_count++; | |
| } | |
| default: | |
| break; | |
| } | |
| } | |
| } | |
| list_free(cell_list); | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /* | |
| * @brief set modem status event callback | |
| @param [in] handle_ptr callback function address | |
| @retval 0: success | |
| @retval 0: other: fail | |
| */ | |
| int gsw_reg_set_modem_status_event_callback(GSW_NW_ModemStateHandlePtr handle_ptr) | |
| { | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| int ret = -1; | |
| if(handle_ptr == NULL) | |
| { | |
| LOGE("handle_ptr is NULL\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| modem_cb = handle_ptr; | |
| ret = mbtk_radio_state_change_cb_reg(nw_info_handle,gsw_modem_status_event_callback); | |
| if(ret != 0) | |
| { | |
| LOGE("mbtk_radio_state_change_cb_reg failed : %d\n", ret); | |
| return GSW_HAL_FAIL; | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /* | |
| * @brief get PLMNs from the FPLMN list | |
| * @param [inout] plmn_list: | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_get_forbidden_networks(gsw_nw_plmn_list_t *plmn_list) | |
| { | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| int ret = -1; | |
| char fplmn[256] = {0}; | |
| LOGE("mbtk_fplmn_get enter\n"); | |
| ret = mbtk_fplmn_get(nw_info_handle, fplmn); | |
| LOGE("mbtk_fplmn_get exit\n"); | |
| if(ret != 0) | |
| { | |
| LOGE("mbtk_fplmn_get failed : %d\n",ret); | |
| return GSW_HAL_FAIL; | |
| } | |
| update_fplmn_list(fplmn); | |
| for(int i = 0; i < fplmn_index; i++) | |
| { | |
| if(strcmp(fplmn_array[i],"FFFFFF") == 0) | |
| { | |
| continue; | |
| } | |
| extract_mcc_mnc(fplmn_array[i], plmn_list->plmn_list[plmn_list->plmn_list_len].mcc, plmn_list->plmn_list[plmn_list->plmn_list_len].mnc); | |
| LOGE("mcc = %s, mnc = %s\n", plmn_list->plmn_list[plmn_list->plmn_list_len].mcc, plmn_list->plmn_list[plmn_list->plmn_list_len].mnc); | |
| plmn_list->plmn_list_len++; | |
| } | |
| LOGE("fplmn = %s\n", fplmn); | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /* | |
| * @brief add PLMNs from the plmn_list to the FPLMN list | |
| * @param [in] plmn_list: | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_add_forbidden_networks(gsw_nw_plmn_list_t *plmn_list) | |
| { | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| if(plmn_list->plmn_list_len >= fplmn_max_length) | |
| { | |
| LOGE("can't save all the plmn\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| int i = 0; | |
| int index = -1; | |
| for(i = 0; i < plmn_list->plmn_list_len; i++) | |
| { | |
| index = check_index(plmn_list->plmn_list[i].mcc, plmn_list->plmn_list[i].mnc); | |
| if(index == -1) | |
| { | |
| LOGE("no this PLMN, add it\n"); | |
| if((fplmn_index + plmn_list->plmn_list_len) > fplmn_max_length) | |
| { | |
| LOGE("can't save all the plmn\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| else | |
| { | |
| memcpy(fplmn_array[fplmn_index], plmn_list->plmn_list[i].mcc, 3); | |
| memcpy(fplmn_array[fplmn_index] + 3, plmn_list->plmn_list[i].mnc, 2); | |
| fplmn_array[fplmn_index][5] = '\0'; | |
| LOGE("fplmn_array[%d] = %s\n", fplmn_index, fplmn_array[fplmn_index]); | |
| fplmn_index++; | |
| } | |
| } | |
| else | |
| { | |
| LOGE("already have this PLMN, don't add it\n"); | |
| } | |
| } | |
| char fplmn_str[256] = {0}; | |
| convert_plmn_to_fplmn_str(fplmn_str); | |
| LOGE("fplmn_str = %s\n", fplmn_str); | |
| int ret = mbtk_fplmn_set(nw_info_handle, fplmn_str); | |
| if(ret != 0) | |
| { | |
| LOGE("mbtk_fplmn_set failed : %d\n",ret); | |
| return GSW_HAL_FAIL; | |
| } | |
| LOGE("gsw_add_forbidden_networks exit\n"); | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /* | |
| * @brief Remove PLMNs from the plmn_list from the FPLMN list | |
| * @param [in] plmn_list: | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_remove_forbidden_networks(gsw_nw_plmn_list_t *plmn_list) | |
| { | |
| LOGE("gsw_remove_forbidden_networks enter\n"); | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| int i = 0; | |
| int index = -1; | |
| for(i = 0; i < plmn_list->plmn_list_len; i++) | |
| { | |
| index = check_index(plmn_list->plmn_list[i].mcc, plmn_list->plmn_list[i].mnc); | |
| if(index != -1) | |
| { | |
| remove_fplmn(index); | |
| } | |
| else | |
| { | |
| LOGE("no this PLMN, can't remove it\n"); | |
| } | |
| } | |
| for(i = 0; i < fplmn_index; i++) | |
| { | |
| LOGE("fplmn_array[%d] = %s\n", i, fplmn_array[i]); | |
| } | |
| char fplmn_str[256] = {0}; | |
| convert_plmn_to_fplmn_str(fplmn_str); | |
| LOGE("fplmn_str = %s\n", fplmn_str); | |
| int ret = mbtk_fplmn_set(nw_info_handle, fplmn_str); | |
| if(ret != 0) | |
| { | |
| LOGE("mbtk_fplmn_set failed : %d\n",ret); | |
| return GSW_HAL_FAIL; | |
| } | |
| LOGE("gsw_remove_forbidden_networks exit\n"); | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /* | |
| * @brief clear FPLMN list | |
| * @param | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_clear_forbidden_networks(void) | |
| { | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| char fplmn_str[FPLMN_STRING_LENGTH+1]; | |
| memset(fplmn_str, 'F', (6 * fplmn_max_length)); | |
| fplmn_str[(6 * fplmn_max_length)] = '\0'; | |
| LOGE("%s\n", fplmn_str); | |
| int ret = mbtk_fplmn_set(nw_info_handle, fplmn_str); | |
| if(ret != 0) | |
| { | |
| LOGE("mbtk_fplmn_set failed : %d\n",ret); | |
| return GSW_HAL_FAIL; | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /* | |
| * @brief get oos config | |
| * @param [in] oos_config | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_oos_config_get(GSW_NW_OOS_CONFIG_INFO_T *pt_info) | |
| { | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| if(pt_info == NULL) | |
| { | |
| LOGE("pt_info is null\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| int ret = -1; | |
| mbtk_oos_info oos_info; | |
| memset(&oos_info, 0x00, sizeof(mbtk_oos_info)); | |
| ret = mbtk_oos_get(nw_info_handle, &oos_info); | |
| if(ret != 0) | |
| { | |
| LOGE("mbtk_oos_get failed : %d\n",ret); | |
| return GSW_HAL_FAIL; | |
| } | |
| if(oos_info.mode == 0) | |
| { | |
| pt_info->t_min = 0; | |
| pt_info->t_step = 0; | |
| pt_info->t_max = 0; | |
| } | |
| else | |
| { | |
| pt_info->t_min = (int)oos_info.oosPhase[0]; | |
| pt_info->t_step = (int)oos_info.oosPhase[1]; | |
| pt_info->t_max = (int)oos_info.oosPhase[2]; | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |
| /* | |
| * @brief set oos config | |
| * @param [in] oos_config | |
| * @retval 0: success | |
| * @retval other: fail | |
| */ | |
| int gsw_oos_config_set(GSW_NW_OOS_CONFIG_INFO_T *pt_info) | |
| { | |
| if (nw_init_flag == 0 || nw_info_handle == NULL) | |
| { | |
| return GSW_HAL_FAIL; | |
| } | |
| if(pt_info == NULL) | |
| { | |
| LOGE("pt_info is null\n"); | |
| return GSW_HAL_FAIL; | |
| } | |
| int ret = -1; | |
| mbtk_oos_info oos_info; | |
| memset(&oos_info, 0x00, sizeof(mbtk_oos_info)); | |
| if (pt_info->t_min < 0 || pt_info->t_step < 0 || pt_info->t_max < 0) | |
| { | |
| LOGE("gsw_oos_config_set set time < 0 "); | |
| return GSW_HAL_FAIL; | |
| } | |
| else if ((pt_info->t_min > 0 && pt_info->t_min <= 255) && pt_info->t_step == 0 && pt_info->t_max == 0) | |
| { | |
| oos_info.mode = 1; | |
| oos_info.oosPhase[0] = pt_info->t_min; | |
| } | |
| else if ((pt_info->t_min > 0 && pt_info->t_min <= 255) && (pt_info->t_step > 0 && pt_info->t_step <= 255) && pt_info->t_max == 0) | |
| { | |
| oos_info.mode = 1; | |
| oos_info.oosPhase[0] = pt_info->t_min; | |
| oos_info.oosPhase[1] = pt_info->t_step; | |
| } | |
| else if ((pt_info->t_min > 0 && pt_info->t_min <= 255) && (pt_info->t_step > 0 && pt_info->t_step <= 255) && (pt_info->t_max > 0 && pt_info->t_max <= 255)) | |
| { | |
| oos_info.mode = 1; | |
| oos_info.oosPhase[0] = pt_info->t_min; | |
| oos_info.oosPhase[1] = pt_info->t_step; | |
| oos_info.oosPhase[2] = pt_info->t_max; | |
| } | |
| else if (pt_info->t_min == 0 && pt_info->t_step == 0 && pt_info->t_max == 0) | |
| { | |
| oos_info.mode = 0; | |
| } | |
| else | |
| { | |
| LOGE("gsw_oos_config_set set Format err"); | |
| return GSW_HAL_FAIL; | |
| } | |
| ret = mbtk_oos_set(nw_info_handle, &oos_info); | |
| if(ret != 0) | |
| { | |
| LOGE("mbtk_oos_set failed : %d\n",ret); | |
| return GSW_HAL_FAIL; | |
| } | |
| return GSW_HAL_SUCCESS; | |
| } | |