mbtk/test/libql_lib_v2/ql_ecall_test.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <ctype.h>

#include "ql_type.h"
#include "ql_ms_voice.h"
#include "ql_ecall.h"
#include "mbtk_utils.h"

typedef void (*item_handler_f)(void);

typedef struct
{
    const char *name;
    item_handler_f handle;
} t_item_t;

void item_ql_ecall_set_test_number(void)
{
    int ret = 0;
    int sim_id;

    char test_number[QL_VOICE_MAX_PHONE_NUMBER];

    printf("test ql_voice_ecall_set_test_number: ");

    printf("please enter test number: ");
    char* find = NULL;

    if(NULL == fgets(test_number, QL_VOICE_MAX_PHONE_NUMBER-1, stdin))
        return;
    find = strchr(test_number, '\n');
    if(find)
    {
        *find = '\0';
    }

    printf("please enter the sim_id: ");

    if(1 != scanf("%u", &sim_id))
        return;
    getchar();
    printf("sim_id is %u\n", sim_id);

    ret = ql_ecall_set_test_number(sim_id, test_number);

    if (ret == QL_ERR_OK)
    {
        printf("ok\n");
    }
    else
    {
        printf("failed, ret = %d\n", ret);
    }
}

void item_ql_ecall_reset_ivs(void)
{
    int ret = 0;
    int sim_id;

    printf("please enter the sim_id: ");

    if(1 != scanf("%u", &sim_id))
        return;
    getchar();
    printf("sim_id is %u\n", sim_id);

    ret = ql_ecall_reset_ivs(sim_id);
    if (ret == QL_ERR_OK)
    {
        printf("ok\n");
    }
    else
    {
        printf("failed, ret = %d\n", ret);
    }
}

void fast_ecall_dial(void){
    int ret = 0, v = 0;
    ql_voice_ecall_info_t *p_info = NULL;
    char *find = NULL;
    uint32_t id;
    int sim_id;

    p_info = (ql_voice_ecall_info_t *)calloc(1, sizeof(*p_info));
    if (NULL  == p_info)
    {
        printf("run out of memory\n");
        return;
    }

    printf("please enter the sim_id: ");
    if(1 != scanf("%d", &sim_id))
        return;
    getchar();

    if(!QL_IS_SIM_VALID(sim_id))
    {
        printf("invalid sim_id\n");
        free(p_info);
        p_info = NULL;
        return;
    }

    printf("sim_id is %d\n", sim_id);

    printf("example MSD: 01 04 a9 81 d5 49 70 d6 5c 35 97 ca 04 20 c4 14 60 "
        "0b be 5f 7e b1 4b a6 ee 10 4f c5 27 03 c1 80 q\n");
    printf("please enter MSD(at most 140 hex), end with 'q': ");
    while (1 == scanf("%x", &v))
    {
        p_info->msd[p_info->msd_len++] = v;
    }
    getchar();  // read `q'
    getchar();  // read '\n'

    printf("MSD ========[");
    for(v = 0; v < p_info->msd_len; v ++)
    {
        printf("%02x ", p_info->msd[v]);
    }
    printf("]\n");

    if (p_info->msd_len > QL_VOICE_MAX_ECALL_MSD)
    {
        printf("MSD too long\n");
        free(p_info);
        p_info = NULL;
        return;
    }

    printf("please enter eCall type(1 - test, 2 - emergency,  3 - reconfig): ");
    if(1 != scanf("%d", (int *)&p_info->type))
        return;
    getchar();

    printf("please enter test number(emergency ecall should be empty): ");
    find = NULL;
    if(NULL == fgets(p_info->test_number, sizeof(p_info->test_number)-1, stdin))
        return;
    find = strchr(p_info->test_number, '\n');
    if(find)
    {
        *find = '\0';
    }

    printf("how to trigger eCall(0 - manual, 1 - auto): ");
    if(1 != scanf("%d", &p_info->auto_trigger))
        return;
    getchar();

    ret = ql_ecall_dial(sim_id, p_info, &id);
    if (ret == QL_ERR_OK)
    {
        printf("ok, call_id is %u\n", id);
    }
    else
    {
        printf("failed, ret = %d\n", ret);
    }

    free(p_info);
    p_info = NULL;
}

void item_ql_ecall_dial(void)
{
    printf("test ql_voice_ecall_dial: \n");
    printf("Is fast ecall? (1 - yes, other - wrong): ");
    int is_fast;
    scanf("%d", &is_fast);
    getchar();

    if(is_fast == 1){
        printf("Dialling fast ecall\n");
        fast_ecall_dial();
    }else{
        printf("Wrong arguments\n");
    }
}

