Gitiles
Code Review Sign In
192.168.1.100 / T108_Public / 10a341098c6f513bf58b8f3f4dfa967e9e570c02 / . / mbtk / test / libmbtk_ril / mbtk_ril_test.c
blob: acc9266b78c99f2f20dbdded250ea90fbee224eb [file] [log] [blame]
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]1#include <stdio.h>
2#include <stdlib.h>
3#include <unistd.h>
4#include <errno.h>
5#include <sys/socket.h>
6#include <sys/un.h>
7#include <netinet/in.h>
8#include <pthread.h>
9#include <sys/epoll.h>
10#include <string.h>
11#include <fcntl.h>
12#include <signal.h>
13
14#include "mbtk_ril_api.h"
15
16#define CLI_THREAD_MAX 3
17
18typedef struct {
19 pthread_t pid;
20 bool is_running;
21 char name[20];
22} ril_cli_thread_info_t;
23
24static ril_cli_thread_info_t cli_threads[CLI_THREAD_MAX];
25static int cli_pid_index = 1;
26
27static void help()
28{
29 printf("version: Get version.\n");
30 printf("imei: Get IMEI.\n");
31 printf("sn: Get SN.\n");
32 printf("meid: Get MEID.\n");
33 printf("volte: Get VoLTE state.\n");
34 printf("volte 0: Close VoLTE.\n");
35 printf("volte 1: Open VoLTE.\n");
36 printf("radio: Get radio state.\n");
37 printf("radio 0 [0/1]: Close radio.\n");
38 printf("radio 1 [0/1]: Open radio.\n");
39 printf("temp <0,1>: Get SOC/RF temperature.\n");
40 printf("cell_time: Get cell time.\n");
41 printf("sim_state: Get sim state.\n");
42 printf("sim_type: Get sim type.\n");
43 printf("imsi: Get IMSI.\n");
44 printf("iccid: Get ICCID.\n");
45 printf("pn: Get Phone Number.\n");
46 printf("pin_state:Get Sim lock state.\n");
47 printf("pin_times:Get PIN/PUK last times.\n");
48 printf("pin_open <PIN>:Enable sim lock.\n");
49 printf("pin_close <PIN>:Disable sim lock.\n");
50 printf("pin_change <old_pin> <new_pin>:Change sim PIN.\n");
51 printf("pin_verify <PIN>:Verify PIN.\n");
52 printf("puk_verify <PUK> <PIN>:Verify PUK.\n");
53 printf("plmn:Get PLMN List.\n");
54 printf("avail_net: Get available network.\n");
55 printf("sel_mode: Get network select mode.\n");
56 printf("sel_mode <sel_mode> <net_type> <plmn>: Set network select mode.\n");
57 printf("band: Get current bands.\n");
58 printf("band support: Get support bands.\n");
59 printf("band <net_pref> <gsm_band> <umts_band> <tdlte_band> <fddlte_band>: Set current bands.\n");
60 printf("signal: Get network signal.\n");
61 printf("reg: Get network registe information.\n");
62 printf("cell: Get current cell information.\n");
63 printf("shutdown <0,1,2>: reboot/poweroff/halt system.\n");
64 printf("power_sim <0,1>: Power off/on sim.\n");
65 printf("time <0,1,2> YYYY-MM-DD HH:MM:SS : Set system time as CELL/NTP/User.\n");
66 printf("apn : Get current apns.\n");
b.liubcf86c92024-08-19 19:48:28 +0800[diff] [blame]67 printf("apn <cid> <ip_type:1/2/3/4> <save:0/1> <auto_call:0/1> <def_route:0/1> <as_dns:0/1> <apn/null> : Set apn.\n");
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]68 printf("apn_del <cid> <save:0/1> : Delete APN.\n");
b.liubcf86c92024-08-19 19:48:28 +0800[diff] [blame]69 printf("data_call <0/1/2> <cid> <auto_boot_call> <def_route> <as_dns>: Stop/Start/State data call.\n");
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]70 printf("call: Call the phone number.\n");
71 printf("answer: Answer the phone call.\n");
72 printf("hangup: Hang up all phone call. No id.\n");
73 printf("hangup 0: Hang up waiting or background phone call.\n");
74 printf("hangup 1: Hang up a phone call.\n");
75 printf("hangup 2: Hang up a phone call.\n");
76 printf("hangup 3: Hangup foreground resume background call.\n");
77 printf("waitin: Returns the list of current calls.\n");
78 printf("mute: Get mute state.\n");
79 printf("mute 0: Close mute.\n");
80 printf("mute 1: Open mute.\n");
81 printf("dtmf : Set dtmf character[0, 1, 2, ..., A, B, C, D, *, #], duration [300-600].\n Such as: dtmf 0 300\n");
82 printf("ims_en 0/1 : Close/Open IMS(Restart takes effect).\n");
83 printf("ims_state : Get IMS open or not?\n");
84 printf("ims_reg: Get IMS register state.\n");
85}
86
87static void thread_exit_with_wait()
88{
89 int i = 0;
90 while(i < CLI_THREAD_MAX) {
91 cli_threads[i].is_running = FALSE;
92 i++;
93 }
94
95 i = 0;
96 while(i < CLI_THREAD_MAX) {
97 if(cli_threads[i].pid) {
98 pthread_join(cli_threads[i].pid, NULL);
99 printf("Thread (%s) exit.\n", cli_threads[i].name);
100 }
101 i++;
102 }
103}
104
105static void sig_process(int sig)
106{
107 LOGI("I got signal %d\n", sig);
108 switch(sig)
109 {
110 case SIGINT: // Ctrl + C
111 {
112 LOGI("Exit by SIGINT.\n");
113 thread_exit_with_wait();
114 mbtk_ril_deinit();
115 exit(0);
116 }
117 case SIGQUIT: // Ctrl + \ (类似 SIGINT ，但要产生core文件)
118 {
119 LOGI("Exit by SIGQUIT.\n");
120 thread_exit_with_wait();
121 mbtk_ril_deinit();
122 exit(0);
123 }
124 case SIGTERM:// 默认kill (同 SIGKILL ，但 SIGKILL 不可捕获)
125 {
126 LOGI("Exit by SIGTERM.\n");
127 thread_exit_with_wait();
128 mbtk_ril_deinit();
129 exit(0);
130 }
131 case SIGTSTP:// Ctrl + Z (同 SIGSTOP ，但 SIGSTOP 不可捕获)
132 {
133 LOGI("Exit by SIGTSTP.\n");
134 exit(0);
135 }
136 case SIGSEGV: // 如空指针
137 {
138 LOGI("Exit by SIGSEGV.\n");
139 exit(0);
140 }
141 default:
142 {
143 LOGI("Unknown sig:%d\n",sig);
144 break;
145 }
146 }
147}
148
149static char* thread_id2name(pthread_t pid)
150{
151 int i = 0;
152 while(i < CLI_THREAD_MAX) {
153 if(pid == cli_threads[i].pid) {
154 return cli_threads[i].name;
155 }
156 i++;
157 }
158
159 return "UNKNOWN";
160}
161
162static void* sub_thread_run(void *arg)
163{
164 ril_cli_thread_info_t *cli = (ril_cli_thread_info_t*)arg;
165 cli->pid = pthread_self();
166 cli->is_running = TRUE;
167 sprintf(cli->name, "PID-%d", cli_pid_index++);
168
169 printf("[%s] enter.\n", thread_id2name(cli->pid));
170 while(cli->is_running) {
171 srand((int)(time(0) + cli->pid));
172 int time_sec = 1 + (int)(10.0 * rand() / ( RAND_MAX + 1.0));
173 char version[50] = {0};
174 mbtk_ril_err_enum err = mbtk_version_get(version);
175 if(err != MBTK_RIL_ERR_SUCCESS) {
176 printf("[%s : %ds]Error : %d\n", thread_id2name(cli->pid), time_sec, err);
177 } else {
178 printf("[%s : %ds]Version : %s\n", thread_id2name(cli->pid), time_sec, version);
179 }
180
181 sleep(time_sec);
182 }
183 printf("[%s] exit.\n", thread_id2name(cli->pid));
184 return NULL;
185}
186
187int main(int argc, char *argv[])
188{
189 signal(SIGINT, sig_process);
190 signal(SIGQUIT, sig_process);
191 signal(SIGTERM, sig_process);
192 //signal(SIGTSTP, sig_process);
193 //signal(SIGSEGV, sig_process);
194
195 mbtk_log_init("radio","RIL_CLI");
196
197#ifdef MBTK_DUMP_SUPPORT
198 mbtk_debug_open(NULL, TRUE);
199#endif
200
201 //test2(0, "192.168.1.198");
202 //test2(1, "2409:8162:140:cd3c:1:2:1494:72ba");
203 //test2(1, "254.128.0.0.0.0.0.0.0.1.0.2.144.5.212.239");
204 //test2(1, "2400:3200::1");
205
206 if(mbtk_ril_init() != MBTK_RIL_ERR_SUCCESS)
207 {
208 return -1;
209 }
210
211#if 0
212 memset(cli_threads, 0, sizeof(ril_cli_thread_info_t) * CLI_THREAD_MAX);
213
214 pthread_t pid1, pid2, pid3;
215 if(pthread_create(&pid1, NULL, sub_thread_run, &cli_threads[0]))
216 {
217 printf("pthread_create() fail.");
218 goto exit;
219 }
220
221 if(pthread_create(&pid2, NULL, sub_thread_run, &cli_threads[1]))
222 {
223 printf("pthread_create() fail.");
224 goto exit;
225 }
226
227 if(pthread_create(&pid3, NULL, sub_thread_run, &cli_threads[2]))
228 {
229 printf("pthread_create() fail.");
230 goto exit;
231 }
232#endif
233 printf(">>>>>>>>>>>>>>>>>>>>>>>>Enter cmd:\n");
234 char cmd[100];
235 while(1)
236 {
237 memset(cmd, 0, 100);
238 mbtk_ril_err_enum err;
239 if(fgets(cmd, 100, stdin))
240 {
241 char *ptr = cmd + strlen(cmd) - 1;
242 while(ptr >= cmd && (*ptr == '\r' || *ptr == '\n'))
243 {
244 *ptr-- = '\0';
245 }
246 if(!strncasecmp(cmd, "version", 7))
247 {
248 char version[50] = {0};
249 err = mbtk_version_get(version);
250 if(err != MBTK_RIL_ERR_SUCCESS) {
251 printf("Error : %d\n", err);
252 } else {
253 printf("Version : %s\n", version);
254 }
255 }
256 else if(!strncasecmp(cmd, "imei", 4)){
257 char imei[50] = {0};
258 err = mbtk_imei_get(imei);
259 if(err != MBTK_RIL_ERR_SUCCESS) {
260 printf("Error : %d\n", err);
261 } else {
262 printf("IMEI : %s\n", imei);
263 }
264 } else if(!strncasecmp(cmd, "sn", 2)){
265 char sn[50] = {0};
266 err = mbtk_sn_get(sn);
267 if(err != MBTK_RIL_ERR_SUCCESS) {
268 printf("Error : %d\n", err);
269 } else {
270 printf("SN : %s\n", sn);
271 }
272 } else if(!strncasecmp(cmd, "meid", 4)){
273 char meid[50] = {0};
274 err = mbtk_meid_get(meid);
275 if(err != MBTK_RIL_ERR_SUCCESS) {
276 printf("Error : %d\n", err);
277 } else {
278 printf("MEID : %s\n", meid);
279 }
280 } else if(!strncasecmp(cmd, "volte", 5)){ // "volte" or "volte 0" or "volte 1"
281 int volte;
282 if(!strcasecmp(cmd, "volte")) { // Get
283 err = mbtk_volte_state_get(&volte);
284 if(err != MBTK_RIL_ERR_SUCCESS) {
285 printf("Error : %d\n", err);
286 } else {
287 printf("VoLTE : %d\n", volte);
288 }
289 } else { // Set
290 if(!strcasecmp(cmd, "volte 1")) { // Open VoLTE
291 volte = 1;
292 } else { // Close VoLTE
293 volte = 0;
294 }
295 err = mbtk_volte_state_set(volte);
296 if(err != MBTK_RIL_ERR_SUCCESS) {
297 printf("Error : %d\n", err);
298 } else {
299 printf("VoLTE set success\n");
300 }
301 }
302 } else if(!strncasecmp(cmd, "radio", 5)){ // "radio" or "radio 0" or "radio 1"
303 mbtk_radio_state_enum radio;
304 if(!strcasecmp(cmd, "radio")) { // Get
305 err = mbtk_radio_state_get(&radio);
306 if(err != MBTK_RIL_ERR_SUCCESS) {
307 printf("Error : %d\n", err);
308 } else {
309 printf("Radio : %d\n", radio);
310 }
311 } else { // Set
312 int reset;
313 int count = sscanf(cmd, "radio %d %d", &radio, &reset);
314 if(count > 0) {
315 if(count == 1) {
316 reset = 0;
317 }
318
319 err = mbtk_radio_state_set(radio, reset);
320 if(err != MBTK_RIL_ERR_SUCCESS) {
321 printf("Error : %d\n", err);
322 } else {
323 printf("Radio set success\n");
324 }
325 }
326 }
327 } else if(!strncasecmp(cmd, "temp", 4)){
328 int temp;
329 if(!strcasecmp(cmd, "temp 0")) {
330 err = mbtk_temp_get(MBTK_TEMP_TYPE_SOC, &temp);
331 if(err != MBTK_RIL_ERR_SUCCESS) {
332 printf("Error : %d\n", err);
333 } else {
334 printf("SOC : %d\n", temp);
335 }
336 } else if(!strcasecmp(cmd, "temp 1")) {
337 err = mbtk_temp_get(MBTK_TEMP_TYPE_RF, &temp);
338 if(err != MBTK_RIL_ERR_SUCCESS) {
339 printf("Error : %d\n", err);
340 } else {
341 printf("RF : %d\n", temp);
342 }
343 }
344 } else if(!strncasecmp(cmd, "cell_time", 9)){
345 char time[128] = {0};
346 err = mbtk_cell_time_get(time);
347 if(err != MBTK_RIL_ERR_SUCCESS) {
348 printf("Error : %d\n", err);
349 } else {
350 printf("Cell Time : %s\n", time);
351 }
352 } else if(!strncasecmp(cmd, "sim_state", 9)){
353 mbtk_sim_state_enum sim;
354 err = mbtk_sim_state_get(&sim);
355 if(err != MBTK_RIL_ERR_SUCCESS) {
356 printf("Error : %d\n", err);
357 } else {
358 printf("Sim State : %d\n", sim);
359 }
360 } else if(!strncasecmp(cmd, "sim_type", 8)){
361 mbtk_sim_card_type_enum type;
362 err = mbtk_sim_type_get(&type);
363 if(err != MBTK_RIL_ERR_SUCCESS) {
364 printf("Error : %d\n", err);
365 } else {
366 printf("Sim Type : %d\n", type);
367 }
368 } else if(!strncasecmp(cmd, "imsi", 4)){
369 char imsi[50] = {0};
370 err = mbtk_imsi_get(imsi);
371 if(err != MBTK_RIL_ERR_SUCCESS) {
372 printf("Error : %d\n", err);
373 } else {
374 printf("IMSI : %s\n", imsi);
375 }
376 } else if(!strncasecmp(cmd, "iccid", 5)){
377 char iccid[50] = {0};
378 err = mbtk_iccid_get(iccid);
379 if(err != MBTK_RIL_ERR_SUCCESS) {
380 printf("Error : %d\n", err);
381 } else {
382 printf("ICCID : %s\n", iccid);
383 }
384 } else if(!strncasecmp(cmd, "pn", 2)){
385 char phone_number[50] = {0};
386 err = mbtk_phone_number_get(phone_number);
387 if(err != MBTK_RIL_ERR_SUCCESS) {
388 printf("Error : %d\n", err);
389 } else {
390 printf("Phone Number : %s\n", phone_number);
391 }
392 }
393 /*
394 printf("pin_state:Get Sim lock state.\n");
395 printf("pin_times:Get PIN/PUK last times.\n");
396 printf("pin_open <PIN>:Enable sim lock.\n");
397 printf("pin_close <PIN>:Disable sim lock.\n");
398 printf("pin_change <old_pin> <new_pin>:Change sim PIN.\n");
399 printf("pin_verify <PIN>:Verify PIN.\n");
400 printf("puk_verify <PUK> <PIN>:Verify PUK.\n");
401 */
402 else if(!strncasecmp(cmd, "pin_state", 9)){
403 int lock_state;
404 err = mbtk_sim_lock_get(&lock_state);
405 if(err != MBTK_RIL_ERR_SUCCESS) {
406 printf("Error : %d\n", err);
407 } else {
408 printf("PIN state : %d\n", lock_state);
409 }
410 } else if(!strncasecmp(cmd, "pin_times", 9)){
411 mbtk_pin_puk_last_times_t times;
412 err = mbtk_sim_lock_retry_times_get(&times);
413 if(err != MBTK_RIL_ERR_SUCCESS) {
414 printf("Error : %d\n", err);
415 } else {
416 printf("PIN/PUK retry times:%d,%d,%d,%d\n", times.p1_retry, times.p2_retry, times.puk1_retry, times.puk2_retry);
417 }
418 } else if(!strncasecmp(cmd, "pin_open", 8)){
419 mbtk_sim_lock_info_t info;
420 info.type = MBTK_SIM_LOCK_TYPE_ENABLE;
421 int count = sscanf(cmd, "pin_open %s", info.pin1);
422 if(count == 1) {
423 err = mbtk_sim_lock_set(&info);
424 if(err != MBTK_RIL_ERR_SUCCESS) {
425 printf("Error : %d\n", err);
426 } else {
427 printf("Enable sim lock success.\n");
428 }
429 }
430 } else if(!strncasecmp(cmd, "pin_close", 9)){
431 mbtk_sim_lock_info_t info;
432 info.type = MBTK_SIM_LOCK_TYPE_DISABLE;
433 int count = sscanf(cmd, "pin_close %s", info.pin1);
434 if(count == 1) {
435 err = mbtk_sim_lock_set(&info);
436 if(err != MBTK_RIL_ERR_SUCCESS) {
437 printf("Error : %d\n", err);
438 } else {
439 printf("Disable sim lock success.\n");
440 }
441 }
442 } else if(!strncasecmp(cmd, "pin_change", 10)){
443 mbtk_sim_lock_info_t info;
444 info.type = MBTK_SIM_LOCK_TYPE_CHANGE;
445 int count = sscanf(cmd, "pin_change %s %s", info.pin1, info.pin2);
446 if(count == 2) {
447 err = mbtk_sim_lock_set(&info);
448 if(err != MBTK_RIL_ERR_SUCCESS) {
449 printf("Error : %d\n", err);
450 } else {
451 printf("PIN change success.\n");
452 }
453 }
454 } else if(!strncasecmp(cmd, "pin_verify", 10)){
455 mbtk_sim_lock_info_t info;
456 info.type = MBTK_SIM_LOCK_TYPE_VERIFY_PIN;
457 int count = sscanf(cmd, "pin_verify %s", info.pin1);
458 if(count == 1) {
459 err = mbtk_sim_lock_set(&info);
460 if(err != MBTK_RIL_ERR_SUCCESS) {
461 printf("Error : %d\n", err);
462 } else {
463 printf("PIN verify success.\n");
464 }
465 }
466 } else if(!strncasecmp(cmd, "puk_verify", 10)){
467 mbtk_sim_lock_info_t info;
468 info.type = MBTK_SIM_LOCK_TYPE_VERIFY_PUK;
469 int count = sscanf(cmd, "puk_verify %s %s", info.puk, info.pin1);
470 if(count == 2) {
471 err = mbtk_sim_lock_set(&info);
472 if(err != MBTK_RIL_ERR_SUCCESS) {
473 printf("Error : %d\n", err);
474 } else {
475 printf("PUK verify success.\n");
476 }
477 }
478 } else if(!strncasecmp(cmd, "plmn", 4)){
479 mbtk_plmn_info info;
480 err = mbtk_plmn_list_get(&info);
481 if(err != MBTK_RIL_ERR_SUCCESS) {
482 printf("Error : %d\n", err);
483 } else {
484 printf("PLMN number:%d\n", info.count);
485 int i = 0;
486 while(i < info.count) {
487 printf("%d,%d,%s\n", i+1, info.plmn[i].format, info.plmn[i].name);
488 i++;
489 }
490 }
491 }
492 else if(!strncasecmp(cmd, "avail_net", 9)){
493 mbtk_net_info_array_t net_list;
494 err = mbtk_available_net_get(&net_list);
495 if(err != MBTK_RIL_ERR_SUCCESS) {
496 printf("Error : %d\n", err);
497 } else {
498 printf("Available net number:%d\n", net_list.num);
499 int i = 0;
500 while(i < net_list.num) {
501 printf("NET : %d,%d,%d,%d\n", net_list.net_info[i].net_sel_mode,
502 net_list.net_info[i].net_type, net_list.net_info[i].net_state,
503 net_list.net_info[i].plmn);
504 i++;
505 }
506 }
507 } else if(!strncasecmp(cmd, "sel_mode", 8)){ // "sel_mode" or "sel_mode 1 7 46000"
508 mbtk_net_info_t net;
509 memset(&net, 0, sizeof(mbtk_net_info_t));
510 if(!strcasecmp(cmd, "sel_mode")) { // Get
511 err = mbtk_net_sel_mode_get(&net);
512 if(err != MBTK_RIL_ERR_SUCCESS) {
513 printf("Error : %d\n", err);
514 } else {
515 printf("Net : %d, %d, %d, %d\n", net.net_sel_mode, net.net_type, net.net_state, net.plmn);
516 }
517 } else { // Set
518 char *ptr = strstr(cmd, " ");
519 if(ptr == NULL)
520 continue;
521 while(*ptr != '\0' && *ptr == ' ')
522 ptr++;
523 net.net_sel_mode = (uint8)atoi(ptr);
524
525 ptr = strstr(ptr, " ");
526 if(ptr == NULL)
527 continue;
528 while(*ptr != '\0' && *ptr == ' ')
529 ptr++;
530 net.net_type = (uint8)atoi(ptr);
531
532 ptr = strstr(ptr, " ");
533 if(ptr == NULL)
534 continue;
535 while(*ptr != '\0' && *ptr == ' ')
536 ptr++;
537 net.plmn = (uint32)atoi(ptr);
538
539 err = mbtk_net_sel_mode_set(&net);
540 if(err != MBTK_RIL_ERR_SUCCESS) {
541 printf("Error : %d\n", err);
542 } else {
543 printf("Net select mode set success\n");
544 }
545 }
546 } else if(!strncasecmp(cmd, "band", 4)){ // "band" or "band support" or "band 0 79 147 482 524503"
547 mbtk_band_info_t band;
548 memset(&band, 0x0, sizeof(mbtk_band_info_t));
549 if(!strcasecmp(cmd, "band")) { // Get
550 err = mbtk_current_band_get(&band);
551 if(err != MBTK_RIL_ERR_SUCCESS) {
552 printf("Error : %d\n", err);
553 } else {
554 printf("Band : %d, %d, %d, %d, %d, %d\n", band.net_pref, band.gsm_band, band.umts_band, band.tdlte_band, band.fddlte_band, band.lte_ext_band);
555 }
556 } else if(!strcasecmp(cmd, "band support")) { // Get
557 err = mbtk_support_band_get(&band);
558 if(err != MBTK_RIL_ERR_SUCCESS) {
559 printf("Error : %d\n", err);
560 } else {
561 printf("Band : %d, %d, %d, %d, %d, %d\n", band.net_pref, band.gsm_band, band.umts_band, band.tdlte_band, band.fddlte_band, band.lte_ext_band);
562 }
563 } else { // "band 0 79 147 482 524503"
564 char *ptr = strstr(cmd, " ");
565 if(ptr == NULL)
566 continue;
567 while(*ptr != '\0' && *ptr == ' ')
568 ptr++;
569 band.net_pref = (uint8)atoi(ptr);
570
571 ptr = strstr(ptr, " ");
572 if(ptr == NULL)
573 continue;
574 while(*ptr != '\0' && *ptr == ' ')
575 ptr++;
576 band.gsm_band = (uint16)atoi(ptr);
577
578 ptr = strstr(ptr, " ");
579 if(ptr == NULL)
580 continue;
581 while(*ptr != '\0' && *ptr == ' ')
582 ptr++;
583 band.umts_band = (uint16)atoi(ptr);
584
585 ptr = strstr(ptr, " ");
586 if(ptr == NULL)
587 continue;
588 while(*ptr != '\0' && *ptr == ' ')
589 ptr++;
590 band.tdlte_band = (uint32)atoi(ptr);
591
592 ptr = strstr(ptr, " ");
593 if(ptr == NULL)
594 continue;
595 while(*ptr != '\0' && *ptr == ' ')
596 ptr++;
597 band.fddlte_band = (uint32)atoi(ptr);
598
599 err = mbtk_current_band_set(&band);
600 if(err != MBTK_RIL_ERR_SUCCESS) {
601 printf("Error : %d\n", err);
602 } else {
603 printf("Band set success\n");
604 }
605 }
606 } else if(!strncasecmp(cmd, "signal", 6)){
607 mbtk_signal_info_t signal;
608 err = mbtk_net_signal_get(&signal);
609 if(err != MBTK_RIL_ERR_SUCCESS) {
610 printf("Error : %d\n", err);
611 } else {
612 printf("Signal : %d, %d, %d, %d, %d, %d, %d, %d\n", signal.type, signal.rssi, signal.rxlev, signal.ber,
613 signal.rscp, signal.ecno, signal.rsrq, signal.rsrp);
614 }
615 } else if(!strncasecmp(cmd, "reg", 3)){
616 mbtk_net_reg_info_t reg;
617 err = mbtk_net_reg_get(&reg);
618 if(err != MBTK_RIL_ERR_SUCCESS) {
619 printf("Error : %d\n", err);
620 } else {
621 printf("REG : call_state=%d, data_state=%d, ims_state=%d, net_type=%d, %04x, %08x\n", reg.call_state, reg.data_state, reg.ims_state, reg.type, reg.lac, reg.ci);
622 }
623 } else if(!strncasecmp(cmd, "apn_del", 7)) {
624 mbtk_apn_info_t apn;
625 memset(&apn, 0, sizeof(mbtk_apn_info_t));
626 int cid, auto_save;
627 int count = sscanf(cmd, "apn_del %d %d", &cid, &auto_save);
628 if(count == 2) {
629 apn.cid = (mbtk_ril_cid_enum)cid;
630 apn.auto_save = (uint8)auto_save;
631 }
632 err = mbtk_apn_set(&apn);
633 if(err != MBTK_RIL_ERR_SUCCESS) {
634 printf("Error : %d\n", err);
635 } else {
636 printf("APN delete success\n");
637 }
638
639 } else if(!strncasecmp(cmd, "apn", 3)){
640 if(!strcasecmp(cmd, "apn")) { // Get apn
641 mbtk_apn_info_array_t apns;
642 err = mbtk_apn_get(&apns);
643 if(err != MBTK_RIL_ERR_SUCCESS) {
644 printf("Error : %d\n", err);
645 } else {
646 printf("APN Num:%d\n", apns.num);
647 int i = 0;
648 while(i < apns.num) {
b.liu10a34102024-08-20 20:36:24 +0800[diff] [blame^]649 // printf("APN : %d, %s, %s\n", apns.apns[i].cid, apn2str(apns.apns[i].ip_type), apns.apns[i].apn);
650 printf("APN : %d, %s, auth-%d, auto_save-%d, auto_boot_call-%d, %s, %s, %s, %s\n", apns.apns[i].cid, apn2str(apns.apns[i].ip_type),
651 apns.apns[i].auth, apns.apns[i].auto_save, apns.apns[i].auto_boot_call,
652 str_empty(apns.apns[i].apn) ? "NULL" : apns.apns[i].apn,
653 str_empty(apns.apns[i].user) ? "NULL" : apns.apns[i].user,
654 str_empty(apns.apns[i].pass) ? "NULL" : apns.apns[i].pass,
655 str_empty(apns.apns[i].type) ? "NULL" : apns.apns[i].type);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]656 i++;
657 }
b.liu10a34102024-08-20 20:36:24 +0800[diff] [blame^]658 printf("Def route : %d, def dns : %d\n", apns.cid_for_def_route, apns.cid_for_def_dns);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]659 }
660 } else { // apn <cid> <0/1/2/3> <0/1> <0/1> <apn>
661 mbtk_apn_info_t apn;
662 memset(&apn, 0, sizeof(mbtk_apn_info_t));
663#if 1
b.liubcf86c92024-08-19 19:48:28 +0800[diff] [blame]664 int cid, ip_type, auto_save, auto_boot_call, def_route, as_dns;
665 int count = sscanf(cmd, "apn %d %d %d %d %d %d %s",
666 &cid, &ip_type, &auto_save, &auto_boot_call,
667 &def_route, &as_dns, apn.apn);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]668
669 // Delete APN
670 if(strcmp(apn.apn,"null") == 0 || strcmp(apn.apn,"NULL") == 0) {
671 memset(apn.apn, 0, sizeof(apn.apn));
672 }
b.liubcf86c92024-08-19 19:48:28 +0800[diff] [blame]673 if(count == 7) {
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]674 apn.cid = (mbtk_ril_cid_enum)cid;
675 apn.ip_type = (mbtk_ip_type_enum)ip_type;
676 apn.auto_save = (uint8)auto_save;
677 apn.auto_boot_call = (uint8)auto_boot_call;
b.liubcf86c92024-08-19 19:48:28 +0800[diff] [blame]678 apn.def_route = (uint8)def_route;
679 apn.as_dns = (uint8)as_dns;
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]680 }
681#else
682 char *ptr = strstr(cmd, " ");
683 if(ptr == NULL)
684 continue;
685 while(*ptr != '\0' && *ptr == ' ')
686 ptr++;
687 apn.cid = (mbtk_ril_cid_enum)atoi(ptr);
688
689 ptr = strstr(ptr, " ");
690 if(ptr == NULL)
691 continue;
692 while(*ptr != '\0' && *ptr == ' ')
693 ptr++;
694 apn.ip_type = (mbtk_ip_type_enum)atoi(ptr);
695
696 ptr = strstr(ptr, " ");
697 if(ptr == NULL)
698 continue;
699 while(*ptr != '\0' && *ptr == ' ')
700 ptr++;
701 memcpy(apn.apn, ptr, strlen(ptr));
702#endif
703 err = mbtk_apn_set(&apn);
704 if(err != MBTK_RIL_ERR_SUCCESS) {
705 printf("Error : %d\n", err);
706 } else {
707 printf("APN set success\n");
708 }
709 }
710 }
b.liubcf86c92024-08-19 19:48:28 +0800[diff] [blame]711 else if(!strncasecmp(cmd, "data_call", 9)){ // data_call <0/1/2> <cid> <timeout>
712 // mbtk_ril_cid_enum cid, bool auto_boot_call, bool def_route, int retry_interval, int timeout, mbtk_ip_info_t *rsp_info
713 // data_call <0/1/2> <cid> <timeout>
714 int type, cid, auto_boot_call, def_route, as_dns;
715 int count = sscanf(cmd, "data_call %d %d %d %d %d", &type, &cid, &auto_boot_call, &def_route, &as_dns);
716 if(count != 5) {
717 count = sscanf(cmd, "data_call %d %d", &type, &cid);
718 }
719
720 if(count == 5 || count == 2) {
721 mbtk_ip_info_t ip;
722 memset(&ip, 0, sizeof(mbtk_ip_info_t));
723 if(type == MBTK_DATA_CALL_START) {
724 err = mbtk_data_call_start((mbtk_ril_cid_enum)cid, (bool)auto_boot_call, (bool)def_route, (bool)as_dns, 10, 10, &ip);
725 } else if(type == MBTK_DATA_CALL_STOP) {
726 err = mbtk_data_call_stop((mbtk_ril_cid_enum)cid, 10);
727 } else {
728 err = mbtk_data_call_state_get((mbtk_ril_cid_enum)cid, &ip);
729 }
730 if(err) {
731 printf("Error : %d\n", err);
732 } else {
733 printf("DATA_CALL success\n");
734 if(type == MBTK_DATA_CALL_START || type == MBTK_DATA_CALL_STATE) {
735 if(ip.ipv4.valid) {
736 // log_hex("IPv4", &ipv4, sizeof(mbtk_ipv4_info_t));
737 char ip_tmp[20];
738
739 memset(ip_tmp, 0, 20);
740 if(inet_ntop(AF_INET, &(ip.ipv4.IPAddr), ip_tmp, 20) == NULL) {
741 printf("IP error.\n");
742 } else {
743 printf("IP : %s\n", ip_tmp);
744 }
745
746 memset(ip_tmp, 0, 20);
747 if(inet_ntop(AF_INET, &(ip.ipv4.PrimaryDNS), ip_tmp, 20) == NULL) {
748 printf("PrimaryDNS error.\n");
749 } else {
750 printf("PrimaryDNS : %s\n", ip_tmp);
751 }
752
753 memset(ip_tmp, 0, 20);
754 if(inet_ntop(AF_INET, &(ip.ipv4.SecondaryDNS), ip_tmp, 20) == NULL) {
755 printf("SecondaryDNS error.\n");
756 } else {
757 printf("SecondaryDNS : %s\n", ip_tmp);
758 }
759
760 memset(ip_tmp, 0, 20);
761 if(inet_ntop(AF_INET, &(ip.ipv4.GateWay), ip_tmp, 20) == NULL) {
762 printf("GateWay error.\n");
763 } else {
764 printf("GateWay : %s\n", ip_tmp);
765 }
766
767 memset(ip_tmp, 0, 20);
768 if(inet_ntop(AF_INET, &(ip.ipv4.NetMask), ip_tmp, 20) == NULL) {
769 printf("NetMask error.\n");
770 } else {
771 printf("NetMask : %s\n", ip_tmp);
772 }
773 }
774
775 if(ip.ipv6.valid) {
776 // log_hex("IPv6", &ipv6, sizeof(mbtk_ipv6_info_t));
777 char ip_tmp[50];
778
779 memset(ip_tmp, 0, 50);
780 if(ipv6_2_str(&(ip.ipv6.IPV6Addr), ip_tmp)) {
781 printf("IP error.\n");
782 } else {
783 printf("IP : %s\n", ip_tmp);
784 }
785
786 memset(ip_tmp, 0, 50);
787 if(ipv6_2_str(&(ip.ipv6.PrimaryDNS), ip_tmp)) {
788 printf("PrimaryDNS error.\n");
789 } else {
790 printf("PrimaryDNS : %s\n", ip_tmp);
791 }
792
793 memset(ip_tmp, 0, 50);
794 if(ipv6_2_str(&(ip.ipv6.SecondaryDNS), ip_tmp)) {
795 printf("SecondaryDNS error.\n");
796 } else {
797 printf("SecondaryDNS : %s\n", ip_tmp);
798 }
799
800 memset(ip_tmp, 0, 50);
801 if(ipv6_2_str(&(ip.ipv6.GateWay), ip_tmp)) {
802 printf("GateWay error.\n");
803 } else {
804 printf("GateWay : %s\n", ip_tmp);
805 }
806
807 memset(ip_tmp, 0, 50);
808 if(ipv6_2_str(&(ip.ipv6.NetMask), ip_tmp)) {
809 printf("NetMask error.\n");
810 } else {
811 printf("NetMask : %s\n", ip_tmp);
812 }
813 }
814 }
815 }
816 }
817 }
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]818 else if(!strncasecmp(cmd, "cell", 4)){
819 char *ptr = strstr(cmd, ","); //CPMS,ME,ME,ME
820 if(ptr == NULL)
821 {
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]822 mbtk_cell_info_array_t cell;
823 err = mbtk_cell_get(&cell);
824 if(err) {
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]825 printf("Error : %d\n", err);
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]826 } else if(cell.num > 0){
827 // Current server cell.
828 switch(cell.type)
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]829 {
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]830 case MBTK_CELL_TYPE_GSM:
831 printf("GSM : lac=%d, ci=%d, arfcn=%d, bsic=%d\n", cell.cell[0].value1, cell.cell[0].value2, cell.cell[0].value3, cell.cell[0].value4);
832 break;
833 case MBTK_CELL_TYPE_UMTS:
834 printf("UMTS : lac=%d, ci=%d, arfcn=%d\n", cell.cell[0].value1, cell.cell[0].value2, cell.cell[0].value3);
835 break;
836 case MBTK_CELL_TYPE_LTE:
837 printf("LTE : tac=%d, PCI=%d, dlEuarfcn=%d, ulEuarfcn=%d, band=%d\n", cell.cell[0].value1, cell.cell[0].value2, cell.cell[0].value3, cell.cell[0].value4, cell.cell[0].value5);
838 break;
839 default:
840 break;
841 }
842
843 int i = 1;
844 while (i < cell.num)
845 {
846 switch(cell.type)
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]847 {
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]848 case MBTK_CELL_TYPE_GSM:
849 printf("CELL : %d, %d, %d, %d, %d", cell.cell[i].value1, cell.cell[i].value2, cell.cell[i].value3, cell.cell[i].value4, cell.cell[i].value5);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]850 break;
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]851 case MBTK_CELL_TYPE_UMTS:
852 printf("CELL : lac=%d, ci=%d, arfcn=%d\n", cell.cell[i].value1, cell.cell[i].value2, cell.cell[i].value3);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]853 break;
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]854 case MBTK_CELL_TYPE_LTE:
855 printf("CELL : phyCellId=%d, euArfcn=%d, rsrp=%d, rsrq=%d\n", cell.cell[i].value1, cell.cell[i].value2, cell.cell[i].value3, cell.cell[i].value4);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]856 break;
857 default:
858 break;
859 }
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]860 i++;
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]861 }
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]862 } else {
863 printf("Cell no found.");
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]864 }
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]865 }
866 else{
867 char *ptr = strstr(cmd, ","); //cell,2,3,,40936,430
868 char mem[50]={0};
869 char resp[1024] = {0};
870 if(ptr != NULL)
871 {
872 ptr++;
873 memset(mem, 0, sizeof(mem));
874 memcpy(mem, ptr, strlen(ptr));
875 printf("cell:%s\n", mem);
876 }
877 printf("cell_mem: %s \n", mem);
878
879 memset(resp, 0, sizeof(resp));
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]880 err = mbtk_cell_set(mem, resp);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]881 if(err) {
882 printf("Error : %d\n", err);
883 } else {
884 printf("cell set . resp:%s\n", resp);
885 }
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]886 }
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]887 }
888 else if(!strncasecmp(cmd, "call", 4)){
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]889 char phone_number[12];
890 char *ptr = strstr(cmd, " ");
891 if(ptr == NULL)
892 continue;
893 while(*ptr != '\0' && *ptr == ' ')
894 ptr++;
895 memset(phone_number,0,strlen(phone_number));
896 memcpy(phone_number,ptr,strlen(ptr));
897 printf("phone number is: %s\n",phone_number);
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]898 err = mbtk_call_start(phone_number);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]899 if(err) {
900 printf("Error : %d\n", err);
901 } else {
902 printf("Call success.\n");
903 }
904 } else if(!strncasecmp(cmd, "answer", 6)){
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]905 err = mbtk_call_answer();
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]906 if(err) {
907 printf("Error : %d\n", err);
908 } else {
909 printf("Call success.\n");
910 }
911 } else if(!strncasecmp(cmd, "hangup", 6)){
912 int phone_id;
913 if(!strcasecmp(cmd, "hangup")) { // hang up all
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]914 err = mbtk_call_hang();
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]915 if(err) {
916 printf("Error : %d\n", err);
917 } else {
918 printf("Call hang up all.\n");
919 }
920 } else if(!strcasecmp(cmd, "hangup 0")) {
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]921 err = mbtk_waiting_or_background_call_hang();
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]922 if(err) {
923 printf("Error : %d\n", err);
924 } else {
925 printf("Call hang up waiting or background.\n");
926 }
927 } else if(!strcasecmp(cmd, "hangup 3")) {
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]928 err = mbtk_foreground_resume_background_call_hang();
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]929 if(err) {
930 printf("Error : %d\n", err);
931 } else {
932 printf("Call hang up foreground resume background.\n");
933 }
934 } else {
935 if(!strcasecmp(cmd, "hangup 1")) { // hang up a call
936 phone_id = 1;
937 } else if(!strcasecmp(cmd, "hangup 2")) {
938 phone_id = 2;
939 } else {
940 printf("Error : Invalid input\n");
941 }
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]942 err = mbtk_a_call_hang(phone_id);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]943 if(err) {
944 printf("Error : %d\n", err);
945 } else {
946 printf("A Call hang up.\n");
947 }
948 }
949 } else if(!strncasecmp(cmd, "waitin", 6)){
950 mbtk_call_info_t reg;
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]951 err = mbtk_call_reg_get(&reg);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]952 if(err) {
953 printf("Error : %d\n", err);
954 } else {
955 if(reg.call_wait == 0) {
956 printf("No call ring\n");
957 }
958 else {
959 printf("RING : %d, %d, %d, %d, %d, %s, %d\n", reg.dir1, reg.dir, reg.state, reg.mode, reg.mpty, reg.phone_number, reg.type);
960 }
961 }
962 } else if(!strncasecmp(cmd, "mute", 4)){ // "mute" or "mute 0" or "mute 1"
963 int mute;
964 if(!strcasecmp(cmd, "mute")) { // Get
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]965 err = mbtk_mute_state_get(&mute);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]966 if(err) {
967 printf("Error : %d\n", err);
968 } else {
969 printf("mute : %d\n", mute);
970 }
971 } else { // Set
972 if(!strcasecmp(cmd, "mute 1")) { // on mute
973 mute = 1;
974 } else { // off mute
975 mute = 0;
976 }
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]977 err = mbtk_mute_state_set(mute);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]978 if(err) {
979 printf("Error : %d\n", err);
980 } else {
981 printf("mute set success\n");
982 }
983 }
984 } else if(!strncasecmp(cmd, "DTMF", 4)){ // valid character: (0, 1, ..., 9, A, B, C, D, *, #)
985
986 mbtk_call_dtmf_info_t reg;
987
988 char *ptr = strstr(cmd, " ");
989 if(ptr == NULL)
990 continue;
991 while(*ptr != '\0' && *ptr == ' ')
992 ptr++;
993 reg.character = *ptr;
994
995 ptr = strstr(ptr, " ");
996 if(ptr == NULL)
997 continue;
998 while(*ptr != '\0' && *ptr == ' ')
999 ptr++;
1000 reg.duration = (uint32)atoi(ptr);
1001 printf("DTMF character is: %c,%d\n",reg.character, reg.duration);
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]1002 err = mbtk_dtmf_send(&reg);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]1003 if(err) {
1004 printf("Error : %d\n", err);
1005 } else {
1006 printf("DTMF success.\n");
1007 }
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]1008 } else if(!strncasecmp(cmd, "cmgf", 4)){ // set mode 0: pud, 1:text
1009 int mode;
1010 if(!strcasecmp(cmd, "cmgf")) { // Get
1011 err = mbtk_sms_cmgf_get(&mode);
1012 if(err) {
1013 printf("Error : %d\n", err);
1014 } else {
1015 printf("VoLTE : %d\n", mode);
1016 }
1017 } else { // Set
1018 if(!strcasecmp(cmd, "cmgf 1")) { // cmgf 1
1019 mode = 1;
1020 } else { //
1021 mode = 0;
1022 }
1023 printf("mode:%d\n", mode);
1024 sleep(2);
1025 err = mbtk_sms_cmgf_set(mode);
1026 if(err) {
1027 printf("Error : %d\n", err);
1028 } else {
1029 printf("VoLTE set success\n");
1030 }
1031 }
1032 }else if(!strncasecmp(cmd, "cpms", 4)){ // //CPMS=ME, ME, ME
1033 char mem[100] = {0};
1034 char resp[100] = {0};
1035 if(!strcasecmp(cmd, "cpms")) { // Get
1036 err = mbtk_sms_cpms_get(&mem);
1037 if(err) {
1038 printf("Error : %d\n", err);
1039 } else {
1040 printf("cpms : %s\n", mem);
1041 }
1042 } else { // Set
1043
1044 char *ptr = strstr(cmd, ","); //CPMS,ME,ME,ME
1045 if(ptr != NULL)
1046 {
1047 ptr++;
1048 memset(mem, 0, sizeof(mem));
1049 memcpy(mem, ptr, strlen(ptr));
1050 printf("cpms:%s\n", mem);
1051 }
1052 printf("cpms 0\n");
1053
1054 memset(resp, 0, sizeof(resp));
1055 err = mbtk_sms_cpms_set(mem, resp);
1056 if(err) {
1057 printf("Error : %d\n", err);
1058 } else {
1059 printf("cpms set success. resp:%s\n", resp);
1060 }
1061 }
1062 }else if(!strncasecmp(cmd, "cmgs", 4)){ // AT+CMGS="10086", CMGS TEST
1063 char cmgs[1024] = {0};
1064 char resp[50] = {0};
1065 if(!strcasecmp(cmd, "cmgs")) { // Get
1066 int mode;
1067 // err = mbtk_sms_cmgs_get(info_handle, &mode);
1068 if(err) {
1069 printf("Error : %d\n", err);
1070 } else {
1071 printf("VoLTE : %d\n", mode);
1072 }
1073 } else { // Set
1074
1075 /*
1076 *AT+CMGS="10086", CMGS TEST // Send a SMS
1077 > CMGS TEST
1078 +CMGS: 17
1079 OK
1080 */
1081
1082 char *ptr = strstr(cmd, "cmgs,"); //CMGS="10086",hf
1083 if(ptr != NULL)
1084 {
1085 ptr = strstr(cmd, ",");
1086 ptr++;
1087 memset(cmgs, 0, sizeof(cmgs));
1088 memcpy(cmgs, ptr, strlen(ptr));
1089 printf("1cmgs:%s, strlen(cmgs):%d\n", cmgs, strlen(cmgs));
1090 }
1091
1092 memset(resp, 0, sizeof(resp));
1093 err = mbtk_sms_cmgs_set(cmgs, resp);
1094 if(err) {
1095 printf("Error : %d\n", err);
1096 } else {
1097 printf("cmgs set success . resp:%s\n", resp);
1098 }
1099 }
1100 }else if(!strncasecmp(cmd, "cmss", 4)){ // +CMSS=<index>[,<da>[,<toda>]]
1101 char cmss[20] = {0};
1102 char resp[20] = {0};
1103 if(!strcasecmp(cmd, "cmgs")) { // Get
1104 printf("cmss : OK\n");
1105
1106 } else {
1107 char *ptr = strstr(cmd, "cmss,"); //CMSS=<index>
1108 if(ptr != NULL)
1109 {
1110 ptr = strstr(cmd, ",");
1111 ptr++;
1112 memset(cmss, 0, sizeof(cmss));
1113 memcpy(cmss, ptr, strlen(ptr));
1114 printf("1cmss:%s\n", cmss);
1115 }
1116
1117
1118 err = mbtk_sms_cmss_set(cmss, resp);
1119 if(err) {
1120 printf("Error : %d\n", err);
1121 } else {
1122 printf("cmss set success. resp:%s\n", resp);
1123 }
1124 }
1125 }
1126 else if(!strncasecmp(cmd, "cmgr", 4)){ // +CMGR=<index
1127 int index = 0;
1128 char resp[1024] = {0};
1129 if(!strcasecmp(cmd, "cmgr")) { // Get
1130 printf("cmgr : OK\n");
1131
1132 } else {
1133 char *ptr = strstr(cmd, "cmgr,"); //+CMGR <index>
1134 if(ptr != NULL)
1135 {
1136 ptr = strstr(cmd, ",");
1137 ptr++;
1138 index = atoi(ptr);
1139 }
1140 printf("1index:%d\n", index);
1141
1142 memset(resp, 0, sizeof(resp));
1143 err = mbtk_sms_cmgr_set(index, resp);
1144 if(err) {
1145 printf("Error : %d\n", err);
1146 } else {
1147 printf("cmgr set success. rep:%s\n", resp);
1148 }
1149 }
1150 }
1151 else if(!strncasecmp(cmd, "cmgw", 4)){ // +CMGW=<oa/da>[,<tooa/toda>[,<stat>]]<CR>
1152 //+CMGW=<length>[,<stat>]<CR>PDU is given<ctrl-Z/ESC>
1153 char cmgw[128] = {0};
1154 char resp[50] = {0};
1155 if(!strcasecmp(cmd, "cmgw")) { // Get
1156 printf("cmgw : OK\n");
1157
1158 } else {
1159 char *ptr = strstr(cmd, "cmgw,"); //+CMGW, <oa/da>, data
1160 if(ptr != NULL)
1161 {
1162 ptr = strstr(cmd, ",");
1163 ptr++;
1164 memset(cmgw, 0, sizeof(cmgw));
1165 memcpy(cmgw, ptr, strlen(ptr));
1166 printf("cmgw:%s\n", cmgw);
1167 }
1168
1169 memset(resp, 0, sizeof(resp));
1170 err = mbtk_sms_cmgw_set(cmgw, resp);
1171 if(err) {
1172 printf("Error : %d\n", err);
1173 } else {
1174 printf("cmgw set success. resp:%s\n", resp);
1175 }
1176 }
1177 }
1178 else if(!strncasecmp(cmd, "cmgd", 4)){ // +CMGD=<index>[,<delflag>
1179 //
1180 char cmgd[128] = {0};
1181 if(!strcasecmp(cmd, "cmgd")) { // Get
1182 printf("cmgd : OK\n");
1183
1184 } else {
1185 char *ptr = strstr(cmd, ","); //+CMGD=<index>[,<delflag>
1186 if(ptr != NULL)
1187 {
1188 ptr++;
1189 memset(cmgd, 0, sizeof(cmgd));
1190 memcpy(cmgd, ptr, strlen(ptr));
1191 printf("1cmgd:%s\n", cmgd);
1192 }
1193
1194
1195 err = mbtk_sms_cmgd_set(cmgd);
1196 if(err) {
1197 printf("Error : %d\n", err);
1198 } else {
1199 printf("VoLTE set success\n");
1200 }
1201 }
1202 }
1203 else if(!strncasecmp(cmd, "cmgl", 4)){ // AT+CMGL[=<stat>]
1204 //
1205 char cmgl[128] = {0};
1206 char resp[5*1024] ={0};
1207 if(!strcasecmp(cmd, "cmgl")) { // Get
1208 printf("cmgl : OK\n");
1209
1210 } else {
1211 char *ptr = strstr(cmd, "cmgl,"); // AT+CMGL[=<stat>]
1212 if(ptr != NULL)
1213 {
1214 ptr = strstr(cmd, ",");
1215 ptr++;
1216 memset(cmgl, 0, sizeof(cmgl));
1217 memcpy(cmgl, ptr, strlen(ptr));
1218 printf("0cmgl:%s\n", cmgl);
1219 }
1220
1221 memset(resp, 0, sizeof(resp));
1222 err = mbtk_sms_cmgl_set(cmgl, resp);
1223 if(err) {
1224 printf("Error : %d\n", err);
1225 } else {
1226 // printf("cmgl set success, reg:%s\n",resp);
1227 }
1228 }
1229 }
1230 else if(!strncasecmp(cmd, "csca", 4)){ // AT+CSCA=<number> [,<type>]
1231 //
1232 char csca[128] = {0};
1233 if(!strcasecmp(cmd, "csca")) { // Get
1234 err = mbtk_sms_csca_get(csca);
1235 if(err) {
1236 printf("mbtk_sms_csca_get Error : %d\n", err);
1237 } else {
1238 printf("mbtk_sms_csca_get success\n");
1239 }
1240
1241 } else {
1242 char *ptr = strstr(cmd, ","); // AT+CSCA=<number> [,<type>]
1243 if(ptr != NULL)
1244 {
1245 ptr++;
1246 memset(csca, 0, sizeof(csca));
1247 memcpy(csca, ptr, strlen(ptr));
1248 printf("csca:%s\n", csca);
1249 }
1250
1251 err = mbtk_sms_csca_set(csca);
1252 if(err) {
1253 printf("Error : %d\n", err);
1254 } else {
1255 printf("VoLTE set success\n");
1256 }
1257 }
1258 }
1259 else if(!strncasecmp(cmd, "csmp", 4)){ // AT+CSMP=[<fo>[,<vp>[,<pid>[,<dcs>]]]]
1260 //
1261 char csmp[128] = {0};
1262 if(!strcasecmp(cmd, "csmp")) { // Get
1263 printf("cmgl : OK\n");
1264
1265 } else {
1266 char *ptr = strstr(cmd, ","); // AT+CSMP=[<fo>[,<vp>[,<pid>[,<dcs>]]]]
1267 if(ptr != NULL)
1268 {
1269 ptr++;
1270 memset(csmp, 0, sizeof(csmp));
1271 memcpy(csmp, ptr, strlen(ptr));
1272 printf("csmp:%s\n", csmp);
1273 }
1274
1275 err = mbtk_sms_csmp_set(csmp);
1276 if(err) {
1277 printf("Error : %d\n", err);
1278 } else {
1279 printf("VoLTE set success\n");
1280 }
1281 }
1282 }
1283 else if(!strncasecmp(cmd, "cscb", 4)){ // AT+CSCB=<[<mode>[,<mids>[,<dcss>]]]>
1284 //
1285 char cscb[128] = {0};
1286 if(!strcasecmp(cmd, "cscb")) { // Get
1287 printf("cmgl : OK\n");
1288
1289 } else {
1290 char *ptr = strstr(cmd, ","); // AT+CSCB=<[<mode>[,<mids>[,<dcss>]]]>
1291 if(ptr != NULL)
1292 {
1293 ptr++;
1294 memset(cscb, 0, sizeof(cscb));
1295 memcpy(cscb, ptr, strlen(ptr));
1296 printf("cscb:%s\n", cscb);
1297 }
1298
1299 err = mbtk_sms_cscb_set(cscb);
1300 if(err) {
1301 printf("Error : %d\n", err);
1302 } else {
1303 printf("VoLTE set success\n");
1304 }
1305 }
1306 }
1307#if 0
1308 else if(!strncasecmp(cmd, "shutdown", 8)){
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]1309 if(!strcasecmp(cmd, "shutdown 0")) {
1310 err = mbtk_system_reboot(0);
1311 if(err) {
1312 printf("Error : %d\n", err);
1313 } else {
1314 printf("Success.\n");
1315 }
1316 } else if(!strcasecmp(cmd, "shutdown 1")) {
1317 err = mbtk_system_reboot(1);
1318 if(err) {
1319 printf("Error : %d\n", err);
1320 } else {
1321 printf("Success.\n");
1322 }
1323 } else if(!strcasecmp(cmd, "shutdown 2")) {
1324 err = mbtk_system_reboot(2);
1325 if(err) {
1326 printf("Error : %d\n", err);
1327 } else {
1328 printf("Success.\n");
1329 }
1330 } else {
1331 printf("Error.");
1332 }
1333 } else if(!strncasecmp(cmd, "power_sim", 9)){
1334 if(!strcasecmp(cmd, "power_sim 0")) {
1335 err = mbtk_sim_power_set(0);
1336 if(err) {
1337 printf("Error : %d\n", err);
1338 } else {
1339 printf("Success.\n");
1340 }
1341 } else if(!strcasecmp(cmd, "power_sim 1")) {
1342 err = mbtk_sim_power_set(1);
1343 if(err) {
1344 printf("Error : %d\n", err);
1345 } else {
1346 printf("Success.\n");
1347 }
1348 } else {
1349 printf("Error.");
1350 }
1351 } else if(!strncasecmp(cmd, "time", 4)){
1352 if(!strcasecmp(cmd, "time 0")) {
1353 err = mbtk_time_set(info_handle, 0, NULL);
1354 if(err) {
1355 printf("Error : %d\n", err);
1356 } else {
1357 printf("Success.\n");
1358 }
1359 } else if(!strcasecmp(cmd, "time 1")) {
1360 err = mbtk_time_set(info_handle, 1, NULL);
1361 if(err) {
1362 printf("Error : %d\n", err);
1363 } else {
1364 printf("Success.\n");
1365 }
1366 } else if(!strncasecmp(cmd, "time 2 ", 7)) {
1367 err = mbtk_time_set(info_handle, 2, cmd + 7);
1368 if(err) {
1369 printf("Error : %d\n", err);
1370 } else {
1371 printf("Success.\n");
1372 }
1373 } else { // Get time type.
1374 int time_type;
1375 err = mbtk_time_get(info_handle, &time_type);
1376 if(err) {
1377 printf("Error : %d\n", err);
1378 } else {
1379 printf("Time type:%d.\n", time_type);
1380 }
1381 }
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]1382 }
1383#endif
1384 else if(!strcasecmp(cmd, "h") || !strcasecmp(cmd, "help")) {
1385 help();
1386 } else if(!strcasecmp(cmd, "q")) {
1387 mbtk_ril_deinit();
1388 break;
1389 } else {
1390 printf("\n");
1391 }
1392 }
1393 }
1394
1395 thread_exit_with_wait();
1396
1397exit:
1398 mbtk_ril_deinit();
1399
1400 LOG("Client exec complete.");
1401
1402 return 0;
1403}