Gitiles
Code Review Sign In
192.168.1.100 / T108_Public / b8c12bd238d2d42e895dfa65eb5d825ccb84c4d6 / . / mbtk / libql_lib / src / ql_quec_nw.c
blob: 9582913e7690b247bc9895f42d332b9f49fb5614 [file] [log] [blame]
liubin281ac462023-07-19 14:22:54 +0800[diff] [blame]1#include "ql/ql_nw.h"
2#include "mbtk_type.h"
3#include "mbtk_info_api.h"
4
5extern mbtk_info_handle_t* ql_info_handle;
6extern int ql_info_handle_num;
7static bool inited = FALSE;
8
9typedef struct
10{
11 uint8 *operator_l;
12 uint8 *operator_s;
13 uint32 mcc_mnc;
14} operator_mcc_mnc_t;
15
16typedef struct
17{
18 QL_NW_EventHandlerFunc_t handlerPtr;
19 void* contextPtr;
20} ql_cust_cb_func;
21
22static ql_cust_cb_func ql_func_cb_handle;
23
24static int roaming_pref = 1; // Open roaming for default.
25
26static operator_mcc_mnc_t operator_mcc_mnc [] =
27{
28 {"China Mobile","CMCC",46000},
29 {"China Unicom","CU",46001},
30 {"China Mobile","CMCC",46002},
31 {"China Telecom","CT",46003},
32 {"China Mobile","CMCC",46004},
33 {"China Telecom","CT",46005},
34 {"China Unicom","CU",46006},
35 {"China Mobile","CMCC",46007},
36 {"China Mobile","CMCC",46008},
37 {"China Unicom","CU",46009},
38 {"China Telecom","CT",46011}
39};
40
41typedef enum {
42 RADIO_TECH_3GPP = 1, /* 3GPP Technologies - GSM, WCDMA */
43 RADIO_TECH_3GPP2 = 2 /* 3GPP2 Technologies - CDMA */
44} RIL_RadioTechnologyFamily;
45
46void ql_nw_state_change_cb(const void* data, int data_len)
47{
48 ///mbtk_net_info_t *reg = (mbtk_net_info_t *)data;
49 uint8 *net_data = NULL;
50
51 net_data = (uint8*)data;
52 /*
53 uint8 data[3];
54 data[0] = (uint8)MBTK_NET_CS_STATE;
55
56 net_data[0] = *(uint8 *)(data); //MBTK_NET_PS_STATE
57 net_data[1] = *(uint8 *)(data + sizeof(uint8)); //mbtk_net_reg_state_enum state Reg State
58 net_data[2] = *(uint8 *)(data + sizeof(uint8) + sizeof(uint8)); //act
59 */
60 if(roaming_pref == 0)
61 {
62 mbtk_modem_info_t info;
63 if(*net_data == 5)
64 {
65 info.fun=4;
66 //ql_netw_status_cb(5);
67 }
68 else
69 info.fun=1;
70 info.rst=0;
71 mbtk_set_modem_fun(ql_info_handle, &info);
72 }
73
74 if(ql_func_cb_handle.handlerPtr != NULL)
75 {
76 ql_func_cb_handle.handlerPtr(QL_NW_IND_DATA_REG_EVENT_FLAG,&(net_data[2]), sizeof(&(net_data[2])), NULL);
77 }
78}
79
80QL_NW_ERROR_CODE ql_nw_init()
81{
82 if(!inited && ql_info_handle == NULL)
83 {
84 ql_info_handle = mbtk_info_handle_get();
85 if(ql_info_handle)
86 {
87 ql_info_handle_num++;
88 inited = TRUE;
89 return QL_NW_SUCCESS;
90 } else {
91 LOGE("mbtk_info_handle_get() fail.");
92 return QL_NW_GENERIC_FAILURE;
93 }
94 } else {
95 if(!inited) {
96 ql_info_handle_num++;
97 inited = TRUE;
98 }
99 return QL_NW_SUCCESS;
100 }
101}
102
103QL_NW_ERROR_CODE ql_nw_release()
104{
105 if(ql_info_handle)
106 {
107 LOGD("ql_info_handle_num = %d", ql_info_handle_num);
108 if(ql_info_handle_num == 1) { // 最后一个引用，可释放。
109 int ret = mbtk_info_handle_free(&ql_info_handle);
110 if(ret) {
111 LOGE("mbtk_info_handle_free() fail.");
112 return QL_NW_GENERIC_FAILURE;
113 }
114 else
115 {
116 ql_info_handle_num = 0;
117 ql_info_handle = NULL;
118 return QL_NW_SUCCESS;
119 }
120 } else {
121 ql_info_handle_num--;
122 return QL_NW_SUCCESS;
123 }
124 }
125 else
126 {
127 LOGE("NW handle not inited.");
128 return QL_NW_GENERIC_FAILURE;
129 }
130}
131
132static uint8 net_pre_change(bool mbtk_2_ql,int net_mode)
133{
134 uint8 mbtk_net_pre = 0xFF;
135
136 /*
137 QL_NW_PREF_NET_TYPE_GSM_WCDMA = 0, //4
138 QL_NW_PREF_NET_TYPE_GSM_ONLY = 1, //0
139 QL_NW_PREF_NET_TYPE_WCDMA = 2, //1
140 QL_NW_PREF_NET_TYPE_GSM_WCDMA_AUTO = 3, //2
141 QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA = 9, //12
142 QL_NW_PREF_NET_TYPE_LTE_ONLY = 11, //5
143 QL_NW_PREF_NET_TYPE_LTE_WCDMA = 12, //9
144 QL_NW_PREF_NET_TYPE_LTE_GSM_GSM_PREF = 13, //7
145 QL_NW_PREF_NET_TYPE_LTE_GSM_LTE_PREF = 14, //8
146 QL_NW_PREF_NET_TYPE_LTE_GSM = 15, //6
147 QL_NW_PREF_NET_TYPE_LTE_WCDMA_WCDMA_PREF = 16, //10
148 QL_NW_PREF_NET_TYPE_LTE_WCDMA_LTE_PREF = 17, //11
149 QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_GSM_PREF = 19, //13
150 QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_WCDMA_PREF = 20, //14
151 QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_LTE_PREF = 21, //15
152 */
153 /*
154 0 : GSM only
155 1 : UMTS only
156 2 : GSM/UMTS(auto)
157 3 : GSM/UMTS(GSM preferred)
158 4 : GSM/UMTS(UMTS preferred)
159 5 : LTE only
160 6 : GSM/LTE(auto)
161 7 : GSM/LTE(GSM preferred)
162 8 : GSM/LTE(LTE preferred)
163 9 : UMTS/LTE(auto)
164 10 : UMTS/LTE(UMTS preferred)
165 11 : UMTS/LTE(LTE preferred)
166 12 : GSM/UMTS/LTE(auto)
167 13 : GSM/UMTS/LTE(GSM preferred)
168 14 : GSM/UMTS/LTE(UMTS preferred)
169 15 : GSM/UMTS/LTE(LTE preferred)
170 */
171
172 if(mbtk_2_ql) {
173 switch(net_mode)
174 {
175 case MBTK_NET_PREF_GSM_UMTS_UMTS_PREF:
176 mbtk_net_pre = QL_NW_PREF_NET_TYPE_GSM_WCDMA;
177 break;
178 case MBTK_NET_PREF_GSM_ONLY:
179 mbtk_net_pre = QL_NW_PREF_NET_TYPE_GSM_ONLY;
180 break;
181 case MBTK_NET_PREF_UMTS_ONLY:
182 mbtk_net_pre = QL_NW_PREF_NET_TYPE_WCDMA;
183 break;
184 case MBTK_NET_PREF_GSM_UMTS_AUTO:
185 mbtk_net_pre = QL_NW_PREF_NET_TYPE_GSM_WCDMA_AUTO;
186 break;
187 case MBTK_NET_PREF_GSM_UMTS_LTE_AUTO:
188 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA;
189 break;
190 case MBTK_NET_PREF_LTE_ONLY:
191 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_ONLY;
192 break;
193 case MBTK_NET_PREF_UMTS_LTE_AUTO:
194 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_WCDMA;
195 break;
196 case MBTK_NET_PREF_GSM_LTE_GSM_PREF:
197 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM_GSM_PREF;
198 break;
199 case MBTK_NET_PREF_GSM_LTE_LTE_PREF:
200 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM_LTE_PREF;
201 break;
202 case MBTK_NET_PREF_GSM_LTE_AUTO:
203 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM;
204 break;
205 case MBTK_NET_PREF_UMTS_LTE_UMTS_PREF:
206 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_WCDMA_WCDMA_PREF;
207 break;
208 case MBTK_NET_PREF_UMTS_LTE_LTE_PREF:
209 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_WCDMA_LTE_PREF;
210 break;
211 case MBTK_NET_PREF_GSM_UMTS_LTE_GSM_PREF:
212 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_GSM_PREF;
213 break;
214 case MBTK_NET_PREF_GSM_UMTS_LTE_UMTS_PREF:
215 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_WCDMA_PREF;
216 break;
217 case MBTK_NET_PREF_GSM_UMTS_LTE_LTE_PREF:
218 mbtk_net_pre = QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_LTE_PREF;
219 break;
220 default:
221 mbtk_net_pre = 0xFF;
222 break;
223 }
224 } else {
225 switch(net_mode)
226 {
227 case QL_NW_PREF_NET_TYPE_GSM_WCDMA:
228 mbtk_net_pre = MBTK_NET_PREF_GSM_UMTS_UMTS_PREF;
229 break;
230 case QL_NW_PREF_NET_TYPE_GSM_ONLY:
231 mbtk_net_pre = MBTK_NET_PREF_GSM_ONLY;
232 break;
233 case QL_NW_PREF_NET_TYPE_WCDMA:
234 mbtk_net_pre = MBTK_NET_PREF_UMTS_ONLY;
235 break;
236 case QL_NW_PREF_NET_TYPE_GSM_WCDMA_AUTO:
237 mbtk_net_pre = MBTK_NET_PREF_GSM_UMTS_AUTO;
238 break;
239 case QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA:
240 mbtk_net_pre = MBTK_NET_PREF_GSM_UMTS_LTE_AUTO;
241 break;
242 case QL_NW_PREF_NET_TYPE_LTE_ONLY:
243 mbtk_net_pre = MBTK_NET_PREF_LTE_ONLY;
244 break;
245 case QL_NW_PREF_NET_TYPE_LTE_WCDMA:
246 mbtk_net_pre = MBTK_NET_PREF_UMTS_LTE_AUTO;
247 break;
248 case QL_NW_PREF_NET_TYPE_LTE_GSM_GSM_PREF:
249 mbtk_net_pre = MBTK_NET_PREF_GSM_LTE_GSM_PREF;
250 break;
251 case QL_NW_PREF_NET_TYPE_LTE_GSM_LTE_PREF:
252 mbtk_net_pre = MBTK_NET_PREF_GSM_LTE_LTE_PREF;
253 break;
254 case QL_NW_PREF_NET_TYPE_LTE_GSM:
255 mbtk_net_pre = MBTK_NET_PREF_GSM_LTE_AUTO;
256 break;
257 case QL_NW_PREF_NET_TYPE_LTE_WCDMA_WCDMA_PREF:
258 mbtk_net_pre = MBTK_NET_PREF_UMTS_LTE_UMTS_PREF;
259 break;
260 case QL_NW_PREF_NET_TYPE_LTE_WCDMA_LTE_PREF:
261 mbtk_net_pre = MBTK_NET_PREF_UMTS_LTE_LTE_PREF;
262 break;
263 case QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_GSM_PREF:
264 mbtk_net_pre = MBTK_NET_PREF_GSM_UMTS_LTE_GSM_PREF;
265 break;
266 case QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_WCDMA_PREF:
267 mbtk_net_pre = MBTK_NET_PREF_GSM_UMTS_LTE_UMTS_PREF;
268 break;
269 case QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_LTE_PREF:
270 mbtk_net_pre = MBTK_NET_PREF_GSM_UMTS_LTE_LTE_PREF;
271 break;
272 default:
273 mbtk_net_pre = 0xFF;
274 break;
275 }
276 }
277 return mbtk_net_pre;
278}
279
280QL_NW_ERROR_CODE ql_nw_set_config(QL_NW_CONFIG_INFO_T *pt_info)
281{
282 if(ql_info_handle == NULL || pt_info == NULL)
283 {
284 LOGE("ARG error.");
285 return QL_NW_GENERIC_FAILURE;
286 }
287
288 if(pt_info->preferred_nw_mode < QL_NW_PREF_NET_TYPE_GSM_WCDMA || pt_info->preferred_nw_mode > QL_NW_PREF_NET_TYPE_LTE_GSM_WCDMA_LTE_PREF)
289 {
290 LOGE("Unknown preferred_nw_mode(%d) error.", pt_info->preferred_nw_mode);
291 return QL_NW_GENERIC_FAILURE;
292 }
293
294 roaming_pref = pt_info->roaming_pref;
295
296 mbtk_band_info_t band;
297 memset(&band, 0, sizeof(mbtk_band_info_t));
298 band.net_pref = net_pre_change(FALSE, pt_info->preferred_nw_mode);
299 if(band.net_pref == 0xFF)
300 {
301 LOGE("net_pre_change() fail.");
302 return QL_NW_GENERIC_FAILURE;
303 }
304 if(mbtk_current_band_set(ql_info_handle, &band)) {
305 return QL_NW_GENERIC_FAILURE;
306 } else {
307 return QL_NW_SUCCESS;
308 }
309}
310
311QL_NW_ERROR_CODE ql_nw_get_config(QL_NW_CONFIG_INFO_T *pt_info)
312{
313 if(ql_info_handle == NULL || pt_info == NULL)
314 {
315 LOGE("ARG error.");
316 return QL_NW_GENERIC_FAILURE;
317 }
318 pt_info->roaming_pref = roaming_pref;
319 mbtk_band_info_t band;
320 if(mbtk_current_band_get(ql_info_handle, &band)) {
321 return QL_NW_GENERIC_FAILURE;
322 } else {
323 pt_info->preferred_nw_mode = (QL_NW_PREFERRED_NETWORK_TYPE)net_pre_change(TRUE, band.net_pref);
324 return QL_NW_SUCCESS;
325 }
326}
327
328QL_NW_ERROR_CODE ql_nw_get_nitz_time_info(QL_NW_NITZ_TIME_INFO_T *pt_info)
329{
330 if(ql_info_handle == NULL || pt_info == NULL)
331 {
332 LOGE("ARG error.");
333 return QL_NW_GENERIC_FAILURE;
334 }
335 memset(pt_info, 0x0, sizeof(QL_NW_NITZ_TIME_INFO_T));
336 char time_str[100]={0};
337 ///printf("mbtk_net_time_get begin\n");
338 int err = mbtk_net_time_get(ql_info_handle, time_str);
339 if(err) {
340 LOGE("mbtk_net_time_get() fail.");
341 return QL_NW_GENERIC_FAILURE;
342 } else {
343 memset(pt_info->nitz_time,0,32);
344 memcpy(pt_info->nitz_time,time_str,strlen(time_str));
345 if(mbtk_get_abs_time(time_str, &(pt_info->abs_time))) {
346 LOGE("mbtk_get_abs_time() fail.");
347 return QL_NW_GENERIC_FAILURE;
348 }
349
350 pt_info->leap_sec = 0;
351
352 return QL_NW_SUCCESS;
353 }
354}
355
356//--------------------------------------------------------------------------------------
357QL_NW_ERROR_CODE ql_nw_event_register(unsigned int bitmask)
358{
359 /*
360 NW_IND_VOICE_REG_EVENT_IND_FLAG 语音拨号注册事件
361 NW_IND_DATA_REG_EVENT_IND_FLAG (1 << 1) 数据拨号注册事件
362 NW_IND_SIGNAL_STRENGTH_EVENT_IND_FLAG (1 << 2) 信号强度事件
363 NW_IND_NITZ_TIME_UPDATE_EVENT_IND_FLAG (1 << 3) 网络时间更新事件
364 */
365 if(bitmask == QL_NW_IND_VOICE_REG_EVENT_FLAG)
366 {}
367 if(bitmask == QL_NW_IND_DATA_REG_EVENT_FLAG)
368 {}
369 if(bitmask == QL_NW_IND_SIGNAL_STRENGTH_EVENT_FLAG)
370 {}
371 if(bitmask == QL_NW_IND_NITZ_TIME_UPDATE_EVENT_FLAG)
372 {}
373 return QL_NW_SUCCESS;
374}
375//--------------------------------------------------------------------------------------
376
377QL_NW_ERROR_CODE ql_nw_get_operator_name(QL_NW_OPERATOR_INFO_T *pt_info)
378{
379 if(ql_info_handle == NULL || pt_info == NULL)
380 {
381 LOGE("ARG error.");
382 return QL_NW_GENERIC_FAILURE;
383 }
384 char OperatorFN[128];
385 char OperatorSH[128];
386 char MccMnc[128];
387 mbtk_net_info_t net;
388 if(!mbtk_net_sel_mode_get(ql_info_handle, &net) && net.plmn > 0)
389 {
390 // printf("Net : %d, %d, %d\n", net.net_sel_mode, net.net_type, net.plmn);
391 int i = 0;
392 while(i < ARRAY_SIZE(operator_mcc_mnc))
393 {
394 if(operator_mcc_mnc[i].mcc_mnc == net.plmn)
395 break;
396 i++;
397 }
398
399 if(i == ARRAY_SIZE(operator_mcc_mnc)) // No found mcc&mnc
400 {
401 strcpy(OperatorFN, "UNKNOWN");
402 strcpy(OperatorSH, "UNKNOWN");
403 sprintf(MccMnc, "%d", net.plmn);
404 }
405 else
406 {
407 strcpy(OperatorFN, operator_mcc_mnc[i].operator_l);
408 strcpy(OperatorSH, operator_mcc_mnc[i].operator_s);
409 sprintf(MccMnc, "%d", operator_mcc_mnc[i].mcc_mnc);
410 }
411 memset(pt_info->long_eons,0,128);
412 memcpy(pt_info->long_eons,operator_mcc_mnc[i].operator_l,strlen(operator_mcc_mnc[i].operator_l));
413 memset(pt_info->short_eons,0,128);
414 memcpy(pt_info->short_eons,operator_mcc_mnc[i].operator_s,strlen(operator_mcc_mnc[i].operator_s));
415 memset(pt_info->mcc,0,4);
416 memset(pt_info->mnc,0,4);
417 sprintf(pt_info->mcc, "%d", (operator_mcc_mnc[i].mcc_mnc)/100);
418 sprintf(pt_info->mnc, "%d", (operator_mcc_mnc[i].mcc_mnc)%100);
419 //pt_info->act;
420 return QL_NW_SUCCESS;
421 }
422
423 return QL_NW_GENERIC_FAILURE;
424}
425
426QL_NW_ERROR_CODE ql_nw_perform_scan(QL_NW_SCAN_RESULT_LIST_INFO_T *pt_info)
427{
428 if(ql_info_handle == NULL || pt_info == NULL)
429 {
430 LOGE("ARG error.");
431 return -1;
432 }
433 list_node_t* net_list = NULL;
434 int ret = mbtk_available_net_get(ql_info_handle, &net_list);
435 if(ret != 0)
436 {
437 LOGE("mbtk_available_net_get fail.");
438 return QL_NW_GENERIC_FAILURE;
439 }
440 else
441 {
442 memset(pt_info, 0x0, sizeof(QL_NW_SCAN_RESULT_LIST_INFO_T));
443 mbtk_net_info_t* net = NULL;
444 list_first(net_list);
445 int i=0;
446 while ((net = (mbtk_net_info_t*) list_next(net_list)))
447 {
448 //printf("Net : %d, %d, %d, %d\n", net->net_sel_mode, net->net_type, net->net_state, net->plmn);
449 if(net->net_state == 8)
450 pt_info->entry[i].status = QL_NW_ACCESS_TECH_E_UTRAN_CA;
451 else if(net->net_state == 0xff)
452 pt_info->entry[i].status = QL_NW_ACCESS_TECH_NONE;
453 else
454 pt_info->entry[i].status = net->net_state;
455
456 int j = 0;
457 while(j < ARRAY_SIZE(operator_mcc_mnc))
458 {
459 if(operator_mcc_mnc[j].mcc_mnc == net->plmn)
460 break;
461 j++;
462 }
463 if(j == ARRAY_SIZE(operator_mcc_mnc)) // No found mcc&mnc
464 {
465 strcpy(pt_info->entry[i].operator_name.long_eons, "UNKNOWN");
466 strcpy(pt_info->entry[i].operator_name.short_eons, "UNKNOWN");
467 sprintf(pt_info->entry[i].operator_name.mcc, "%d", (net->plmn)/100);
468 sprintf(pt_info->entry[i].operator_name.mnc, "%d", (net->plmn)%100);
469 }
470 else
471 {
472 strcpy(pt_info->entry[i].operator_name.long_eons, operator_mcc_mnc[j].operator_l);
473 strcpy(pt_info->entry[i].operator_name.short_eons, operator_mcc_mnc[j].operator_s);
474 sprintf(pt_info->entry[i].operator_name.mcc, "%d", (net->plmn)/100);
475 sprintf(pt_info->entry[i].operator_name.mnc, "%d", (net->plmn)%100);
476 }
477 pt_info->entry[i].operator_name ;
478 pt_info->entry[i].act = net->net_type;
479 i++;
480 if(i > 40)
481 break;
482 }
483 pt_info->entry_len = i;
484 list_free(net_list);
485 return QL_NW_SUCCESS;
486 }
487}
488
489#if 0
490static int ql_query_registration_state(const char *type, int* regState,int *imsRegState,int * LAC, int *CID,int *netType,int * radioTechFam,int *netRejected)
491{
492 if(ql_info_handle == NULL || str_empty(type) || regState == NULL || imsRegState == NULL
493 || LAC == NULL || CID == NULL || netType == NULL || radioTechFam == NULL || netRejected == NULL)
494 {
495 return -1;
496 }
497 mbtk_net_reg_info_t reg;
498 int err = mbtk_net_reg_get(ql_info_handle, &reg);
499 if(err) {
500 *netRejected = err;
501 return -1;
502 } else {
503 //printf("REG : %d, %d, %d, %04x, %08o\n", reg.state, reg.type, reg.ims_reg, reg.lac, reg.ci);
504 // Voice/Data/IMS
505 if(strcmp("VOICE", type) == 0) {
506 *regState = reg.call_state;
507 } else if(strcmp("DATA", type) == 0) {
508 *regState = reg.data_state;
509 } else if(strcmp("IMS", type) == 0) {
510 *imsRegState = reg.ims_state;
511 } else {
512 return -1;
513 }
514
515 if(reg.call_state != MBTK_NET_REG_STATE_NON || reg.data_state != MBTK_NET_REG_STATE_NON || reg.ims_state != MBTK_NET_REG_STATE_NON) {
516 sprintf(LAC, "%04x", reg.lac);
517 sprintf(CID, "%08o", reg.ci);
518 *netType = reg.type;
519 *radioTechFam = RADIO_TECH_3GPP;
520 }
521 return 0;
522 }
523
524}
525#endif
526
527QL_NW_ERROR_CODE ql_nw_get_reg_status(QL_NW_REG_STATUS_INFO_T *pt_info)
528{
529 if(ql_info_handle == NULL || pt_info == NULL)
530 {
531 LOGE("ARG error.");
532 return QL_NW_GENERIC_FAILURE;
533 }
534 /*VOICE/DATA/IMS*/
535 mbtk_net_reg_info_t reg;
536 int err = mbtk_net_reg_get(ql_info_handle, &reg);
537 if(err) {
538 LOGE("mbtk_net_reg_get fail.");
539 return QL_NW_GENERIC_FAILURE;
540 } else {
541 memset(pt_info, 0x0, sizeof(QL_NW_REG_STATUS_INFO_T));
542 pt_info->data_reg.state = (QL_NW_REG_STATE)reg.data_state;
543 pt_info->data_reg.lac = reg.lac;
544 pt_info->data_reg.cid = reg.ci;
545 pt_info->voice_reg.state = (QL_NW_REG_STATE)reg.call_state;
546 pt_info->voice_reg.lac = reg.lac;
547 pt_info->voice_reg.cid = reg.ci;
548 switch(reg.type)
549 {
550 case MBTK_RADIO_TECH_GSM:
551 case MBTK_RADIO_TECH_GSM_COMPACT:
552 case MBTK_RADIO_TECH_GSM_EGPRS:
553 case MBTK_RADIO_TECH_UTRAN_HSPA:
554 {
555 pt_info->data_reg.rat = QL_NW_RADIO_TECH_GPRS;
556 pt_info->voice_reg.rat = QL_NW_RADIO_TECH_GSM;
557 break;
558 }
559 case MBTK_RADIO_TECH_UTRAN:
560 case MBTK_RADIO_TECH_UTRAN_HSDPA:
561 case MBTK_RADIO_TECH_UTRAN_HSUPA:
562 case MBTK_RADIO_TECH_UTRAN_HSDPA_HSUPA:
563 {
564 pt_info->data_reg.rat = QL_NW_RADIO_TECH_UMTS;
565 pt_info->voice_reg.rat = QL_NW_RADIO_TECH_UMTS;
566 break;
567 }
568 case MBTK_RADIO_TECH_E_UTRAN:
569 {
570 pt_info->data_reg.rat = QL_NW_RADIO_TECH_LTE;
571 pt_info->voice_reg.rat = QL_NW_RADIO_TECH_LTE;
572 break;
573 }
574 default:
575 {
576 pt_info->data_reg.rat = QL_NW_RADIO_TECH_UNKNOWN;
577 pt_info->voice_reg.rat = QL_NW_RADIO_TECH_UNKNOWN;
578 break;
579 }
580 }
581 }
582
583 return 0;
584
585#if 0
586 int ret = ql_query_registration_state("VOICE", &(pt_info->voice_reg.state), &imsRegState, &(pt_info->voice_reg.lac), &(pt_info->voice_reg.cid), &netType, &(pt_info->voice_reg.rejectCause), &netRejected);
587 if(ret != 0)
588 err = QL_NW_GENERIC_FAILURE;
589 else
590 err = QL_NW_SUCCESS;
591 ret = ql_query_registration_state("DATA", &(pt_info->data_reg.state), &imsRegState, &(pt_info->data_reg.lac), &(pt_info->data_reg.cid), &netType, &(pt_info->data_reg.rejectCause), &netRejected);
592 if(ret != 0)
593 err = QL_NW_GENERIC_FAILURE;
594 else
595 err = QL_NW_SUCCESS;
596
597 if(err == QL_NW_SUCCESS)
598 {
599 if(netType < 0 || netType > 8)
600 pt_info->data_reg.rat = QL_NW_ACCESS_TECH_NONE;
601 else
602 pt_info->data_reg.rat = netType;
603 }
604 return err;
605#endif
606}
607
608QL_NW_ERROR_CODE ql_nw_set_selection(QL_NW_SELECTION_INFO_T *pt_info)
609{
610 if(ql_info_handle == NULL || pt_info == NULL)
611 {
612 LOGE("ARG error.");
613 return QL_NW_GENERIC_FAILURE;
614 }
615
616 mbtk_net_info_t net;
617 net.net_type = 0xFF;
618 char mccmnc[10];
619 if(pt_info->nw_selection_mode == 0)
620 {
621 net.net_sel_mode = 0;
622 net.plmn = 0;
623 }
624 else if(pt_info->nw_selection_mode == 1 && !str_empty(pt_info->mnc) && !str_empty(pt_info->mcc))
625 {
626 net.net_sel_mode = 1;
627 memset(mccmnc, 0, 10);
628 //memcpy(mccmnc, pt_info->mcc, 3);
629 //memcpy(mccmnc + 3, pt_info->mnc, 3);
630 sprintf(mccmnc,"%s%s",pt_info->mcc,pt_info->mnc);
631 net.plmn = (uint32)atoi(mccmnc);
632 if(pt_info->act < QL_NW_ACCESS_TECH_GSM || pt_info->act > QL_NW_ACCESS_TECH_UTRAN_HSPAP)
633 net.net_type = 0xff;
634 else
635 net.net_type = pt_info->act;
636 }
637 else
638 {
639 LOGE("ARG error.");
640 return QL_NW_GENERIC_FAILURE;
641 }
642 //printf("mccmnc = %s\n",mccmnc);
643 //printf("net.plmn = %d\n",net.plmn);
644 int ret = mbtk_net_sel_mode_set(ql_info_handle, &net);
645 if(ret == 0)
646 {
647 return QL_NW_SUCCESS;
648 }
649 else
650 {
651 printf("mbtk_net_sel_mode_set error: %d\n",ret );
652 return QL_NW_GENERIC_FAILURE;
653 }
654}
655
656QL_NW_ERROR_CODE ql_nw_get_selection(QL_NW_SELECTION_INFO_T *pt_info)
657{
658 if(ql_info_handle == NULL || pt_info == NULL)
659 {
660 LOGE("ARG error.");
661 return QL_NW_GENERIC_FAILURE;
662 }
663 char OperatorFN[128];
664 char OperatorSH[128];
665 char MccMnc[128];
666 mbtk_net_info_t net;
667 if(!mbtk_net_sel_mode_get(ql_info_handle, &net) && net.plmn > 0)
668 {
669 memset(pt_info, 0x0, sizeof(QL_NW_SELECTION_INFO_T));
670 // printf("Net : %d, %d, %d\n", net.net_sel_mode, net.net_type, net.plmn);
671 int i = 0;
672 while(i < ARRAY_SIZE(operator_mcc_mnc))
673 {
674 if(operator_mcc_mnc[i].mcc_mnc == net.plmn)
675 break;
676 i++;
677 }
678 if(i == ARRAY_SIZE(operator_mcc_mnc)) // No found mcc&mnc
679 {
680 strcpy(OperatorFN, "UNKNOWN");
681 strcpy(OperatorSH, "UNKNOWN");
682 sprintf(MccMnc, "%d", net.plmn);
683 }
684 else
685 {
686 strcpy(OperatorFN, operator_mcc_mnc[i].operator_l);
687 strcpy(OperatorSH, operator_mcc_mnc[i].operator_s);
688 sprintf(MccMnc, "%d", operator_mcc_mnc[i].mcc_mnc);
689
690 sprintf(pt_info->mcc,"%d",operator_mcc_mnc[i].mcc_mnc/100);
691 sprintf(pt_info->mnc,"%d",operator_mcc_mnc[i].mcc_mnc%100);
692
693 }
694 pt_info->nw_selection_mode = net.net_sel_mode;
695
696 pt_info->act = net.net_type;
697 return QL_NW_SUCCESS;
698 }
699
700 return QL_NW_GENERIC_FAILURE;
701
702}
703
704QL_NW_ERROR_CODE ql_nw_get_signal_strength(QL_NW_SIGNAL_STRENGTH_INFO_T *pt_info)
705{
706 if(ql_info_handle == NULL || pt_info == NULL)
707 {
708 LOGE("ARG error.");
709 return QL_NW_GENERIC_FAILURE;
710 }
711
712 int ret;
713 mbtk_signal_info_t signal;
714 ret = mbtk_net_signal_get(ql_info_handle, &signal);
715 if(ret != 0) {
716 LOGE("mbtk_net_signal_get fail.");
717 return QL_NW_GENERIC_FAILURE;
718 }
719 else
720 {
721 if(signal.type == MBTK_RADIO_TECH_GSM) //GSM
722 {
723 pt_info->GW_SignalStrength.bitErrorRate = signal.ber;
724 pt_info->GW_SignalStrength.ecio = signal.ecno;
725 pt_info->GW_SignalStrength.rscp = signal.rscp;
726 pt_info->GW_SignalStrength.rssi = signal.rssi;
727 }
728 else if(signal.type == MBTK_RADIO_TECH_E_UTRAN) //LTE
729 {
730 //pt_info->LTE_SignalStrength.cqi = signal.;
731 pt_info->LTE_SignalStrength.rsrp = signal.rsrp;
732 pt_info->LTE_SignalStrength.rsrq = signal.rsrq;
733 pt_info->LTE_SignalStrength.rssnr = signal.ecno;
734 pt_info->LTE_SignalStrength.rssi = signal.rssi;
735 }
736 else
737 {
738 return QL_NW_GENERIC_FAILURE;
739 }
740 return QL_NW_SUCCESS;
741 }
742}
743
744QL_NW_ERROR_CODE ql_nw_get_cell_info(QL_NW_CELL_INFO_T *pt_info)
745{
746 list_node_t* cell_list = NULL;
747 mbtk_cell_type_enum type;
748 if(ql_info_handle == NULL || pt_info == NULL)
749 {
750 LOGE("ARG error.");
751 return QL_NW_GENERIC_FAILURE;
752 }
753
754 memset(pt_info, 0, sizeof(QL_NW_CELL_INFO_T));
755 int err = mbtk_cell_get(ql_info_handle, &type, &cell_list);
756 if(err || cell_list == NULL) {
757 LOGE("mbtk_cell_get fail.");
758 return QL_NW_GENERIC_FAILURE;
759 } else {
760 list_first(cell_list);
761 mbtk_cell_info_t* cell = (mbtk_cell_info_t*) list_next(cell_list);
762 if(cell) { // Current server cell.
763 switch(type)
764 {
765 case MBTK_CELL_TYPE_GSM:
766 {
767 LOGD("GSM : lac=%d, ci=%d, arfcn=%d, bsic=%d", cell->value1, cell->value2, cell->value3, cell->value4);
768 pt_info->gsm_info[0].lac = cell->value1;
769 pt_info->gsm_info[0].cid = cell->value2;
770 pt_info->gsm_info[0].arfcn = cell->value3;
771 pt_info->gsm_info[0].bsic = cell->value4;
772 pt_info->gsm_info[0].mcc = cell->value5;
773 pt_info->gsm_info[0].mnc = cell->value6;
774 pt_info->gsm_info[0].flag = 0;
775 pt_info->gsm_info_num++;
776 pt_info->gsm_info_valid = 1;
777 }
778 break;
779 case MBTK_CELL_TYPE_UMTS:
780 {
781 LOGD("UMTS : lac=%d, ci=%d, arfcn=%d", cell->value1, cell->value2, cell->value3);
782 pt_info->umts_info[0].lac = cell->value1;
783 pt_info->umts_info[0].cid = cell->value2;
784 pt_info->umts_info[0].uarfcn = cell->value3;
785 pt_info->umts_info[0].mcc = cell->value4;
786 pt_info->umts_info[0].mnc = cell->value5;
787 pt_info->umts_info[0].psc = cell->value6;
788 pt_info->umts_info[0].flag = 0;
789 pt_info->umts_info_num++;
790 pt_info->umts_info_valid = 1;
791 }
792 break;
793 case MBTK_CELL_TYPE_LTE:
794 {
795 LOGD("LTE : tac=%d, PCI=%d, dlEuarfcn=%d, ulEuarfcn=%d, band=%d", cell->value1, cell->value2, cell->value3, cell->value4, cell->value5);
796 pt_info->lte_info[0].tac = cell->value1;
797 pt_info->lte_info[0].pci = cell->value2;
798 pt_info->lte_info[0].earfcn = cell->value3;
799 pt_info->lte_info[0].cid = cell->value8;
800 pt_info->lte_info[0].mcc = cell->value6;
801 pt_info->lte_info[0].mnc = cell->value7;
802 pt_info->lte_info[0].flag = 0;
803 pt_info->lte_info_num++;
804 pt_info->lte_info_valid = 1;
805 break;
806 }
807 default:
808 break;
809 }
810 }
811 while ((cell = (mbtk_cell_info_t*) list_next(cell_list)))
812 {
813 switch(type)
814 {
815 case MBTK_CELL_TYPE_GSM:
816 {
817 LOGD("CELL : %d, %d, %d, %d, %d", cell->value1, cell->value2, cell->value3, cell->value4, cell->value5);
818 pt_info->gsm_info[pt_info->gsm_info_num].lac = cell->value1;
819 pt_info->gsm_info[pt_info->gsm_info_num].cid = cell->value2;
820 pt_info->gsm_info[pt_info->gsm_info_num].arfcn = cell->value3;
821 pt_info->gsm_info[pt_info->gsm_info_num].bsic = cell->value4;
822 pt_info->gsm_info[pt_info->gsm_info_num].flag = 1;
823 pt_info->gsm_info_num++;
824 pt_info->gsm_info_valid = 1;
825 }
826 break;
827 case MBTK_CELL_TYPE_UMTS:
828 {
829 LOGD("CELL : lac=%d, ci=%d, arfcn=%d", cell->value1, cell->value2, cell->value3);
830 pt_info->umts_info[pt_info->umts_info_num].lac = cell->value1;
831 pt_info->umts_info[pt_info->umts_info_num].cid = cell->value2;
832 pt_info->umts_info[pt_info->umts_info_num].uarfcn = cell->value3;
833 pt_info->umts_info[pt_info->umts_info_num].flag = 1;
834 pt_info->umts_info_num++;
835 pt_info->umts_info_valid = 1;
836 }
837 break;
838 case MBTK_CELL_TYPE_LTE:
839 {
840 LOGD("CELL : phyCellId=%d, euArfcn=%d, rsrp=%d, rsrq=%d", cell->value1, cell->value2, cell->value3, cell->value4);
841 pt_info->lte_info[pt_info->lte_info_num].cid = cell->value1;
842 pt_info->lte_info[pt_info->lte_info_num].earfcn = cell->value2;
843 pt_info->lte_info[pt_info->lte_info_num].tac = cell->value3;
844 pt_info->lte_info[pt_info->lte_info_num].pci = cell->value4;
845 pt_info->lte_info[pt_info->lte_info_num].flag = 1;
846 pt_info->lte_info_num++;
847 pt_info->lte_info_valid = 1;
848 }
849 break;
850 default:
851 break;
852 }
853 }
854 list_free(cell_list);
855 }
856
857 LOGD("get_cell_success: %d, %d, %d.",pt_info->gsm_info_valid, pt_info->umts_info_valid, pt_info->lte_info_valid);
858 return QL_NW_SUCCESS;
859}
860
861QL_NW_ERROR_CODE ql_nw_add_event_handler(QL_NW_EventHandlerFunc_t handlerPtr,void* contextPtr)
862{
863 if(ql_info_handle == NULL || handlerPtr == NULL)
864 {
865 LOGE("ARG error.");
866 return QL_NW_GENERIC_FAILURE;
867 }
868 mbtk_net_state_change_cb_reg(ql_info_handle, ql_nw_state_change_cb);
869 ql_func_cb_handle.handlerPtr = handlerPtr;
870 ql_func_cb_handle.contextPtr = contextPtr;
871 return QL_NW_SUCCESS;
872}
873
874QL_NW_ERROR_CODE ql_nw_get_volte_state(VOLTE_STATE *state)
875{
876 int ret;
877 if(ql_info_handle == NULL || state == NULL)
878 {
879 LOGE("ARG error.");
880 return QL_NW_GENERIC_FAILURE;
881 }
882 ret = mbtk_volte_state_get(ql_info_handle, &(state->reg_state));
883 if(ret != 0)
884 return QL_NW_GENERIC_FAILURE;
885 else
886 return QL_NW_SUCCESS;
887}
888
889QL_NW_ERROR_CODE ql_nw_csq_get_signal_strength(QL_NW_CSQ_SIGNAL_STRENGTH_INFO_T *pt_info)
890{
891 int ret;
892 if(ql_info_handle == NULL || pt_info == NULL)
893 {
894 LOGE("ARG error.");
895 return QL_NW_GENERIC_FAILURE;
896 }
897 mbtk_signal_info_t signal;
898 ret = mbtk_net_signal_get(ql_info_handle, &signal);
899 if(ret != 0)
900 return QL_NW_GENERIC_FAILURE;
901 else
902 {
903 pt_info->rssi = (signal.rssi * 2 - 113);
904 pt_info->bitErrorRate = signal.ber;
905 LOGD("pt_info->rssi = %d pt_info->bitErrorRate = %d",pt_info->rssi,pt_info->bitErrorRate);
906 return QL_NW_SUCCESS;
907 }
908}
909
910//*********************************************************************************
911