void item_ql_ecall_hangup(void)
{
    int ret = 0;
//    int sim_id;

    printf("test ql_voice_ecall_hangup: \n");
    ret = ql_ecall_hangup();
    if (ret == QL_ERR_OK)
    {
        printf("ok\n");
    }
    else
    {
        printf("failed, ret = %d\n", ret);
    }
}

void item_ql_ecall_update_msd_raw(void)
{
    int ret = 0, v = 0;
    uint32_t msd_len = 0;
    char msd[QL_VOICE_MAX_ECALL_MSD] = {0};

    printf("test ql_voice_ecall_update_msd: \n");
    printf("example MSD: 01 04 a9 81 d5 49 70 d6 5c 35 97 ca 04 20 c4 14 60 "
        "0b be 5f 7e b1 4b a6 ee 10 4f c5 27 03 c1 80 q\n");
    printf("please enter MSD(at most 140 hex), end with 'q': ");
    while (1 == scanf("%x", &v))
    {
        if(msd_len >= QL_VOICE_MAX_ECALL_MSD)
        {
            printf("MSD too long\n");
            int c;
            while ((c = getchar()) != '\n' && c != EOF) { }
            return;
        }
        else
        {
            msd[msd_len++] = v;
        }
    }
    getchar();  // read `q'
    getchar();  // read '\n'

    ret = ql_ecall_update_msd_raw((uint8_t *)msd, msd_len);
    if (ret == QL_ERR_OK)
    {
        printf("ok\n");
    }
    else
    {
        printf("failed, ret = %d\n", ret);
    }
}

void item_ql_ecall_push_msd(void)
{
    int ret = 0;

    printf("test ql_voice_ecall_push_msd: \n");
    ret = ql_ecall_push_msd();
    if (ret == QL_ERR_OK)
    {
        printf("sql_ecall_push_msd OK\n");
    }
    else
    {
        printf("failed, ret = %d\n", ret);
    }
}

static void ecall_user_ind_callback(int ind, void *userdata)
{
    printf("\n****** eCall indication Received ******\n");
    printf("ecall_indication: %d - ", ind);

    switch(ind){
        case QL_ECALL_EVENT_SENDING_START:
            printf("QL_ECALL_EVENT_SENDING_START\n");
            break;
        case QL_ECALL_EVENT_SENDING_MSD:
            printf("QL_ECALL_EVENT_SENDING_MSD\n");
            break;
        case QL_ECALL_EVENT_LLACK_RECEIVED:
            printf("QL_ECALL_EVENT_LLACK_RECEIVED\n");
            break;
        case QL_ECALL_EVENT_ALLACK_POSITIVE_RECEIVED:
            printf("QL_ECALL_EVENT_ALLACK_POSITIVE_RECEIVED\n");
            break;
        case QL_ECALL_EVENT_ALLACK_CLEARDOWN_RECEIVED:
            printf("QL_ECALL_EVENT_ALLACK_CLEARDOWN_RECEIVED\n");
            break;
        case QL_ECALL_EVENT_ACTIVE:
            printf("QL_ECALL_EVENT_ACTIVE\n");
            break;
        case QL_ECALL_EVENT_DISCONNECTED:
            printf("QL_ECALL_EVENT_DISCONNECTED\n");
            break;
        case QL_ECALL_EVENT_ABNORMAL_HANGUP:
            printf("QL_ECALL_EVENT_ABNORMAL_HANGUP\n");
            break;
        case QL_ECALL_EVENT_ONLY_DEREGISTRATION:
            printf("QL_ECALL_EVENT_ONLY_DEREGISTRATION\n");
            break;
        case QL_ECALL_EVENT_MAY_DEREGISTRATION:
            printf("QL_ECALL_EVENT_MAY_DEREGISTRATION\n");
            break;
        case QL_ECALL_EVENT_PSAP_CALLBACK_START:
            printf("QL_ECALL_EVENT_PSAP_CALLBACK_START\n");
            break;
        case QL_ECALL_EVENT_T2_TIMEOUT:
            printf("QL_ECALL_EVENT_T2_TIMEOUT\n");
            break;
        case QL_ECALL_EVENT_T5_TIMEOUT:
            printf("QL_ECALL_EVENT_T5_TIMEOUT\n");
            break;
        case QL_ECALL_EVENT_T6_TIMEOUT:
            printf("QL_ECALL_EVENT_T6_TIMEOUT\n");
            break;
        case QL_ECALL_EVENT_T7_TIMEOUT:
            printf("QL_ECALL_EVENT_T7_TIMEOUT\n");
            break;
        case QL_ECALL_EVENT_ECALL_STARTED:
            printf("QL_ECALL_EVENT_ECALL_STARTED\n");
            break;
        case QL_ECALL_EVENT_INCOMING_CALL:
            printf("QL_ECALL_EVENT_INCOMING_CALL\n");
            break;
        case QL_ECALL_EVENT_DIAL_DURATION_TIMEOUT:
            printf("QL_ECALL_EVENT_DIAL_DURATION_TIMEOUT\n");
            break;
        case QL_ECALL_EVENT_INTERVAL_TIMEOUT:
            printf("QL_ECALL_EVENT_INTERVAL_TIMEOUT\n");
            break;
        case QL_ECALL_EVENT_AUTO_ANSWER_TIMEOUT:
            printf("QL_ECALL_EVENT_AUTO_ANSWER_TIMEOUT\n");
            break;
        default:
            printf("UNKNOWN\n");
            break;
    }
}

