Gitiles
Code Review Sign In
192.168.1.100 / T108_Public / bcf86c99f1bd133d56f1dd97335e341f446d2606 / . / mbtk / test / libmbtk_ril / mbtk_ril_test.c
blob: 30ad2a1218ed0cb0eadfd5cc0aa90bb019a67d2b [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) {
649 printf("APN : %d, %s, %s\n", apns.apns[i].cid, apn2str(apns.apns[i].ip_type), apns.apns[i].apn);
650 i++;
651 }
652 }
653 } else { // apn <cid> <0/1/2/3> <0/1> <0/1> <apn>
654 mbtk_apn_info_t apn;
655 memset(&apn, 0, sizeof(mbtk_apn_info_t));
656#if 1
b.liubcf86c92024-08-19 19:48:28 +0800[diff] [blame^]657 int cid, ip_type, auto_save, auto_boot_call, def_route, as_dns;
658 int count = sscanf(cmd, "apn %d %d %d %d %d %d %s",
659 &cid, &ip_type, &auto_save, &auto_boot_call,
660 &def_route, &as_dns, apn.apn);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]661
662 // Delete APN
663 if(strcmp(apn.apn,"null") == 0 || strcmp(apn.apn,"NULL") == 0) {
664 memset(apn.apn, 0, sizeof(apn.apn));
665 }
b.liubcf86c92024-08-19 19:48:28 +0800[diff] [blame^]666 if(count == 7) {
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]667 apn.cid = (mbtk_ril_cid_enum)cid;
668 apn.ip_type = (mbtk_ip_type_enum)ip_type;
669 apn.auto_save = (uint8)auto_save;
670 apn.auto_boot_call = (uint8)auto_boot_call;
b.liubcf86c92024-08-19 19:48:28 +0800[diff] [blame^]671 apn.def_route = (uint8)def_route;
672 apn.as_dns = (uint8)as_dns;
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]673 }
674#else
675 char *ptr = strstr(cmd, " ");
676 if(ptr == NULL)
677 continue;
678 while(*ptr != '\0' && *ptr == ' ')
679 ptr++;
680 apn.cid = (mbtk_ril_cid_enum)atoi(ptr);
681
682 ptr = strstr(ptr, " ");
683 if(ptr == NULL)
684 continue;
685 while(*ptr != '\0' && *ptr == ' ')
686 ptr++;
687 apn.ip_type = (mbtk_ip_type_enum)atoi(ptr);
688
689 ptr = strstr(ptr, " ");
690 if(ptr == NULL)
691 continue;
692 while(*ptr != '\0' && *ptr == ' ')
693 ptr++;
694 memcpy(apn.apn, ptr, strlen(ptr));
695#endif
696 err = mbtk_apn_set(&apn);
697 if(err != MBTK_RIL_ERR_SUCCESS) {
698 printf("Error : %d\n", err);
699 } else {
700 printf("APN set success\n");
701 }
702 }
703 }
b.liubcf86c92024-08-19 19:48:28 +0800[diff] [blame^]704 else if(!strncasecmp(cmd, "data_call", 9)){ // data_call <0/1/2> <cid> <timeout>
705 // mbtk_ril_cid_enum cid, bool auto_boot_call, bool def_route, int retry_interval, int timeout, mbtk_ip_info_t *rsp_info
706 // data_call <0/1/2> <cid> <timeout>
707 int type, cid, auto_boot_call, def_route, as_dns;
708 int count = sscanf(cmd, "data_call %d %d %d %d %d", &type, &cid, &auto_boot_call, &def_route, &as_dns);
709 if(count != 5) {
710 count = sscanf(cmd, "data_call %d %d", &type, &cid);
711 }
712
713 if(count == 5 || count == 2) {
714 mbtk_ip_info_t ip;
715 memset(&ip, 0, sizeof(mbtk_ip_info_t));
716 if(type == MBTK_DATA_CALL_START) {
717 err = mbtk_data_call_start((mbtk_ril_cid_enum)cid, (bool)auto_boot_call, (bool)def_route, (bool)as_dns, 10, 10, &ip);
718 } else if(type == MBTK_DATA_CALL_STOP) {
719 err = mbtk_data_call_stop((mbtk_ril_cid_enum)cid, 10);
720 } else {
721 err = mbtk_data_call_state_get((mbtk_ril_cid_enum)cid, &ip);
722 }
723 if(err) {
724 printf("Error : %d\n", err);
725 } else {
726 printf("DATA_CALL success\n");
727 if(type == MBTK_DATA_CALL_START || type == MBTK_DATA_CALL_STATE) {
728 if(ip.ipv4.valid) {
729 // log_hex("IPv4", &ipv4, sizeof(mbtk_ipv4_info_t));
730 char ip_tmp[20];
731
732 memset(ip_tmp, 0, 20);
733 if(inet_ntop(AF_INET, &(ip.ipv4.IPAddr), ip_tmp, 20) == NULL) {
734 printf("IP error.\n");
735 } else {
736 printf("IP : %s\n", ip_tmp);
737 }
738
739 memset(ip_tmp, 0, 20);
740 if(inet_ntop(AF_INET, &(ip.ipv4.PrimaryDNS), ip_tmp, 20) == NULL) {
741 printf("PrimaryDNS error.\n");
742 } else {
743 printf("PrimaryDNS : %s\n", ip_tmp);
744 }
745
746 memset(ip_tmp, 0, 20);
747 if(inet_ntop(AF_INET, &(ip.ipv4.SecondaryDNS), ip_tmp, 20) == NULL) {
748 printf("SecondaryDNS error.\n");
749 } else {
750 printf("SecondaryDNS : %s\n", ip_tmp);
751 }
752
753 memset(ip_tmp, 0, 20);
754 if(inet_ntop(AF_INET, &(ip.ipv4.GateWay), ip_tmp, 20) == NULL) {
755 printf("GateWay error.\n");
756 } else {
757 printf("GateWay : %s\n", ip_tmp);
758 }
759
760 memset(ip_tmp, 0, 20);
761 if(inet_ntop(AF_INET, &(ip.ipv4.NetMask), ip_tmp, 20) == NULL) {
762 printf("NetMask error.\n");
763 } else {
764 printf("NetMask : %s\n", ip_tmp);
765 }
766 }
767
768 if(ip.ipv6.valid) {
769 // log_hex("IPv6", &ipv6, sizeof(mbtk_ipv6_info_t));
770 char ip_tmp[50];
771
772 memset(ip_tmp, 0, 50);
773 if(ipv6_2_str(&(ip.ipv6.IPV6Addr), ip_tmp)) {
774 printf("IP error.\n");
775 } else {
776 printf("IP : %s\n", ip_tmp);
777 }
778
779 memset(ip_tmp, 0, 50);
780 if(ipv6_2_str(&(ip.ipv6.PrimaryDNS), ip_tmp)) {
781 printf("PrimaryDNS error.\n");
782 } else {
783 printf("PrimaryDNS : %s\n", ip_tmp);
784 }
785
786 memset(ip_tmp, 0, 50);
787 if(ipv6_2_str(&(ip.ipv6.SecondaryDNS), ip_tmp)) {
788 printf("SecondaryDNS error.\n");
789 } else {
790 printf("SecondaryDNS : %s\n", ip_tmp);
791 }
792
793 memset(ip_tmp, 0, 50);
794 if(ipv6_2_str(&(ip.ipv6.GateWay), ip_tmp)) {
795 printf("GateWay error.\n");
796 } else {
797 printf("GateWay : %s\n", ip_tmp);
798 }
799
800 memset(ip_tmp, 0, 50);
801 if(ipv6_2_str(&(ip.ipv6.NetMask), ip_tmp)) {
802 printf("NetMask error.\n");
803 } else {
804 printf("NetMask : %s\n", ip_tmp);
805 }
806 }
807 }
808 }
809 }
810 }
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]811 else if(!strncasecmp(cmd, "cell", 4)){
812 char *ptr = strstr(cmd, ","); //CPMS,ME,ME,ME
813 if(ptr == NULL)
814 {
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]815 mbtk_cell_info_array_t cell;
816 err = mbtk_cell_get(&cell);
817 if(err) {
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]818 printf("Error : %d\n", err);
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]819 } else if(cell.num > 0){
820 // Current server cell.
821 switch(cell.type)
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]822 {
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]823 case MBTK_CELL_TYPE_GSM:
824 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);
825 break;
826 case MBTK_CELL_TYPE_UMTS:
827 printf("UMTS : lac=%d, ci=%d, arfcn=%d\n", cell.cell[0].value1, cell.cell[0].value2, cell.cell[0].value3);
828 break;
829 case MBTK_CELL_TYPE_LTE:
830 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);
831 break;
832 default:
833 break;
834 }
835
836 int i = 1;
837 while (i < cell.num)
838 {
839 switch(cell.type)
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]840 {
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]841 case MBTK_CELL_TYPE_GSM:
842 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]843 break;
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]844 case MBTK_CELL_TYPE_UMTS:
845 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]846 break;
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]847 case MBTK_CELL_TYPE_LTE:
848 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]849 break;
850 default:
851 break;
852 }
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]853 i++;
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]854 }
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]855 } else {
856 printf("Cell no found.");
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]857 }
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]858 }
859 else{
860 char *ptr = strstr(cmd, ","); //cell,2,3,,40936,430
861 char mem[50]={0};
862 char resp[1024] = {0};
863 if(ptr != NULL)
864 {
865 ptr++;
866 memset(mem, 0, sizeof(mem));
867 memcpy(mem, ptr, strlen(ptr));
868 printf("cell:%s\n", mem);
869 }
870 printf("cell_mem: %s \n", mem);
871
872 memset(resp, 0, sizeof(resp));
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]873 err = mbtk_cell_set(mem, resp);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]874 if(err) {
875 printf("Error : %d\n", err);
876 } else {
877 printf("cell set . resp:%s\n", resp);
878 }
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]879 }
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]880 }
881 else if(!strncasecmp(cmd, "call", 4)){
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]882 char phone_number[12];
883 char *ptr = strstr(cmd, " ");
884 if(ptr == NULL)
885 continue;
886 while(*ptr != '\0' && *ptr == ' ')
887 ptr++;
888 memset(phone_number,0,strlen(phone_number));
889 memcpy(phone_number,ptr,strlen(ptr));
890 printf("phone number is: %s\n",phone_number);
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]891 err = mbtk_call_start(phone_number);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]892 if(err) {
893 printf("Error : %d\n", err);
894 } else {
895 printf("Call success.\n");
896 }
897 } else if(!strncasecmp(cmd, "answer", 6)){
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]898 err = mbtk_call_answer();
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, "hangup", 6)){
905 int phone_id;
906 if(!strcasecmp(cmd, "hangup")) { // hang up all
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]907 err = mbtk_call_hang();
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]908 if(err) {
909 printf("Error : %d\n", err);
910 } else {
911 printf("Call hang up all.\n");
912 }
913 } else if(!strcasecmp(cmd, "hangup 0")) {
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]914 err = mbtk_waiting_or_background_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 waiting or background.\n");
919 }
920 } else if(!strcasecmp(cmd, "hangup 3")) {
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]921 err = mbtk_foreground_resume_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 foreground resume background.\n");
926 }
927 } else {
928 if(!strcasecmp(cmd, "hangup 1")) { // hang up a call
929 phone_id = 1;
930 } else if(!strcasecmp(cmd, "hangup 2")) {
931 phone_id = 2;
932 } else {
933 printf("Error : Invalid input\n");
934 }
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]935 err = mbtk_a_call_hang(phone_id);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]936 if(err) {
937 printf("Error : %d\n", err);
938 } else {
939 printf("A Call hang up.\n");
940 }
941 }
942 } else if(!strncasecmp(cmd, "waitin", 6)){
943 mbtk_call_info_t reg;
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]944 err = mbtk_call_reg_get(&reg);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]945 if(err) {
946 printf("Error : %d\n", err);
947 } else {
948 if(reg.call_wait == 0) {
949 printf("No call ring\n");
950 }
951 else {
952 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);
953 }
954 }
955 } else if(!strncasecmp(cmd, "mute", 4)){ // "mute" or "mute 0" or "mute 1"
956 int mute;
957 if(!strcasecmp(cmd, "mute")) { // Get
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]958 err = mbtk_mute_state_get(&mute);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]959 if(err) {
960 printf("Error : %d\n", err);
961 } else {
962 printf("mute : %d\n", mute);
963 }
964 } else { // Set
965 if(!strcasecmp(cmd, "mute 1")) { // on mute
966 mute = 1;
967 } else { // off mute
968 mute = 0;
969 }
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]970 err = mbtk_mute_state_set(mute);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]971 if(err) {
972 printf("Error : %d\n", err);
973 } else {
974 printf("mute set success\n");
975 }
976 }
977 } else if(!strncasecmp(cmd, "DTMF", 4)){ // valid character: (0, 1, ..., 9, A, B, C, D, *, #)
978
979 mbtk_call_dtmf_info_t reg;
980
981 char *ptr = strstr(cmd, " ");
982 if(ptr == NULL)
983 continue;
984 while(*ptr != '\0' && *ptr == ' ')
985 ptr++;
986 reg.character = *ptr;
987
988 ptr = strstr(ptr, " ");
989 if(ptr == NULL)
990 continue;
991 while(*ptr != '\0' && *ptr == ' ')
992 ptr++;
993 reg.duration = (uint32)atoi(ptr);
994 printf("DTMF character is: %c,%d\n",reg.character, reg.duration);
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]995 err = mbtk_dtmf_send(&reg);
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]996 if(err) {
997 printf("Error : %d\n", err);
998 } else {
999 printf("DTMF success.\n");
1000 }
b.liub4772072024-08-15 14:47:03 +0800[diff] [blame]1001 } else if(!strncasecmp(cmd, "cmgf", 4)){ // set mode 0: pud, 1:text
1002 int mode;
1003 if(!strcasecmp(cmd, "cmgf")) { // Get
1004 err = mbtk_sms_cmgf_get(&mode);
1005 if(err) {
1006 printf("Error : %d\n", err);
1007 } else {
1008 printf("VoLTE : %d\n", mode);
1009 }
1010 } else { // Set
1011 if(!strcasecmp(cmd, "cmgf 1")) { // cmgf 1
1012 mode = 1;
1013 } else { //
1014 mode = 0;
1015 }
1016 printf("mode:%d\n", mode);
1017 sleep(2);
1018 err = mbtk_sms_cmgf_set(mode);
1019 if(err) {
1020 printf("Error : %d\n", err);
1021 } else {
1022 printf("VoLTE set success\n");
1023 }
1024 }
1025 }else if(!strncasecmp(cmd, "cpms", 4)){ // //CPMS=ME, ME, ME
1026 char mem[100] = {0};
1027 char resp[100] = {0};
1028 if(!strcasecmp(cmd, "cpms")) { // Get
1029 err = mbtk_sms_cpms_get(&mem);
1030 if(err) {
1031 printf("Error : %d\n", err);
1032 } else {
1033 printf("cpms : %s\n", mem);
1034 }
1035 } else { // Set
1036
1037 char *ptr = strstr(cmd, ","); //CPMS,ME,ME,ME
1038 if(ptr != NULL)
1039 {
1040 ptr++;
1041 memset(mem, 0, sizeof(mem));
1042 memcpy(mem, ptr, strlen(ptr));
1043 printf("cpms:%s\n", mem);
1044 }
1045 printf("cpms 0\n");
1046
1047 memset(resp, 0, sizeof(resp));
1048 err = mbtk_sms_cpms_set(mem, resp);
1049 if(err) {
1050 printf("Error : %d\n", err);
1051 } else {
1052 printf("cpms set success. resp:%s\n", resp);
1053 }
1054 }
1055 }else if(!strncasecmp(cmd, "cmgs", 4)){ // AT+CMGS="10086", CMGS TEST
1056 char cmgs[1024] = {0};
1057 char resp[50] = {0};
1058 if(!strcasecmp(cmd, "cmgs")) { // Get
1059 int mode;
1060 // err = mbtk_sms_cmgs_get(info_handle, &mode);
1061 if(err) {
1062 printf("Error : %d\n", err);
1063 } else {
1064 printf("VoLTE : %d\n", mode);
1065 }
1066 } else { // Set
1067
1068 /*
1069 *AT+CMGS="10086", CMGS TEST // Send a SMS
1070 > CMGS TEST
1071 +CMGS: 17
1072 OK
1073 */
1074
1075 char *ptr = strstr(cmd, "cmgs,"); //CMGS="10086",hf
1076 if(ptr != NULL)
1077 {
1078 ptr = strstr(cmd, ",");
1079 ptr++;
1080 memset(cmgs, 0, sizeof(cmgs));
1081 memcpy(cmgs, ptr, strlen(ptr));
1082 printf("1cmgs:%s, strlen(cmgs):%d\n", cmgs, strlen(cmgs));
1083 }
1084
1085 memset(resp, 0, sizeof(resp));
1086 err = mbtk_sms_cmgs_set(cmgs, resp);
1087 if(err) {
1088 printf("Error : %d\n", err);
1089 } else {
1090 printf("cmgs set success . resp:%s\n", resp);
1091 }
1092 }
1093 }else if(!strncasecmp(cmd, "cmss", 4)){ // +CMSS=<index>[,<da>[,<toda>]]
1094 char cmss[20] = {0};
1095 char resp[20] = {0};
1096 if(!strcasecmp(cmd, "cmgs")) { // Get
1097 printf("cmss : OK\n");
1098
1099 } else {
1100 char *ptr = strstr(cmd, "cmss,"); //CMSS=<index>
1101 if(ptr != NULL)
1102 {
1103 ptr = strstr(cmd, ",");
1104 ptr++;
1105 memset(cmss, 0, sizeof(cmss));
1106 memcpy(cmss, ptr, strlen(ptr));
1107 printf("1cmss:%s\n", cmss);
1108 }
1109
1110
1111 err = mbtk_sms_cmss_set(cmss, resp);
1112 if(err) {
1113 printf("Error : %d\n", err);
1114 } else {
1115 printf("cmss set success. resp:%s\n", resp);
1116 }
1117 }
1118 }
1119 else if(!strncasecmp(cmd, "cmgr", 4)){ // +CMGR=<index
1120 int index = 0;
1121 char resp[1024] = {0};
1122 if(!strcasecmp(cmd, "cmgr")) { // Get
1123 printf("cmgr : OK\n");
1124
1125 } else {
1126 char *ptr = strstr(cmd, "cmgr,"); //+CMGR <index>
1127 if(ptr != NULL)
1128 {
1129 ptr = strstr(cmd, ",");
1130 ptr++;
1131 index = atoi(ptr);
1132 }
1133 printf("1index:%d\n", index);
1134
1135 memset(resp, 0, sizeof(resp));
1136 err = mbtk_sms_cmgr_set(index, resp);
1137 if(err) {
1138 printf("Error : %d\n", err);
1139 } else {
1140 printf("cmgr set success. rep:%s\n", resp);
1141 }
1142 }
1143 }
1144 else if(!strncasecmp(cmd, "cmgw", 4)){ // +CMGW=<oa/da>[,<tooa/toda>[,<stat>]]<CR>
1145 //+CMGW=<length>[,<stat>]<CR>PDU is given<ctrl-Z/ESC>
1146 char cmgw[128] = {0};
1147 char resp[50] = {0};
1148 if(!strcasecmp(cmd, "cmgw")) { // Get
1149 printf("cmgw : OK\n");
1150
1151 } else {
1152 char *ptr = strstr(cmd, "cmgw,"); //+CMGW, <oa/da>, data
1153 if(ptr != NULL)
1154 {
1155 ptr = strstr(cmd, ",");
1156 ptr++;
1157 memset(cmgw, 0, sizeof(cmgw));
1158 memcpy(cmgw, ptr, strlen(ptr));
1159 printf("cmgw:%s\n", cmgw);
1160 }
1161
1162 memset(resp, 0, sizeof(resp));
1163 err = mbtk_sms_cmgw_set(cmgw, resp);
1164 if(err) {
1165 printf("Error : %d\n", err);
1166 } else {
1167 printf("cmgw set success. resp:%s\n", resp);
1168 }
1169 }
1170 }
1171 else if(!strncasecmp(cmd, "cmgd", 4)){ // +CMGD=<index>[,<delflag>
1172 //
1173 char cmgd[128] = {0};
1174 if(!strcasecmp(cmd, "cmgd")) { // Get
1175 printf("cmgd : OK\n");
1176
1177 } else {
1178 char *ptr = strstr(cmd, ","); //+CMGD=<index>[,<delflag>
1179 if(ptr != NULL)
1180 {
1181 ptr++;
1182 memset(cmgd, 0, sizeof(cmgd));
1183 memcpy(cmgd, ptr, strlen(ptr));
1184 printf("1cmgd:%s\n", cmgd);
1185 }
1186
1187
1188 err = mbtk_sms_cmgd_set(cmgd);
1189 if(err) {
1190 printf("Error : %d\n", err);
1191 } else {
1192 printf("VoLTE set success\n");
1193 }
1194 }
1195 }
1196 else if(!strncasecmp(cmd, "cmgl", 4)){ // AT+CMGL[=<stat>]
1197 //
1198 char cmgl[128] = {0};
1199 char resp[5*1024] ={0};
1200 if(!strcasecmp(cmd, "cmgl")) { // Get
1201 printf("cmgl : OK\n");
1202
1203 } else {
1204 char *ptr = strstr(cmd, "cmgl,"); // AT+CMGL[=<stat>]
1205 if(ptr != NULL)
1206 {
1207 ptr = strstr(cmd, ",");
1208 ptr++;
1209 memset(cmgl, 0, sizeof(cmgl));
1210 memcpy(cmgl, ptr, strlen(ptr));
1211 printf("0cmgl:%s\n", cmgl);
1212 }
1213
1214 memset(resp, 0, sizeof(resp));
1215 err = mbtk_sms_cmgl_set(cmgl, resp);
1216 if(err) {
1217 printf("Error : %d\n", err);
1218 } else {
1219 // printf("cmgl set success, reg:%s\n",resp);
1220 }
1221 }
1222 }
1223 else if(!strncasecmp(cmd, "csca", 4)){ // AT+CSCA=<number> [,<type>]
1224 //
1225 char csca[128] = {0};
1226 if(!strcasecmp(cmd, "csca")) { // Get
1227 err = mbtk_sms_csca_get(csca);
1228 if(err) {
1229 printf("mbtk_sms_csca_get Error : %d\n", err);
1230 } else {
1231 printf("mbtk_sms_csca_get success\n");
1232 }
1233
1234 } else {
1235 char *ptr = strstr(cmd, ","); // AT+CSCA=<number> [,<type>]
1236 if(ptr != NULL)
1237 {
1238 ptr++;
1239 memset(csca, 0, sizeof(csca));
1240 memcpy(csca, ptr, strlen(ptr));
1241 printf("csca:%s\n", csca);
1242 }
1243
1244 err = mbtk_sms_csca_set(csca);
1245 if(err) {
1246 printf("Error : %d\n", err);
1247 } else {
1248 printf("VoLTE set success\n");
1249 }
1250 }
1251 }
1252 else if(!strncasecmp(cmd, "csmp", 4)){ // AT+CSMP=[<fo>[,<vp>[,<pid>[,<dcs>]]]]
1253 //
1254 char csmp[128] = {0};
1255 if(!strcasecmp(cmd, "csmp")) { // Get
1256 printf("cmgl : OK\n");
1257
1258 } else {
1259 char *ptr = strstr(cmd, ","); // AT+CSMP=[<fo>[,<vp>[,<pid>[,<dcs>]]]]
1260 if(ptr != NULL)
1261 {
1262 ptr++;
1263 memset(csmp, 0, sizeof(csmp));
1264 memcpy(csmp, ptr, strlen(ptr));
1265 printf("csmp:%s\n", csmp);
1266 }
1267
1268 err = mbtk_sms_csmp_set(csmp);
1269 if(err) {
1270 printf("Error : %d\n", err);
1271 } else {
1272 printf("VoLTE set success\n");
1273 }
1274 }
1275 }
1276 else if(!strncasecmp(cmd, "cscb", 4)){ // AT+CSCB=<[<mode>[,<mids>[,<dcss>]]]>
1277 //
1278 char cscb[128] = {0};
1279 if(!strcasecmp(cmd, "cscb")) { // Get
1280 printf("cmgl : OK\n");
1281
1282 } else {
1283 char *ptr = strstr(cmd, ","); // AT+CSCB=<[<mode>[,<mids>[,<dcss>]]]>
1284 if(ptr != NULL)
1285 {
1286 ptr++;
1287 memset(cscb, 0, sizeof(cscb));
1288 memcpy(cscb, ptr, strlen(ptr));
1289 printf("cscb:%s\n", cscb);
1290 }
1291
1292 err = mbtk_sms_cscb_set(cscb);
1293 if(err) {
1294 printf("Error : %d\n", err);
1295 } else {
1296 printf("VoLTE set success\n");
1297 }
1298 }
1299 }
1300#if 0
1301 else if(!strncasecmp(cmd, "shutdown", 8)){
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]1302 if(!strcasecmp(cmd, "shutdown 0")) {
1303 err = mbtk_system_reboot(0);
1304 if(err) {
1305 printf("Error : %d\n", err);
1306 } else {
1307 printf("Success.\n");
1308 }
1309 } else if(!strcasecmp(cmd, "shutdown 1")) {
1310 err = mbtk_system_reboot(1);
1311 if(err) {
1312 printf("Error : %d\n", err);
1313 } else {
1314 printf("Success.\n");
1315 }
1316 } else if(!strcasecmp(cmd, "shutdown 2")) {
1317 err = mbtk_system_reboot(2);
1318 if(err) {
1319 printf("Error : %d\n", err);
1320 } else {
1321 printf("Success.\n");
1322 }
1323 } else {
1324 printf("Error.");
1325 }
1326 } else if(!strncasecmp(cmd, "power_sim", 9)){
1327 if(!strcasecmp(cmd, "power_sim 0")) {
1328 err = mbtk_sim_power_set(0);
1329 if(err) {
1330 printf("Error : %d\n", err);
1331 } else {
1332 printf("Success.\n");
1333 }
1334 } else if(!strcasecmp(cmd, "power_sim 1")) {
1335 err = mbtk_sim_power_set(1);
1336 if(err) {
1337 printf("Error : %d\n", err);
1338 } else {
1339 printf("Success.\n");
1340 }
1341 } else {
1342 printf("Error.");
1343 }
1344 } else if(!strncasecmp(cmd, "time", 4)){
1345 if(!strcasecmp(cmd, "time 0")) {
1346 err = mbtk_time_set(info_handle, 0, NULL);
1347 if(err) {
1348 printf("Error : %d\n", err);
1349 } else {
1350 printf("Success.\n");
1351 }
1352 } else if(!strcasecmp(cmd, "time 1")) {
1353 err = mbtk_time_set(info_handle, 1, NULL);
1354 if(err) {
1355 printf("Error : %d\n", err);
1356 } else {
1357 printf("Success.\n");
1358 }
1359 } else if(!strncasecmp(cmd, "time 2 ", 7)) {
1360 err = mbtk_time_set(info_handle, 2, cmd + 7);
1361 if(err) {
1362 printf("Error : %d\n", err);
1363 } else {
1364 printf("Success.\n");
1365 }
1366 } else { // Get time type.
1367 int time_type;
1368 err = mbtk_time_get(info_handle, &time_type);
1369 if(err) {
1370 printf("Error : %d\n", err);
1371 } else {
1372 printf("Time type:%d.\n", time_type);
1373 }
1374 }
b.liu87afc4c2024-08-14 17:33:45 +0800[diff] [blame]1375 }
1376#endif
1377 else if(!strcasecmp(cmd, "h") || !strcasecmp(cmd, "help")) {
1378 help();
1379 } else if(!strcasecmp(cmd, "q")) {
1380 mbtk_ril_deinit();
1381 break;
1382 } else {
1383 printf("\n");
1384 }
1385 }
1386 }
1387
1388 thread_exit_with_wait();
1389
1390exit:
1391 mbtk_ril_deinit();
1392
1393 LOG("Client exec complete.");
1394
1395 return 0;
1396}