add ds_mbtk api test
Change-Id: Ie4b889d751661f2a0cf2f0b33ed1304d677c79ea
diff --git a/mbtk/test/libmbtk_ril/Makefile b/mbtk/test/libmbtk_ril/Makefile
index c7011aa..e2d54c2 100755
--- a/mbtk/test/libmbtk_ril/Makefile
+++ b/mbtk/test/libmbtk_ril/Makefile
@@ -14,6 +14,7 @@
#LOCAL_SRC_FILES = $(wildcard *.c) $(wildcard *.cpp)
ifeq ($(MBTK_SOURCE_VERSION), 2)
LOCAL_SRC_FILES = mbtk_ril_test.c
+LOCAL_SRC_FILES = mbtk_ds_ril_test.c
else
LOCAL_SRC_FILES = mbtk_info_test.c
endif
diff --git a/mbtk/test/libmbtk_ril/mbtk_ds_ril_test.c b/mbtk/test/libmbtk_ril/mbtk_ds_ril_test.c
new file mode 100755
index 0000000..e5f9dab
--- /dev/null
+++ b/mbtk/test/libmbtk_ril/mbtk_ds_ril_test.c
@@ -0,0 +1,1905 @@
+/*-----------------------------------------------------------------------------------------------*/
+/**
+ @file mbtk_ds_ril_test.c
+ @brief MBTK DS API TEST
+*/
+/*-----------------------------------------------------------------------------------------------*/
+
+/*-------------------------------------------------------------------------------------------------
+ Copyright (c) 2024 mobiletek Wireless Solution, Co., Ltd. All Rights Reserved.
+ mobiletek Wireless Solution Proprietary and Confidential.
+-------------------------------------------------------------------------------------------------*/
+
+/*-------------------------------------------------------------------------------------------------
+ EDIT HISTORY
+ This section contains comments describing changes made to the file.
+ Notice that changes are listed in reverse chronological order.
+ $Header: $
+ when who what, where, why
+ -------- --------- -----------------------------------------------------------------
+ 20250425 yq.wang Created .
+-------------------------------------------------------------------------------------------------*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <dlfcn.h>
+#include <stdint.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+#include <sys/epoll.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <arpa/inet.h>
+
+#include "mbtk_log.h"
+#include "mbtk_ril_api.h"
+#include "mbtk_str.h"
+
+#define BUF_SIZE_128 128
+#define BUF_SIZE_1024 1024
+
+typedef void (*cmd_func)(void);
+
+typedef struct
+{
+ const char *funcName;
+ cmd_func excute_func;
+} api_test_info_t;
+
+static void item_mbtk_ril_close(void);
+static void item_print_help(void);
+static void item_exit(void);
+
+static int cases_count = 0;
+static mbtk_ril_handle* handle_def = NULL;
+static mbtk_ril_handle* handle_data = NULL;
+static mbtk_ril_handle* handle_voice = NULL;
+
+static void item_sim_type_printf(mbtk_sim_type_enum *sim_id)
+{
+ char cmd[BUF_SIZE_128 + 1] = {0};
+ printf("please input sim type([0: sim1] [1: sim2] [255: sim_auto]):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ *sim_id = (mbtk_sim_type_enum)atoi(cmd);
+}
+
+static void item_mbtk_ril_open(void)
+{
+ if(NULL == handle_def)
+ {
+ handle_def = mbtk_ril_open(MBTK_AT_PORT_DEF);
+ if(NULL == handle_def)
+ {
+ printf("mbtk_ril_open(MBTK_AT_PORT_DEF) fail.\n");
+ goto error;
+ }
+ }
+
+ if(NULL == handle_data)
+ {
+ handle_data = mbtk_ril_open(MBTK_AT_PORT_DATA);
+ if(NULL == handle_data)
+ {
+ printf("mbtk_ril_open(MBTK_AT_PORT_DATA) fail.\n");
+ goto error;
+ }
+ }
+
+ if(NULL == handle_voice)
+ {
+ handle_voice = mbtk_ril_open(MBTK_AT_PORT_VOICE);
+ if(NULL == handle_voice)
+ {
+ printf("mbtk_ril_open(MBTK_AT_PORT_VOICE) fail.\n");
+ goto error;
+ }
+ }
+
+ printf("mbtk_ril_open() success.\n");
+ return;
+error:
+ item_mbtk_ril_close();
+}
+
+static void item_mbtk_ril_close(void)
+{
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ if(handle_def)
+ {
+ ret = mbtk_ril_close(MBTK_AT_PORT_DEF);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ril_close(MBTK_AT_PORT_DEF) fail.[%d]\n", ret);
+ return;
+ }
+ handle_def = NULL;
+ }
+
+ if(handle_data)
+ {
+ ret = mbtk_ril_close(MBTK_AT_PORT_DATA);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ril_close(MBTK_AT_PORT_DATA) fail.[%d]\n", ret);
+ return;
+ }
+ handle_data = NULL;
+ }
+
+ if(handle_voice)
+ {
+ ret = mbtk_ril_close(MBTK_AT_PORT_VOICE);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ril_close(MBTK_AT_PORT_VOICE) fail.[%d]\n", ret);
+ return;
+ }
+ handle_voice = NULL;
+ }
+
+ printf("mbtk_ril_close() success.\n");
+}
+
+static void item_mbtk_version_get(void)
+{
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char version[BUF_SIZE_128] = {0};
+
+ memset(version, 0x00, BUF_SIZE_128);
+ ret = mbtk_version_get(handle_def, version);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_version_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("version: [%s]\n", version);
+ }
+}
+
+static void item_mbtk_ds_model_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char model[BUF_SIZE_128] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(model, 0x00, BUF_SIZE_128);
+ ret = mbtk_ds_model_get(handle_def, sim_id, model);;
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_model_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("model: [%s]\n", model);
+ }
+}
+
+static void item_mbtk_ds_radio_state_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_radio_state_enum radio_state = MBTK_RADIO_STATE_UNKNOWN;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+
+ item_sim_type_printf(&sim_id);
+
+ ret = mbtk_ds_radio_state_get(handle_def, sim_id, &radio_state);;
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_radio_state_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("radio_state: [%d]\n", radio_state);
+ }
+}
+
+static void item_mbtk_ds_radio_state_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ int reset_modem = 0;
+ mbtk_radio_state_enum radio_state = MBTK_RADIO_STATE_UNKNOWN;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char cmd[BUF_SIZE_128 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("exampl <radio_state----->-<reset_modem-->\n");
+ printf("exampl ([0: MINI] [1: FULL])-([0: NO] [1: YES])\n");
+ printf("please input param:\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ ret = sscanf(cmd, "%d %d", &radio_state, &reset_modem);
+
+ ret = mbtk_ds_radio_state_set(handle_def, sim_id, radio_state, reset_modem == 1 ? true : false);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_radio_state_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_radio_state_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_cell_time_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char cell_time[BUF_SIZE_128] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(cell_time, 0x00, BUF_SIZE_128);
+ ret = mbtk_ds_cell_time_get(handle_def, sim_id, cell_time);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_cell_time_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("cell_time: [%s]\n", cell_time);
+ }
+}
+
+static void item_mbtk_ds_sim_state_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_sim_state_enum sim_state = MBTK_SIM_STATE_UNKNOWN;
+
+ item_sim_type_printf(&sim_id);
+
+ ret = mbtk_ds_sim_state_get(handle_def, sim_id, &sim_state);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sim_state_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("sim_state: [%d]\n", sim_state);
+ }
+}
+
+static void item_mbtk_ds_sim_type_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_sim_card_type_enum sim_card_type = MBTK_UNKNOWN;
+
+ item_sim_type_printf(&sim_id);
+
+ ret = mbtk_ds_sim_type_get(handle_def, sim_id, &sim_card_type);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sim_type_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("sim_card_type: [%d]\n", sim_card_type);
+ }
+}
+
+static void item_mbtk_ds_imsi_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char imsi[BUF_SIZE_128] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(imsi, 0x00, BUF_SIZE_128);
+ ret = mbtk_ds_imsi_get(handle_def, sim_id, imsi);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_imsi_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("imsi: [%s]\n", imsi);
+ }
+}
+
+static void item_mbtk_ds_iccid_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char iccid[BUF_SIZE_128] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(iccid, 0x00, BUF_SIZE_128);
+ ret = mbtk_ds_iccid_get(handle_def, sim_id, iccid);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_iccid_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("iccid: [%s]\n", iccid);
+ }
+}
+
+static void item_mbtk_ds_phone_number_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char phone_number[BUF_SIZE_128] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(phone_number, 0x00, BUF_SIZE_128);
+ ret = mbtk_ds_phone_number_get(handle_def, sim_id, phone_number);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_phone_number_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("phone_number: [%s]\n", phone_number);
+ }
+}
+
+static void item_mbtk_ds_sim_lock_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ int lock_state = 0;
+
+ item_sim_type_printf(&sim_id);
+
+ ret = mbtk_ds_sim_lock_get(handle_def, sim_id, &lock_state);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sim_lock_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("lock_state: [%d]\n", lock_state);
+ }
+}
+
+static void item_mbtk_ds_sim_lock_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_sim_lock_info_t lock_info = {0};
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+ int type = 0;
+
+ item_sim_type_printf(&sim_id);
+
+ printf("exampl <lock_type>-<pin1>-<pin2>-<puk>\n");
+ printf("lock_type ([0: DISABLE] [1: ENABLE] [3: CHANGE] [4: VERIFY_PIN] [5: VERIFY_PUK])\n");
+ printf("please input param:\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ memset(&lock_info, 0x00, sizeof(mbtk_sim_lock_info_t));
+ ret = sscanf(cmd, "%d %s %s %s", &type, lock_info.pin1, lock_info.pin2, lock_info.puk);
+ lock_info.type = (mbtk_sim_lock_type_enum)type;
+
+ ret = mbtk_ds_sim_lock_set(handle_def, sim_id, &lock_info);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sim_lock_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_sim_lock_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_sim_lock_retry_times_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_pin_puk_last_times_t retry_times = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(&retry_times, 0x00, sizeof(mbtk_pin_puk_last_times_t));
+ ret = mbtk_ds_sim_lock_retry_times_get(handle_def, sim_id, &retry_times);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sim_lock_retry_times_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("p1_retry: [%d], p2_retry: [%d], puk1_retry: [%d], puk2_retry: [%d]\n", retry_times.p1_retry, retry_times.p2_retry, retry_times.puk1_retry, retry_times.puk2_retry);
+ }
+}
+
+static void item_mbtk_ds_plmn_list_get(void)
+{
+ int i = 0;
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_plmn_info plmn_list = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(&plmn_list, 0x00, sizeof(mbtk_plmn_info));
+ ret = mbtk_ds_plmn_list_get(handle_def, sim_id, &plmn_list);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_plmn_list_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ for(i = 0; i < plmn_list.count; i++)
+ {
+ printf("format: [%d], plmn: [%s]\n", plmn_list.plmn[i].format, plmn_list.plmn[i].name);
+ }
+ }
+}
+
+static void item_mbtk_ds_available_net_get(void)
+{
+ int i = 0;
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_net_info_array_t net_array = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(&net_array, 0x00, sizeof(mbtk_net_info_array_t));
+ ret = mbtk_ds_available_net_get(handle_def, sim_id, &net_array);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_available_net_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ for(i = 0; i < net_array.num; i++)
+ {
+ printf("net_sel_mode: [%d], net_type: [%d], net_state: [%d], plmn: [%d]\n", net_array.net_info[i].net_sel_mode,
+ net_array.net_info[i].net_type,
+ net_array.net_info[i].net_state,
+ net_array.net_info[i].plmn);
+ }
+ }
+}
+
+static void item_mbtk_ds_net_sel_mode_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_net_info_t net = {0};
+ char cmd[BUF_SIZE_128 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("exampl <net_sel_mode>-<net_type>-<net_state>-<plmn>\n");
+ printf("net_sel_mode ([0: automativ] [1: manual])\n");
+ printf("net_type ([0: GSM] [1: GSM Compact] [2: UTRAN] [3: GSM w/EGPRS] [4: UTRAN w/HSDPA])\n");
+ printf(" ([5: UTRAN w/HSDPA] [6: UTRAN w/HSDUPA] [7: E-UTRAN] [8: UTRAN HSPA+])\n");
+ printf("net_state ([0: unknown] [1: available] [2: current] [3: forbidden])\n");
+ printf("please input param:\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ memset(&net, 0x00, sizeof(mbtk_net_info_t));
+ ret = sscanf(cmd, "%hhd %hhd %hhd %d", &(net.net_sel_mode), &(net.net_type), &(net.net_state), &(net.plmn));
+
+ ret = mbtk_ds_net_sel_mode_set(handle_def, sim_id, &net);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_net_sel_mode_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_net_sel_mode_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_net_sel_mode_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_net_info_t net = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(&net, 0x00, sizeof(mbtk_net_info_t));
+ ret = mbtk_ds_net_sel_mode_get(handle_def, sim_id, &net);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_net_sel_mode_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("net_sel_mode: [%d], net_type: [%d], net_state: [%d], plmn: [%d]\n", net.net_sel_mode, net.net_type, net.net_state, net.plmn);
+ }
+}
+
+static void item_mbtk_ds_current_band_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_band_info_t band = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(&band, 0x00, sizeof(mbtk_band_info_t));
+ ret = mbtk_ds_current_band_get(handle_def, sim_id, &band);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_current_band_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("net_pref: [%d], gsm_band: [%d], umts_band: [%d], tdlte_band: [%d], fddlte_band: [%d], lte_ext_band: [%d]\n", band.net_pref, band.gsm_band,
+ band.umts_band, band.tdlte_band,
+ band.fddlte_band, band.lte_ext_band);
+ printf("nr_3_band: [%d], nr_2_band: [%d], nr_1_band: [%d], nr_0_band: [%d]\n", band.nr_3_band, band.nr_2_band, band.nr_1_band, band.nr_0_band);
+ }
+}
+
+static void item_mbtk_ds_current_band_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_band_info_t band = {0};
+ char cmd[BUF_SIZE_128 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("exampl <net_pref>-<gsm_band>-<umts_band>-<tdlte_band>-<fddlte_band>-<lte_ext_band>-<nr_3_band>-<nr_2_band>-<nr_1_band>-<nr_0_band>\n");
+ printf("please input param:\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ memset(&band, 0x00, sizeof(mbtk_band_info_t));
+ ret = sscanf(cmd, "%d %d %d %d %d %d %d %d %d %d", &(band.net_pref), &(band.gsm_band), &(band.umts_band), &(band.tdlte_band), &(band.fddlte_band), &(band.lte_ext_band),
+ &(band.nr_3_band), &(band.nr_2_band), &(band.nr_1_band), &(band.nr_0_band));
+
+ ret = mbtk_ds_current_band_set(handle_def, sim_id, &band);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_current_band_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_current_band_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_cell_get(void)
+{
+ int i = 0;
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_cell_info_array_t cell_array = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(&cell_array, 0x00, sizeof(mbtk_cell_info_array_t));
+ ret = mbtk_ds_cell_get(handle_def, sim_id, &cell_array);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_cell_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("type [%d]:\n", cell_array.type);
+ for(i = 0; i < cell_array.num; i++)
+ {
+ printf("value[%d]: [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%lld] [%lld] [%lld] [%lld] [%lld]\n", i, cell_array.cell[i].value1, cell_array.cell[i].value2,
+ cell_array.cell[i].value3, cell_array.cell[i].value4,
+ cell_array.cell[i].value5, cell_array.cell[i].value6,
+ cell_array.cell[i].value7, cell_array.cell[i].value8,
+ cell_array.cell[i].value9, cell_array.cell[i].value10,
+ cell_array.cell[i].value11, cell_array.cell[i].value12,
+ cell_array.cell[i].value13, cell_array.cell[i].value14,
+ cell_array.cell[i].value15, cell_array.cell[i].value64_1,
+ cell_array.cell[i].value64_2, cell_array.cell[i].value64_3,
+ cell_array.cell[i].value64_4, cell_array.cell[i].value64_5);
+ }
+ }
+}
+
+static void item_mbtk_ds_cell_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char cmd[BUF_SIZE_128 + 1] = {0};
+ char response[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("exampl 2,3,,40936,430\n");
+ printf("please input param:\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+
+ memset(response, 0x00, BUF_SIZE_1024 + 1);
+ ret = mbtk_ds_cell_set(handle_def, sim_id, cmd, response);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_cell_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("response: [%s]\n", response);
+ }
+}
+
+static void item_mbtk_ds_net_signal_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_signal_info_t signal = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(&signal, 0x00, sizeof(mbtk_signal_info_t));
+ ret = mbtk_ds_net_signal_get(handle_def, sim_id, &signal);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_net_signal_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("type: [%d], rssi: [%d], rxlev: [%d], ber: [%d], rscp: [%d], ecno: [%d], rsrq: [%d], rsrp: [%d], ss_rsrq: [%d], ss_rsrp: [%d], ss_sinr: [%d]\n",
+ signal.type, signal.rssi, signal.rxlev, signal.ber, signal.rscp, signal.ecno, signal.rsrq, signal.rsrp, signal.ss_rsrq, signal.ss_rsrp, signal.ss_sinr);
+ }
+}
+
+static void item_mbtk_ds_net_reg_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_net_reg_info_t reg = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(®, 0x00, sizeof(mbtk_net_reg_info_t));
+ ret = mbtk_ds_net_reg_get(handle_def, sim_id, ®);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_net_reg_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("call_state: [%d], data_state: [%d], ims_state: [%d], type: [%d], lac: [%d], ci: [%lld]\n",
+ reg.call_state, reg.data_state, reg.ims_state, reg.type, reg.lac, reg.ci);
+ }
+}
+
+static void item_mbtk_ds_oos_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_ril_oos_info_t oos_info = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(&oos_info, 0x00, sizeof(mbtk_ril_oos_info_t));
+ ret = mbtk_ds_oos_get(handle_def, sim_id, &oos_info);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_oos_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("state: [%d], OosPhase1: [%d], OosPhase2: [%d], OosPhase3: [%d]\n",
+ oos_info.state, oos_info.oosPhase[0], oos_info.oosPhase[1], oos_info.oosPhase[2]);
+ }
+}
+
+static void item_mbtk_ds_oos_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_ril_oos_info_t oos_info = {0};
+ char cmd[BUF_SIZE_128 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("exampl <state>-<OosOhase1>-<OosOhase2>-<OosOhase3>\n");
+ printf("state ([0: disable] [1:enable])\n");
+ printf("please input param:\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ memset(&oos_info, 0x00, sizeof(mbtk_ril_oos_info_t));
+ ret = sscanf(cmd, "%d %d %d %d", &(oos_info.state), &(oos_info.oosPhase[0]), &(oos_info.oosPhase[1]), &(oos_info.oosPhase[2]));
+
+ ret = mbtk_ds_oos_set(handle_def, sim_id, &oos_info);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_oos_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_oos_get() success\n");
+ }
+}
+
+static void item_mbtk_ds_wakeup_state_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ int wakeup_state = 0;
+ char cmd[BUF_SIZE_128 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("exampl <wakeup_state>\n");
+ printf("please input param:\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ wakeup_state = atoi(cmd);
+
+ ret = mbtk_ds_wakeup_state_set(handle_def, sim_id, wakeup_state);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_wakeup_state_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_wakeup_state_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_apn_get(void)
+{
+ int i = 0;
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_apn_info_array_t apns = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(&apns, 0x00, sizeof(mbtk_apn_info_array_t));
+ ret = mbtk_ds_apn_get(handle_data, sim_id, &apns);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_apn_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("cid_for_def_route: [%d], cid_for_def_dns: [%d]\n", apns.cid_for_def_route, apns.cid_for_def_dns);
+ for(i = 0; i < apns.num; i++)
+ {
+ printf("cid: [%d], ip_type: [%d], auth: [%d], auto_save: [%d], auto_boot_call: [%d], redial_enable: [%d], def_route: [%d], as_dns: [%d], apn: [%s], user: [%s], pass: [%s], type: [%s]\n",
+ apns.apns[i].cid, apns.apns[i].ip_type, apns.apns[i].auth, apns.apns[i].auto_save, apns.apns[i].auto_boot_call, apns.apns[i].redial_enable, apns.apns[i].def_route, apns.apns[i].as_dns,
+ str_empty(apns.apns[i].apn) ? "NULL" : (char *)apns.apns[i].apn,
+ str_empty(apns.apns[i].user) ? "NULL" : (char *)apns.apns[i].user,
+ str_empty(apns.apns[i].pass) ? "NULL" : (char *)apns.apns[i].pass,
+ str_empty(apns.apns[i].type) ? "NULL" : (char *)apns.apns[i].type);
+ }
+ }
+}
+
+static void item_mbtk_ds_apn_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_apn_info_t apn = {0};
+ int cid = 0;
+ int ip_type = 0;
+ int auth = 0;
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("exampl <cid>-<ip_type>-<auth>-<auto_save>-<auto_boot_call>-<redial_enable>-<def_route>-<as_dns>-<apn>-<user>-<pass>-<type>\n");
+ printf("cid ([1 - 7])\n");
+ printf("ip_type ([0: ipv4] [1: ipv6] [2: ipv4v6] [3: ppp])\n");
+ printf("auth ([0: default] [1: NONE] [2: PAP] [3: CHAP])\n");
+ printf("please input param:\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ memset(&apn, 0x00, sizeof(mbtk_apn_info_t));
+ ret = sscanf(cmd, "%d %d %d %d %d %d %d %d %s %s %s %s", &cid, &ip_type, &auth, &(apn.auto_save),&(apn.auto_boot_call),
+ &(apn.redial_enable), &(apn.def_route), &(apn.as_dns), apn.apn, apn.user, apn.pass, apn.type);
+ apn.cid = (mbtk_ril_cid_enum)cid;
+ apn.ip_type = (mbtk_ip_type_enum)ip_type;
+ apn.auth = (mbtk_apn_auth_type_enum)auth;
+
+ ret = mbtk_ds_apn_set(handle_data, sim_id, &apn);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_apn_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_apn_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_data_call_start(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ int cid = 0;
+ int timeout = 0;
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("exampl <cid>-<timeout>\n");
+ printf("cid ([1 - 7])\n");
+ printf("please input param:\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ ret = sscanf(cmd, "%d %d", &cid, &timeout);
+
+ ret = mbtk_ds_data_call_start(handle_data, sim_id, (mbtk_ril_cid_enum)cid, MBTK_DATA_CALL_ITEM_STATE_NON,
+ MBTK_DATA_CALL_ITEM_STATE_NON, MBTK_DATA_CALL_ITEM_STATE_NON, NULL, 0, timeout, NULL);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_data_call_start() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_data_call_start() success\n");
+ }
+}
+
+static void item_mbtk_ds_data_call_stop(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ int cid = 0;
+ int timeout = 0;
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("exampl <cid>-<timeout>\n");
+ printf("cid ([1 - 7])\n");
+ printf("please input param:\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ ret = sscanf(cmd, "%d %d", &cid, &timeout);
+
+ ret = mbtk_ds_data_call_stop(handle_data, sim_id, (mbtk_ril_cid_enum)cid, timeout);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_data_call_stop() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_data_call_stop() success\n");
+ }
+}
+
+static void item_mbtk_ds_data_call_state_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ int cid = 0;
+ mbtk_ip_info_t ip = {0};
+ char ip_tmp[BUF_SIZE_128 + 1] = {0};
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("exampl <cid>\n");
+ printf("cid ([1 - 7])\n");
+ printf("please input param:\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ cid = atoi(cmd);
+
+ memset(&ip, 0x00, sizeof(mbtk_ip_info_t));
+ ret = mbtk_ds_data_call_state_get(handle_data, sim_id, (mbtk_ril_cid_enum)cid, &ip);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_data_call_state_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("ip.ipv4.valid: [%d]\n", ip.ipv4.valid);
+ if(ip.ipv4.valid)
+ {
+ memset(ip_tmp, 0x00, BUF_SIZE_128 + 1);
+ if(inet_ntop(AF_INET, &(ip.ipv4.IPAddr), ip_tmp, BUF_SIZE_128) == NULL)
+ {
+ printf("IP error.\n");
+ }
+ else
+ {
+ printf("IP: [%s]\n", ip_tmp);
+ }
+
+ memset(ip_tmp, 0x00, BUF_SIZE_128 + 1);
+ if(inet_ntop(AF_INET, &(ip.ipv4.PrimaryDNS), ip_tmp, BUF_SIZE_128) == NULL)
+ {
+ printf("PrimaryDNS error.\n");
+ }
+ else
+ {
+ printf("PrimaryDNS: [%s]\n", ip_tmp);
+ }
+
+ memset(ip_tmp, 0x00, BUF_SIZE_128 + 1);
+ if(inet_ntop(AF_INET, &(ip.ipv4.SecondaryDNS), ip_tmp, BUF_SIZE_128) == NULL)
+ {
+ printf("SecondaryDNS error.\n");
+ }
+ else
+ {
+ printf("SecondaryDNS: [%s]\n", ip_tmp);
+ }
+
+ memset(ip_tmp, 0x00, BUF_SIZE_128 + 1);
+ if(inet_ntop(AF_INET, &(ip.ipv4.GateWay), ip_tmp, BUF_SIZE_128) == NULL)
+ {
+ printf("GateWay error.\n");
+ }
+ else
+ {
+ printf("GateWay: [%s]\n", ip_tmp);
+ }
+
+ memset(ip_tmp, 0x00, BUF_SIZE_128 + 1);
+ if(inet_ntop(AF_INET, &(ip.ipv4.NetMask), ip_tmp, BUF_SIZE_128) == NULL)
+ {
+ printf("NetMask error.\n");
+ }
+ else
+ {
+ printf("NetMask: [%s]\n", ip_tmp);
+ }
+ }
+
+ printf("ip.ipv6.valid: [%d]\n", ip.ipv6.valid);
+ if(ip.ipv6.valid)
+ {
+ memset(ip_tmp, 0x00, BUF_SIZE_128 + 1);
+ if(ipv6_2_str(&(ip.ipv6.IPV6Addr), ip_tmp))
+ {
+ printf("IPV6 error.\n");
+ }
+ else
+ {
+ printf("IPV6: [%s]\n", ip_tmp);
+ }
+
+ memset(ip_tmp, 0x00, BUF_SIZE_128 + 1);
+ if(ipv6_2_str(&(ip.ipv6.PrimaryDNS), ip_tmp))
+ {
+ printf("PrimaryDNS_V6 error.\n");
+ }
+ else
+ {
+ printf("PrimaryDNS_V6: [%s]\n", ip_tmp);
+ }
+
+ memset(ip_tmp, 0x00, BUF_SIZE_128 + 1);
+ if(ipv6_2_str(&(ip.ipv6.SecondaryDNS), ip_tmp))
+ {
+ printf("SecondaryDNS_V6 error.\n");
+ }
+ else
+ {
+ printf("SecondaryDNS_V6: [%s]\n", ip_tmp);
+ }
+
+ memset(ip_tmp, 0x00, BUF_SIZE_128 + 1);
+ if(ipv6_2_str(&(ip.ipv6.GateWay), ip_tmp))
+ {
+ printf("GateWay_V6 error.\n");
+ }
+ else
+ {
+ printf("GateWay_V6: [%s]\n", ip_tmp);
+ }
+
+ memset(ip_tmp, 0x00, BUF_SIZE_128 + 1);
+ if(ipv6_2_str(&(ip.ipv6.NetMask), ip_tmp))
+ {
+ printf("NetMask_V6 error.\n");
+ }
+ else
+ {
+ printf("NetMask_V6: [%s]\n", ip_tmp);
+ }
+ }
+ }
+}
+
+static void item_mbtk_ds_sms_cmgf_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ int sms_state = 0;
+
+ item_sim_type_printf(&sim_id);
+
+ ret = mbtk_ds_sms_cmgf_get(handle_def, sim_id, &sms_state);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cmgf_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("sms_stateļ¼ [%d]\n", sms_state);
+ }
+}
+
+static void item_mbtk_ds_sms_cmgf_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ int mode = 0;
+ char cmd[BUF_SIZE_128 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(mode):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ mode = atoi(cmd);
+
+ ret = mbtk_ds_sms_cmgf_set(handle_def, sim_id, mode);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cmgf_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_sms_cmgf_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_sms_cmgs_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char resp[BUF_SIZE_128 + 1] = {0};
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(cmgs):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+
+ memset(resp, 0x00, BUF_SIZE_128 + 1);
+ ret = mbtk_ds_sms_cmgs_set(handle_def, sim_id, cmd, resp);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cmgs_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("resp: [%s]\n", resp);
+ }
+}
+
+static void item_mbtk_ds_sms_cmgw_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char resp[BUF_SIZE_128 + 1] = {0};
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(cmgw):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+
+ memset(resp, 0x00, BUF_SIZE_128 + 1);
+ ret = mbtk_ds_sms_cmgw_set(handle_def, sim_id, cmd, resp);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cmgw_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("resp: [%s]\n", resp);
+ }
+}
+
+static void item_mbtk_ds_sms_cmgd_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(cmdg):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+
+ ret = mbtk_ds_sms_cmgd_set(handle_def, sim_id, cmd);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cmgd_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_sms_cmgd_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_sms_cmgd_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char cmdg[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(cmdg, 0x00, BUF_SIZE_1024 + 1);
+ ret = mbtk_ds_sms_cmgd_get(handle_def, sim_id, cmdg);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cmgd_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("cmdg: [%s]\n", cmdg);
+ }
+}
+
+static void item_mbtk_ds_sms_cmgl_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char resp[BUF_SIZE_128 + 1] = {0};
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(cmgw):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+
+ memset(resp, 0x00, BUF_SIZE_128 + 1);
+ ret = mbtk_ds_sms_cmgl_set(handle_def, sim_id, cmd, resp);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cmgl_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("resp: [%s]\n", resp);
+ }
+}
+
+static void item_mbtk_ds_sms_csca_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char buff[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(buff, 0x00, BUF_SIZE_1024 + 1);
+ ret = mbtk_ds_sms_csca_get(handle_def, sim_id, buff);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_csca_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("buff: [%s]\n", buff);
+ }
+}
+
+static void item_mbtk_ds_sms_csca_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(csca):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+
+ ret = mbtk_ds_sms_csca_set(handle_def, sim_id, cmd);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_csca_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_sms_csca_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_sms_csmp_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(csmp):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+
+ ret = mbtk_ds_sms_csmp_set(handle_def, sim_id, cmd);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_csmp_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_sms_csmp_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_sms_cscb_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(csmp):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+
+ ret = mbtk_ds_sms_cscb_set(handle_def, sim_id, cmd);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cscb_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_sms_cscb_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_sms_cnmi_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+
+ item_sim_type_printf(&sim_id);
+
+ ret = mbtk_ds_sms_cnmi_set(handle_def, sim_id);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cnmi_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_sms_cnmi_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_sms_cmss_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char resp[BUF_SIZE_128 + 1] = {0};
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(cmss):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+
+ memset(resp, 0x00, BUF_SIZE_128 + 1);
+ ret = mbtk_ds_sms_cmss_set(handle_def, sim_id, cmd, resp);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cmss_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("resp: [%s]\n", resp);
+ }
+}
+
+static void item_mbtk_ds_sms_cpms_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char resp[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(resp, 0x00, BUF_SIZE_128 + 1);
+ ret = mbtk_ds_sms_cpms_get(handle_def, sim_id, resp);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cpms_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("resp: [%s]\n", resp);
+ }
+}
+
+static void item_mbtk_ds_sms_cpms_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char resp[BUF_SIZE_128 + 1] = {0};
+ char cmd[BUF_SIZE_1024 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(cmss):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_1024, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+
+ memset(resp, 0x00, BUF_SIZE_128 + 1);
+ ret = mbtk_ds_sms_cpms_set(handle_def, sim_id, cmd, resp);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cpms_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("resp: [%s]\n", resp);
+ }
+}
+
+static void item_mbtk_ds_sms_cmgr_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char resp[BUF_SIZE_128 + 1] = {0};
+ int index = 0;
+ char cmd[BUF_SIZE_128 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(cmss):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ index = atoi(cmd);
+
+ memset(resp, 0x00, BUF_SIZE_128 + 1);
+ ret = mbtk_ds_sms_cmgr_set(handle_def, sim_id, index, resp);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_sms_cmgr_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("resp: [%s]\n", resp);
+ }
+}
+
+static void item_mbtk_ds_call_start(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ char cmd[BUF_SIZE_128 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(phone_number):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+
+ ret = mbtk_ds_call_start(handle_voice, sim_id, cmd);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_call_start() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_call_start() success\n");
+ }
+}
+
+static void item_mbtk_ds_call_answer(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+
+ item_sim_type_printf(&sim_id);
+
+ ret = mbtk_ds_call_answer(handle_voice, sim_id);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_call_answer() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_call_answer() success\n");
+ }
+}
+
+static void item_mbtk_ds_call_hang(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+
+ item_sim_type_printf(&sim_id);
+
+ ret = mbtk_ds_call_hang(handle_voice, sim_id);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_call_hang() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_call_hang() success\n");
+ }
+}
+
+static void item_mbtk_ds_a_call_hang(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ int phone_id = 0;
+ char cmd[BUF_SIZE_128 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(phone_id):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ phone_id = atoi(cmd);
+
+ ret = mbtk_ds_a_call_hang(handle_voice, sim_id, phone_id);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_a_call_hang() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_a_call_hang() success\n");
+ }
+}
+
+static void item_mbtk_ds_waiting_or_background_call_hang(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+
+ item_sim_type_printf(&sim_id);
+
+ ret = mbtk_ds_waiting_or_background_call_hang(handle_voice, sim_id);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_waiting_or_background_call_hang() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_waiting_or_background_call_hang() success\n");
+ }
+}
+
+static void item_mbtk_ds_foreground_resume_background_call_hang(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+
+ item_sim_type_printf(&sim_id);
+
+ ret = mbtk_ds_foreground_resume_background_call_hang(handle_voice, sim_id);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_foreground_resume_background_call_hang() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_foreground_resume_background_call_hang() success\n");
+ }
+}
+
+static void item_mbtk_ds_call_reg_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_call_info_t reg = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ memset(®, 0x00, sizeof(mbtk_call_info_t));
+ ret = mbtk_ds_call_reg_get(handle_voice, sim_id, ®);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_call_reg_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("RING: [%hhd] [%hhd] [%hhd] [%hhd] [%hhd] [%hhd] [%s] [%hhd] [%hhd] [%hhd] [%s]\n",
+ reg.call_wait, reg.dir1, reg.dir, reg.state, reg.mode, reg.mpty, reg.phone_number, reg.type, reg.pas, reg.disconnected_id, (char *)reg.end_reason);
+ }
+}
+
+static void item_mbtk_ds_mute_state_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ int mute_state = 0;
+
+ item_sim_type_printf(&sim_id);
+
+ ret = mbtk_ds_mute_state_get(handle_def, sim_id, &mute_state);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_mute_state_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mute_state: [%d]\n", mute_state);
+ }
+}
+
+static void item_mbtk_ds_mute_state_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ int mute_state = 0;
+ char cmd[BUF_SIZE_128 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(mute_state):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ mute_state = atoi(cmd);
+
+ ret = mbtk_ds_mute_state_set(handle_def, sim_id, mute_state);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_mute_state_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_mute_state_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_dtmf_send(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ mbtk_call_dtmf_info_t dtmf_character = {0};
+ char cmd[BUF_SIZE_128 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("exampl <character>-<duration>\n");
+ printf("please input param:\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ ret = sscanf(cmd, "%c %d", &(dtmf_character.character), &(dtmf_character.duration));
+
+ ret = mbtk_ds_dtmf_send(handle_def, sim_id, &dtmf_character);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_dtmf_send() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_dtmf_send() success\n");
+ }
+}
+
+static void item_mbtk_ds_centric_set(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ int centric = 0;
+ char cmd[BUF_SIZE_128 + 1] = {0};
+
+ item_sim_type_printf(&sim_id);
+
+ printf("please input param(centric):\n");
+ if(NULL == fgets(cmd, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("fgets cmd fail.\n");
+ return;
+ }
+ fflush(stdin);
+ centric = atoi(cmd);
+
+ ret = mbtk_ds_centric_set(handle_def, sim_id, centric);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_centric_set() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("mbtk_ds_centric_set() success\n");
+ }
+}
+
+static void item_mbtk_ds_centric_get(void)
+{
+ mbtk_sim_type_enum sim_id;
+ mbtk_ril_err_enum ret = MBTK_RIL_ERR_SUCCESS;
+ int centric = 0;
+
+ item_sim_type_printf(&sim_id);
+
+ ret = mbtk_ds_centric_get(handle_def, sim_id, ¢ric);
+ if(MBTK_RIL_ERR_SUCCESS != ret)
+ {
+ printf("mbtk_ds_centric_get() fail.[%d]\n", ret);
+ }
+ else
+ {
+ printf("centric: [%d]\n", centric);
+ }
+}
+
+//for server test
+static api_test_info_t api_test_cases[] =
+{
+ {"[API]", NULL},
+ {"mbtk_ril_open", item_mbtk_ril_open},
+ {"mbtk_ril_close", item_mbtk_ril_open},
+ {"mbtk_version_get", item_mbtk_version_get},
+ {"mbtk_ds_model_get", item_mbtk_ds_model_get},
+ {"mbtk_ds_radio_state_get", item_mbtk_ds_radio_state_get},
+ {"mbtk_ds_radio_state_set", item_mbtk_ds_radio_state_set},
+ {"mbtk_ds_cell_time_get", item_mbtk_ds_cell_time_get},
+ {"mbtk_ds_sim_state_get", item_mbtk_ds_sim_state_get},
+ {"mbtk_ds_sim_type_get", item_mbtk_ds_sim_type_get},
+ {"mbtk_ds_imsi_get", item_mbtk_ds_imsi_get},
+ {"mbtk_ds_iccid_get", item_mbtk_ds_iccid_get},
+ {"mbtk_ds_phone_number_get", item_mbtk_ds_phone_number_get},
+ {"mbtk_ds_sim_lock_get", item_mbtk_ds_sim_lock_get},
+ {"mbtk_ds_sim_lock_set", item_mbtk_ds_sim_lock_set},
+ {"mbtk_ds_sim_lock_retry_times_get", item_mbtk_ds_sim_lock_retry_times_get},
+ {"mbtk_ds_plmn_list_get", item_mbtk_ds_plmn_list_get},
+ {"mbtk_ds_available_net_get", item_mbtk_ds_available_net_get},
+ {"mbtk_ds_net_sel_mode_set", item_mbtk_ds_net_sel_mode_set},
+ {"mbtk_ds_net_sel_mode_get", item_mbtk_ds_net_sel_mode_get},
+ {"mbtk_ds_current_band_get", item_mbtk_ds_current_band_get},
+ {"mbtk_ds_current_band_set", item_mbtk_ds_current_band_set},
+ {"mbtk_ds_cell_get", item_mbtk_ds_cell_get},
+ {"mbtk_ds_cell_set", item_mbtk_ds_cell_set},
+ {"mbtk_ds_net_signal_get", item_mbtk_ds_net_signal_get},
+ {"mbtk_ds_net_reg_get", item_mbtk_ds_net_reg_get},
+ {"mbtk_ds_oos_get", item_mbtk_ds_oos_get},
+ {"mbtk_ds_oos_set", item_mbtk_ds_oos_set},
+ {"mbtk_ds_wakeup_state_set", item_mbtk_ds_wakeup_state_set},
+ {"mbtk_ds_apn_get", item_mbtk_ds_apn_get},
+ {"mbtk_ds_apn_set", item_mbtk_ds_apn_set},
+ {"mbtk_ds_data_call_start", item_mbtk_ds_data_call_start},
+ {"mbtk_ds_data_call_stop", item_mbtk_ds_data_call_stop},
+ {"mbtk_ds_data_call_state_get", item_mbtk_ds_data_call_state_get},
+ {"mbtk_ds_sms_cmgf_get", item_mbtk_ds_sms_cmgf_get},
+ {"mbtk_ds_sms_cmgf_set", item_mbtk_ds_sms_cmgf_set},
+ {"mbtk_ds_sms_cmgs_set", item_mbtk_ds_sms_cmgs_set},
+ {"mbtk_ds_sms_cmgw_set", item_mbtk_ds_sms_cmgw_set},
+ {"mbtk_ds_sms_cmgd_set", item_mbtk_ds_sms_cmgd_set},
+ {"mbtk_ds_sms_cmgd_get", item_mbtk_ds_sms_cmgd_get},
+ {"mbtk_ds_sms_cmgl_set", item_mbtk_ds_sms_cmgl_set},
+ {"mbtk_ds_sms_csca_get", item_mbtk_ds_sms_csca_get},
+ {"mbtk_ds_sms_csca_set", item_mbtk_ds_sms_csca_set},
+ {"mbtk_ds_sms_csmp_set", item_mbtk_ds_sms_csmp_set},
+ {"mbtk_ds_sms_cscb_set", item_mbtk_ds_sms_cscb_set},
+ {"mbtk_ds_sms_cnmi_set", item_mbtk_ds_sms_cnmi_set},
+ {"mbtk_ds_sms_cmss_set", item_mbtk_ds_sms_cmss_set},
+ {"mbtk_ds_sms_cpms_get", item_mbtk_ds_sms_cpms_get},
+ {"mbtk_ds_sms_cpms_set", item_mbtk_ds_sms_cpms_set},
+ {"mbtk_ds_sms_cmgr_set", item_mbtk_ds_sms_cmgr_set},
+ {"mbtk_ds_call_start", item_mbtk_ds_call_start},
+ {"mbtk_ds_call_answer", item_mbtk_ds_call_answer},
+ {"mbtk_ds_call_hang", item_mbtk_ds_call_hang},
+ {"mbtk_ds_a_call_hang", item_mbtk_ds_a_call_hang},
+ {"mbtk_ds_waiting_or_background_call_hang", item_mbtk_ds_waiting_or_background_call_hang},
+ {"mbtk_ds_foreground_resume_background_call_hang", item_mbtk_ds_foreground_resume_background_call_hang},
+ {"mbtk_ds_call_reg_get", item_mbtk_ds_call_reg_get},
+ {"mbtk_ds_mute_state_get", item_mbtk_ds_mute_state_get},
+ {"mbtk_ds_mute_state_set", item_mbtk_ds_mute_state_set},
+ {"mbtk_ds_dtmf_send", item_mbtk_ds_dtmf_send},
+ {"mbtk_ds_centric_set", item_mbtk_ds_centric_set},
+ {"mbtk_ds_centric_get", item_mbtk_ds_centric_get},
+ {"[OTHER OPERATIONS]", NULL},
+ {"qser_help", item_print_help},
+ {"qser_exit", item_exit}
+};
+
+static void item_print_help(void)
+{
+ int i;
+ printf("test supported %d cases:\n", cases_count);
+ for(i = 0; i < cases_count; i++)
+ {
+ if(api_test_cases[i].excute_func == NULL)
+ {
+ printf("%s\n", api_test_cases[i].funcName);
+ }
+ else
+ {
+ printf("%d:\t%s\n", i, api_test_cases[i].funcName);
+ }
+ }
+}
+
+static void item_exit(void)
+{
+ printf("mbtk ds test exit.\n");
+}
+
+int main(int argc, char const *argv[])
+{
+ int cmdidx = 0;
+ char cases[BUF_SIZE_128] = {0};
+ cases_count = (sizeof(api_test_cases) / sizeof(api_test_info_t));
+
+ item_print_help();
+ while(1)
+ {
+ printf("please input cmd index:\n");
+ memset(cases, 0x0, BUF_SIZE_128);
+ if(NULL == fgets(cases, BUF_SIZE_128, stdin))
+ {
+ fflush(stdin);
+ printf("get cases fail.\n");
+ continue;
+ }
+ fflush(stdin);
+
+ cmdidx = atoi(cases);
+ if(cmdidx < 0 || cmdidx >= cases_count)
+ {
+ printf("cmdidx no exist.\n");
+ continue;
+ }
+ else if(cmdidx == cases_count - 1)
+ {
+ api_test_cases[cmdidx].excute_func();
+ break;
+ }
+
+ if(api_test_cases[cmdidx].excute_func != NULL)
+ {
+ api_test_cases[cmdidx].excute_func();
+ }
+ else
+ {
+ printf("excute func is NULL.\n");
+ }
+ }
+
+ return 0;
+}