void item_ql_ecall_init(void)
{
    int ret = 0;

    printf("test ql_ecall_init: ");
    ret = ql_ecall_init();
    if(ret == QL_ERR_OK)
    {
        printf("ok\n");
    }
    else
    {
        printf("failed, ret = %d\n", ret);
    }
}

void item_ql_ecall_deinit(void)
{
    int ret = 0;

    printf("test ql_ecall_deinit: ");
    ret = ql_ecall_deinit();
    if (ret == QL_ERR_OK)
    {
        printf("ok\n");
    }
    else
    {
        printf("failed, ret = %d\n", ret);
    }
}

void item_ql_ecall_set_user_ind_cb(void)
{
    ql_ecall_set_user_ind_cb(ecall_user_ind_callback, NULL);
}

void item_ql_ecall_set_msd_version(void)
{
    int ret = 0;
    uint8_t index=0;

    printf("ecall MSD version(1-ASN1_ECALL_MSD_VERSION_1;  2-ASN1_ECALL_MSD_VERSION_2): \n");
    scanf("%hhd", &index);
    getchar();

    if (1 == index)
    {
        ret = ql_ecall_set_msd_version(ASN1_ECALL_MSD_VERSION_1);
        printf(" ql_ecall_get_msd_version ret = %d\n", ret);
    }
    else if(2 == index)
    {
        ret = ql_ecall_set_msd_version(ASN1_ECALL_MSD_VERSION_2);
        printf(" ql_ecall_get_msd_version ret = %d\n", ret);
    }
    else
    {
        printf(" This version is not surport.\n");
    }

}

void item_ql_ecall_get_msd_version(void)
{
    uint8_t msdVersion = 0;

    ql_ecall_get_msd_version(&msdVersion);

    if(msdVersion == ASN1_ECALL_MSD_VERSION_1)//unsupported
    {
        printf("MSD version is set to ASN1_ECALL_MSD_VERSION_1.\n");
    }
    else if (msdVersion == ASN1_ECALL_MSD_VERSION_2)//supported
    {
        printf("MSD version is set to ASN1_ECALL_MSD_VERSION_2.\n");
    }
    else
    {
        printf(" This version is not surport.\n");
    }

}

void item_ql_ecall_set_system_type(void)
{
    int ret = 0;
    uint8_t index=0;

    printf("ecall system type(0-ECALL_SYSTEM_STD_PAN_EUROPEAN;  1-ECALL_SYSTEM_STD_ERA_GLONASS): \n");
    scanf("%hhd", &index);
    getchar();

    if (0 == index)
    {
        ret = ql_ecall_set_system_std(ECALL_SYSTEM_STD_PAN_EUROPEAN);
        printf(" ql_ecall_set_system_std ret = %d\n", ret);
    }
    else if(1 == index)
    {
        ret = ql_ecall_set_system_std(ECALL_SYSTEM_STD_ERA_GLONASS);
        printf(" ql_ecall_set_system_std ret = %d\n", ret);
    }
    else
    {
        printf(" This version is not surport.\n");
    }
}

void item_ql_ecall_get_system_type(void)
{
    ECALL_SYSTEM_STD_E system_std;
    ql_ecall_get_system_std(&system_std);
    if(system_std == ECALL_SYSTEM_STD_PAN_EUROPEAN)
    {
        printf("Ecall system type set to ECALL_SYSTEM_STD_PAN_EUROPEAN.\n");
    }
    else if (system_std == ECALL_SYSTEM_STD_ERA_GLONASS)
    {
        printf("Ecall system type set to ECALL_SYSTEM_STD_ERA_GLONASS.\n");
    }
    else
    {
        printf("Ecall system type set to unsupported value.\n");
    }
}

void item_ql_ecall_set_msd_vehicle_type(void)
{
    int ret = 0;
    uint8_t index=0;

    printf("Please input VehicleType:\n");
    printf("MSD_VEHICLE_PASSENGER_M1=1\n");
    printf("MSD_VEHICLE_BUS_M2=2\n");
    printf("MSD_VEHICLE_BUS_M3=3\n");
    printf("MSD_VEHICLE_COMMERCIAL_N1=4\n");
    printf("MSD_VEHICLE_HEAVY_N2=5\n");
    printf("MSD_VEHICLE_HEAVY_N3=6\n");
    printf("MSD_VEHICLE_MOTORCYCLE_L1E=7\n");
    printf("MSD_VEHICLE_MOTORCYCLE_L2E=8\n");
    printf("MSD_VEHICLE_MOTORCYCLE_L3E=9\n");
    printf("MSD_VEHICLE_MOTORCYCLE_L4E=10\n");
    printf("MSD_VEHICLE_MOTORCYCLE_L5E=11\n");
    printf("MSD_VEHICLE_MOTORCYCLE_L6E=12\n");
    printf("MSD_VEHICLE_MOTORCYCLE_L7E=13\n");

    scanf("%hhd", &index);
    getchar();

    ret = ql_ecall_set_msd_vehicle_type(index);
    printf(" ql_ecall_set_msd_vehicle_type ret = %d\n", ret);

}

void item_ql_ecall_get_msd_vehicle_type(void)
{
    uint8_t vehicleType = 0;
    ql_ecall_get_msd_vehicle_type(&vehicleType);
    printf("VehicalType is set to: %u\n", vehicleType);

}

void item_ql_ecall_set_msd_position(void)
{
    int ret = 0;
    int32_t latitude, longitude, direction = 0;

    printf("Please input latitude(example:+48898064):\n");
    scanf("%d", &latitude);
    getchar();

    printf("Please input longitude(example:+2218092):\n");
    scanf("%d", &longitude);
    getchar();

    printf("Please input direction(example:0):\n");
    scanf("%d", &direction);
    getchar();

    ret = ql_ecall_set_msd_position(true, latitude, longitude, direction);
    printf(" ql_ecall_set_msd_position ret = %d\n", ret);
}

void item_ql_ecall_set_msd_position1(void)
{
    int ret = 0;
    int32_t latitudeDeltaN1, longitudeDeltaN1 = 0;

    printf("Please input latitudeDeltaN1(-512 ~ 511):\n");
    scanf("%d", &latitudeDeltaN1);
    getchar();

    printf("Please input longitudeDeltaN1(-512 ~ 511):\n");
    scanf("%d", &longitudeDeltaN1);
    getchar();

    ret = ql_ecall_set_msd_position_n1(latitudeDeltaN1, longitudeDeltaN1);
    printf(" ql_ecall_set_msd_position_n1 ret = %d\n", ret);
}

void item_ql_ecall_set_msd_position2(void)
{
    int ret = 0;
    int32_t latitudeDeltaN2, longitudeDeltaN2 = 0;

    printf("Please input latitudeDeltaN2(-512 ~ 511):\n");
    scanf("%d", &latitudeDeltaN2);
    getchar();

    printf("Please input longitudeDeltaN2(-512 ~ 511):\n");
    scanf("%d", &longitudeDeltaN2);
    getchar();

    ret = ql_ecall_set_msd_position_n2(latitudeDeltaN2, longitudeDeltaN2);
    printf(" ql_ecall_set_msd_position_n2 ret = %d\n", ret);
}

void item_ql_ecall_set_number_of_passengers(void)
{
//    int ret = 0;
    uint8_t numberOfPassengers=0;

    printf("Please input msd numberOfPassengers:\n");
    if(1 != scanf("%hhd", &numberOfPassengers))
        return;
    getchar();

    ql_ecall_set_msd_passengers_count(numberOfPassengers);
}

void item_ql_ecall_set_msd_propulsion_type(void)
{
//    int ret = 0;
    uint8_t propulsionType = 0;

    printf("Please input vehicle propulsion type:\n");
    printf("ECALL_MSD_PROPULSION_TYPE_GASOLINE=0x1\n");
    printf("ECALL_MSD_PROPULSION_TYPE_DIESEL=0x2\n");
    printf("ECALL_MSD_PROPULSION_TYPE_NATURALGAS=0x4\n");
    printf("ECALL_MSD_PROPULSION_TYPE_PROPANE=0x8\n");
    printf("ECALL_MSD_PROPULSION_TYPE_ELECTRIC=0x10\n");
    printf("ECALL_MSD_PROPULSION_TYPE_HYDROGEN=0x20\n");
    printf("ECALL_MSD_PROPULSION_TYPE_OTHER=0x40\n");

    scanf("%hhx", &propulsionType);
    getchar();

    ql_ecall_set_msd_propulsion_type(propulsionType);
}

void item_ql_ecall_get_msd_propulsion_type(void)
{
    uint8_t propulsionType = 0;

    ql_ecall_get_msd_propulsion_type(&propulsionType);

    printf("PropulsionType set to: 0x%x\n", propulsionType);

}

void item_ql_ecall_get_msd_call_type(void)
{

    bool type;
    ql_ecall_get_msd_call_type(&type);

    printf(" item_ql_ecall_get_msd_call_type type = %s\n", type ? "Test" : "Emergency" );
}

void item_ql_ecall_set_msd_call_type(void)
{
    uint8_t index = 0;
    printf("Input call type: Test(0) Emergency(1)\n");
    scanf("%hhd", &index);
    getchar();

    ql_ecall_set_msd_call_type(index == 0);

    printf(" ql_ecall_set_msd_call_type type = %d\n", index);
}


void item_ql_ecall_set_msd_vin(void)
{
    int ret = 0;
    uint8_t index = 0;
    msd_Vin_t vin = {0};
    char* find = NULL;
    char vin_str[QL_ECALL_MAX_VIN];

    printf("Input: default(0) other(1)\n");
    scanf("%hhd", &index);
    getchar();
    if(index)
    {
        printf("Please insert VIN:\n");
        fgets(vin_str, QL_ECALL_MAX_VIN-1, stdin);
        find = strchr(vin_str, '\n');
        if(find)
        {
            *find = '\0';
        }
        // example 1: WM9VDSVDSYA123456
        // example 2: 4Y1SL65848Z411439
        // example 3: VF37BRFVE12345678
        memcpy(&vin.isowmi, vin_str,3);
        memcpy(&vin.isovds, (vin_str+3),6);
        memcpy(&vin.isovisModelyear, (vin_str+9) ,1);
        memcpy(&vin.isovisSeqPlant,  (vin_str+10) ,7);
        printf("isowmi:%s isovds:%s isovisModelyear:%s,isovisSeqPlant:%s\n",vin.isowmi,vin.isovds,vin.isovisModelyear,vin.isovisSeqPlant);
    }
    else
    {
        memcpy(&vin.isowmi,"WM9",3);
        memcpy(&vin.isovds,"VDSVDS",6);
        memcpy(&vin.isovisModelyear,"Y",1);
        memcpy(&vin.isovisSeqPlant,"A123456",7);
        printf("isowmi:%s isovds:%s isovisModelyear:%s,isovisSeqPlant:%s\n",vin.isowmi,vin.isovds,vin.isovisModelyear,vin.isovisSeqPlant);
    }

    ret = ql_ecall_set_msd_vin(vin);
    printf(" ql_ecall_set_msd_vin ret = %d\n", ret);
}

void item_ql_ecall_get_msd_vin(void)
{
    int ret = 0;
    msd_Vin_t vin;
    char vin_str[QL_ECALL_MAX_VIN];

    ret = ql_ecall_get_msd_vin(&vin);
    if(0<strlen(vin.isowmi)&&0<strlen(vin.isovds)&&0<strlen(vin.isovisModelyear)&&0<strlen(vin.isovisSeqPlant))
    {
        sprintf(vin_str,"%s%s%s%s",vin.isowmi,vin.isovds,vin.isovisModelyear,vin.isovisSeqPlant);
    }
    else
    {
        printf(" vin is NULL\n");
        return;
    }
    printf(" ql_ecall_get_msd_vin ret = %d\n", ret);

    printf("VIN=%s\n",vin_str);
}

void item_ql_ecall_set_msd_tx_mode(void)
{
    int ret = 0;
    uint8_t index = 0;

    printf("Please choose MSD Tx Mode: PULL(0) PUSH(1)\n");
    scanf("%hhd", &index);
    getchar();

    if(index == 0)
    {
        ret = ql_ecall_set_msd_tx_mode(QL_ECALL_TX_MODE_PULL);
        printf(" ql_ecall_set_msd_tx_mode ret = %d\n", ret);
    }
    else if(index == 1)
    {
        ret = ql_ecall_set_msd_tx_mode(QL_ECALL_TX_MODE_PUSH);
        printf(" ql_ecall_set_msd_tx_mode ret = %d\n", ret);
    }
    else
    {
        printf("Unsupported MSD transmission mode.\n");
    }
}

void item_ql_ecall_get_msd_tx_mode(void)
{
    QL_ECALL_MSD_TX_MODE_E tx_mode;

    ql_ecall_get_msd_tx_mode(&tx_mode);
    if(tx_mode == QL_ECALL_TX_MODE_PULL)
    {
        printf("MSD Transmission mode is set to QL_ECALL_TX_MODE_PULL\n");
    }
    else if (tx_mode == QL_ECALL_TX_MODE_PUSH)
    {
        printf("MSD Transmission mode is set to QL_ECALL_TX_MODE_PUSH\n");
    }
}

void item_ql_ecall_start_test(void)
{
    int ret = 0;
    int sim_id;

    printf("please enter the sim_id: ");
    ret = scanf("%d", &sim_id);
    getchar();

    if(!QL_IS_SIM_VALID(sim_id))
    {
        printf("invalid sim_id\n");
        return;
    }

    ret = ql_ecall_start_test(sim_id);
    printf(" ql_ecall_start_test ret = %d\n", ret);
}

void item_ql_ecall_start_manual(void)
{
    int ret = 0;
    int sim_id;

    printf("please enter the sim_id: ");
    ret = scanf("%d", &sim_id);
    getchar();

    if(!QL_IS_SIM_VALID(sim_id))
    {
        printf("invalid sim_id\n");
        return;
    }

    ret = ql_ecall_start_manual(sim_id);
    printf(" ql_ecall_start_manual ret = %d\n", ret);
}

void item_ql_ecall_start_automatic(void)
{
    int ret = 0;
    int sim_id;

    printf("please enter the sim_id: ");
    ret = scanf("%d", &sim_id);
    getchar();

    if(!QL_IS_SIM_VALID(sim_id))
    {
        printf("invalid sim_id\n");
        return;
    }

    ret = ql_ecall_start_automatic(sim_id);
    printf(" ql_ecall_start_automatic ret = %d\n", ret);
}

void item_ql_ecall_terminate_nw_registration(void)
{
    int ret;

    ret = ql_ecall_terminate_nw_registration();
    if(ret == QL_ERR_OK)
    {
        printf("ok\n");
    }
    else
    {
        printf("failed, ret = %d\n", ret);
    }
}

void item_ql_ecall_set_interval_between_attempts(void)
{
    uint16_t interval = 0;

    printf("Please input interval between attempts in seconds:\n");
    scanf("%hd", &interval);
    getchar();

    ql_ecall_set_interval_between_dial_attempts(interval);
}

void item_ql_ecall_get_interval_between_attempts(void)
{
    uint16_t interval = 0;
    ql_ecall_get_interval_between_dial_attempts(&interval);

    printf("Interval between attempts is set to %hd seconds:\n", interval);

}

void item_ql_ecall_update_msd (void)
{
    int ret = 0;
    ret = ql_ecall_update_msd();
    if (ret == QL_ERR_OK)
    {
        printf("ok\n");
    }
    else
    {
        printf("failed, ret = %d\n", ret);
    }
}

void item_ql_ecall_set_config_info(void)
{
    ql_ecall_config_t ecall_context_info;
    memset(&ecall_context_info, 0, sizeof(ql_ecall_config_t));

    printf("Whether the time of T5 timer is valid(0:no, 1:yes):\n");
    scanf("%hhd", &ecall_context_info.t5_timeout_ms_valid);
    getchar();
    if(ecall_context_info.t5_timeout_ms_valid)
    {
        printf("please input the time of T5 timer(example:5000ms):\n");
        scanf("%hd", &ecall_context_info.t5_timeout_ms);
        getchar();
    }

    printf("Whether the time of T6 timer is valid(0:no, 1:yes):\n");
    scanf("%hhd", &ecall_context_info.t6_timeout_ms_valid);
    getchar();
    if(ecall_context_info.t6_timeout_ms_valid)
    {
        printf("please input the time of T6 timer(example:5000ms):\n");
        scanf("%hd", &ecall_context_info.t6_timeout_ms);
        getchar();
    }

    printf("Whether the time of T7 timer is valid(0:no, 1:yes):\n");
    scanf("%hhd", &ecall_context_info.t7_timeout_ms_valid);
    getchar();
    if(ecall_context_info.t7_timeout_ms_valid)
    {
        printf("please input the time of T7 timer(example:20000ms):\n");
        scanf("%hd", &ecall_context_info.t7_timeout_ms);
        getchar();
    }

    printf("Whether the time of auto answer timer is valid(0:no, 1:yes):\n");
    scanf("%hhd", &ecall_context_info.autoAnswer_timeout_ms_valid);
    getchar();
    if(ecall_context_info.autoAnswer_timeout_ms_valid)
    {
        printf("please input the time of auto answer  timer(example:3600000ms):\n");
        scanf("%d", &ecall_context_info.autoAnswer_timeout_ms);
        getchar();
    }

    printf("Whether the time of dialDurationTimer is valid(0:no, 1:yes):\n");
    scanf("%hhd", &ecall_context_info.dialDurationTimer_timout_ms_valid);
    getchar();
    if(ecall_context_info.dialDurationTimer_timout_ms_valid)
    {
        printf("please input the time of dialDurationTimer(example:120000ms):\n");
        scanf("%d", &ecall_context_info.dialDurationTimer_timout_ms);
        getchar();
    }

    printf("(Not supported)Whether the maxDialAttempts is valid(0:no, 1:yes):\n");
    scanf("%hhd", &ecall_context_info.maxDialAttempts_valid);
    getchar();
    if(ecall_context_info.maxDialAttempts_valid)
    {
        printf("please input maxDialAttempts:\n");
        scanf("%d", &ecall_context_info.maxDialAttempts);
        getchar();
    }

    printf("(Not supported)Whether the intervalBetweenAttempts is valid(0:no, 1:yes):\n");
    scanf("%hhd", &ecall_context_info.intervalBetweenAttempts_valid);
    getchar();
    if(ecall_context_info.intervalBetweenAttempts_valid)
    {
        printf("please input intervalBetweenAttempts(example:30s):\n");
        scanf("%hd", &ecall_context_info.intervalBetweenAttempts);
        getchar();
    }

    printf("(Not supported)Whether the resetEcallSessionMode is valid(0:no, 1:yes):\n");
    scanf("%hhd", &ecall_context_info.resetEcallSessionMode_valid);
    getchar();
    if(ecall_context_info.resetEcallSessionMode_valid)
    {
        printf("please input resetEcallSessionMode(example: 1,autoanswer):\n");
        scanf("%hhd", &ecall_context_info.resetEcallSessionMode);
        getchar();
    }

    ql_ecall_set_config_info(ecall_context_info);
    printf("ok!\n");
}

void item_ql_ecall_get_config_info(void)
{
    ql_ecall_config_t ecall_context_info;

    ql_ecall_get_config_info(&ecall_context_info);

    printf("ok!\n");
    printf("the time of T5 timer is %hd\n", ecall_context_info.t5_timeout_ms);
    printf("the time of T6 timer is %hd\n", ecall_context_info.t6_timeout_ms);
    printf("the time of T7 timer is %hd\n", ecall_context_info.t7_timeout_ms);
    printf("the time of dialDurationTimer is %d\n", ecall_context_info.dialDurationTimer_timout_ms);
    printf("the maximum redial attempts is %d\n", ecall_context_info.maxDialAttempts);
    //printf("the interval value between dial attempts is %hd\n", ecall_context_info.intervalBetweenAttempts);
}

void item_ql_ecall_set_ecall_only_mode(void)
{
    int ret = 0;
    int ecall_only_value = 0;

    printf("ecall set ecall only mode(0:disable,1:enable): \n");
    scanf("%d", &ecall_only_value);
    getchar();

    ret = ql_ecall_set_ecall_only_mode(ecall_only_value);
    printf(" ql_ecall_set_ecall_only_mode ret = %d\n", ret);
}

static t_item_t ql_ecall_items[] =
{
    {"ql_ecall_init", item_ql_ecall_init},
    {"ql_ecall_dial", item_ql_ecall_dial},
    {"ql_ecall_start_test", item_ql_ecall_start_test},
    {"ql_ecall_start_manual", item_ql_ecall_start_manual},
    {"ql_ecall_start_automatic", item_ql_ecall_start_automatic},
    {"ql_ecall_hangup", item_ql_ecall_hangup},
    {"ql_ecall_set_user_ind_cb", item_ql_ecall_set_user_ind_cb},
    {"ql_voice_ecall_set_test_number", item_ql_ecall_set_test_number},
    {"ql_ecall_set_system_type", item_ql_ecall_set_system_type},
    {"ql_ecall_get_system_type", item_ql_ecall_get_system_type},
    {"ql_ecall_update_msd_raw", item_ql_ecall_update_msd_raw},
    {"ql_ecall_push_msd", item_ql_ecall_push_msd},
    {"ql_voice_ecall_reset_ivs", item_ql_ecall_reset_ivs},
    {"ql_ecall_set_msd_call_type", item_ql_ecall_set_msd_call_type},
    {"ql_ecall_get_msd_call_type", item_ql_ecall_get_msd_call_type},
    {"ql_ecall_set_msd_vin", item_ql_ecall_set_msd_vin},
    {"ql_ecall_get_msd_vin", item_ql_ecall_get_msd_vin},
    {"ql_ecall_set_msd_version", item_ql_ecall_set_msd_version},
    {"ql_ecall_get_msd_version", item_ql_ecall_get_msd_version},
    {"ql_ecall_set_msd_tx_mode", item_ql_ecall_set_msd_tx_mode},
    {"ql_ecall_get_msd_tx_mode", item_ql_ecall_get_msd_tx_mode},
    {"ql_ecall_set_msd_position", item_ql_ecall_set_msd_position},
    {"ql_ecall_set_msd_position1", item_ql_ecall_set_msd_position1},
    {"ql_ecall_set_msd_position2", item_ql_ecall_set_msd_position2},
    {"ql_ecall_set_msd_vehicle_type", item_ql_ecall_set_msd_vehicle_type},
    {"ql_ecall_get_msd_vehicle_type", item_ql_ecall_get_msd_vehicle_type},
    {"ql_ecall_set_number_of_passengers", item_ql_ecall_set_number_of_passengers},
    {"ql_ecall_set_msd_propulsion_type", item_ql_ecall_set_msd_propulsion_type},
    {"ql_ecall_get_msd_propulsion_type", item_ql_ecall_get_msd_propulsion_type},
    {"ql_ecall_terminate_nw_registration", item_ql_ecall_terminate_nw_registration},
    {"ql_ecall_set_interval_between_attempts", item_ql_ecall_set_interval_between_attempts},
    {"ql_ecall_get_interval_between_attempts", item_ql_ecall_get_interval_between_attempts},
    {"ql_ecall_update_msd", item_ql_ecall_update_msd},
    {"ql_ecall_set_config_info", item_ql_ecall_set_config_info},
    {"ql_ecall_get_config_info", item_ql_ecall_get_config_info},
    {"ql_ecall_set_ecall_only_mode", item_ql_ecall_set_ecall_only_mode},
    {"ql_ecall_deinit", item_ql_ecall_deinit}
};

static void help()
{
    int i = 0;
    printf("Test Items:\n");
    while(i < ARRAY_SIZE(ql_ecall_items)) {
        printf("%d : %s\n", i, ql_ecall_items[i].name);
        i++;
    }
    printf(":");
}

int main(int argc, char *argv[])
{
    char cmd[1024];
    help();
    while(1)
    {
        memset(cmd, 0, sizeof(cmd));
        if(fgets(cmd, sizeof(cmd), stdin))
        {
            char *ptr = cmd + strlen(cmd) - 1;
            while(ptr >= cmd && (*ptr == '\r' || *ptr == '\n'))
            {
                *ptr-- = '\0';
            }

            if(strlen(cmd) > 0) {
                if(isdigit(cmd[0])) {
                    int item = atoi(cmd);
                    if(item >= 0 && item < ARRAY_SIZE(ql_ecall_items)) {
                        ql_ecall_items[item].handle();
                    }
                }
                else if(!strcasecmp(cmd, "h")) {
                    help();
                }
                else if(!strcasecmp(cmd, "q")) {
                    break;
                }
            }
            else {
                printf("\n");
            }
        }
    }
    return 0;
}