mbtk/test/libgsw_lib/gsw_ecall_test.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <signal.h>
#include <pthread.h>
#include <stdbool.h>
#include <dlfcn.h>


static void *ecall_handle = NULL;
typedef struct
{
    int cmdIdx;
    char *funcName;
}st_api_test_case;

#define GSW_EU_ECALL_MAX_MSD          140
#define GSW_EU_ECALL_MAX_PHONE_NUMBER 82

typedef enum
{
    GSW_EU_ECALL_TYPE_TEST      = 1,
    GSW_EU_ECALL_TYPE_EMERGENCY = 2,
    GSW_EU_ECALL_TYPE_RECONFIG  = 3,
} gsw_eu_ecall_type_e;

typedef struct
{
    uint32_t            msd_len;
    uint8_t             msd[GSW_EU_ECALL_MAX_MSD];
    gsw_eu_ecall_type_e type;
    int32_t             auto_trigger;
    char        ecall_number[GSW_EU_ECALL_MAX_PHONE_NUMBER];
} gsw_eu_ecall_info_t;



typedef enum {
    GSW_EU_ECALL_STATE_NONE                 = -1,
    GSW_EU_ECALL_STATE_INACTIVE             =  0,
    GSW_EU_ECALL_STATE_ORIGINATING_CALL     =  1,
    GSW_EU_ECALL_STATE_IN_CALL_TRANSMITTING =  2,
    GSW_EU_ECALL_STATE_WAITING_FOR_AL_ACK   =  3,
    GSW_EU_ECALL_STATE_IN_CALL              =  4,
    GSW_EU_ECALL_STATE_IDLE_ALLOW_MT_ECALL  =  5,
} gsw_eu_ecall_state_e;

typedef enum {
    GSW_EU_ECALL_MODE_NORMAL  = 0,
    GSW_EU_ECALL_MODE_ONLY    = 1,
    GSW_EU_ECALL_MODE_DEFAULT = 2,
} gsw_eu_ecall_mode_e;


typedef struct
{
    uint8_t  enable;
    uint8_t  voice_mute;
    gsw_eu_ecall_mode_e mode;
    uint8_t  report_event;
    uint16_t start_timer;
    uint16_t hack_timer;
    uint16_t trans_timer;
    uint8_t  fail_redial;
    uint8_t  drop_redial;
    uint16_t cleardown_timer;
    uint16_t init_timer;
    uint16_t nad_reg_timer;
    uint16_t nad_dereg_timer;
    uint8_t  standard;
    uint16_t era_glonass_redial;
    uint16_t auto_answer; //auto_answer
} gsw_eu_ecall_config_t;

typedef enum {
    GSW_EU_ECALL_CONFIG_ENABLE             = (1 << 0),
    GSW_EU_ECALL_CONFIG_VOICE_MUTE         = (1 << 1),
    GSW_EU_ECALL_CONFIG_MODE               = (1 << 2),
    GSW_EU_ECALL_CONFIG_REPORT_EVENT       = (1 << 3),
    GSW_EU_ECALL_CONFIG_START_TIMER        = (1 << 4),
    GSW_EU_ECALL_CONFIG_HACK_TIMER         = (1 << 5),
    GSW_EU_ECALL_CONFIG_TRANS_TIMER        = (1 << 6),
    GSW_EU_ECALL_CONFIG_FAIL_REDIAL        = (1 << 7),
    GSW_EU_ECALL_CONFIG_DROP_REDIAL        = (1 << 8),
    GSW_EU_ECALL_CONFIG_CLEARDOWN_TIMER    = (1 << 9),
    GSW_EU_ECALL_CONFIG_INIT_TIMER         = (1 << 10),
    GSW_EU_ECALL_CONFIG_NAD_REG_TIMER      = (1 << 11),
    GSW_EU_ECALL_CONFIG_NAD_DEREG_TIMER    = (1 << 12),
    GSW_EU_ECALL_CONFIG_STANDARD           = (1 << 13),
    GSW_EU_ECALL_CONFIG_ERA_GLONASS_REDIAL = (1 << 14),
    GSW_EU_ECALL_CONFIG_AUTO_ANSWER        = (1 << 15),
} gsw_eu_ecall_config_e;

typedef enum {
    GSW_EU_ECALL_EVENT_FAIL_NONE                        = 0,
    GSW_EU_ECALL_EVENT_FAIL_TIMEOUT                     = 1,
    GSW_EU_ECALL_EVENT_FAIL_HACK_TIMEOUT                = 2,
    GSW_EU_ECALL_EVENT_FAIL_MSD_TRANS_TIMEOUT           = 3,
    GSW_EU_ECALL_EVENT_FAIL_IVS_RESET_TIMEOUT           = 4,
    GSW_EU_ECALL_EVENT_FAIL_CLEAR_DOWN_FALLBACK_TIMEOUT = 5,
    GSW_EU_ECALL_EVENT_FAIL_IVS_INITIATION_TIMEOUT      = 6,
} gsw_eu_ecall_event_fail_e;

typedef enum {
    GSW_EU_ECALL_EVENT_PROCESS_IVS_NONE               = 0,
    GSW_EU_ECALL_EVENT_PROCESS_IVS_START_RECEIVED_MSD = 1,
    GSW_EU_ECALL_EVENT_PROCESS_IVS_NACK_RECEIVED      = 2,
    GSW_EU_ECALL_EVENT_PROCESS_IVS_ACK_RECEIVED       = 3,
    GSW_EU_ECALL_EVENT_PROCESS_IVS_TX_COMPLETED       = 4,
    GSW_EU_ECALL_EVENT_PROCESS_IVS_HLACK_RECEIVED     = 5,
} gsw_eu_ecall_event_process_e;

typedef enum {
    GSW_EU_ECALL_EVENT_MSDUPADTE_NONE                   = -1,
    GSW_EU_ECALL_EVENT_MSDUPDATE_IVS_UPDATING_MSD       =  0,
    GSW_EU_ECALL_EVENT_MSDUPDATE_PSAP_REQURE_UPDATE_MSD =  1,
    GSW_EU_ECALL_EVENT_MSDUPDATE_IVS_UPDATE_MSD_TIMEOUT =  2,
} gsw_eu_ecall_event_msdupdate_e;

typedef enum {
    GSW_EU_ECALL_EVENT_ESTABLISH_NONE     = -1,
    GSW_EU_ECALL_EVENT_ESTABLISH_SUCCESS  =  0,
    GSW_EU_ECALL_EVENT_ESTABLISH_FAIL     =  1,
} gsw_eu_ecall_event_establish_e;

typedef enum {
    GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE                          = -1,
    GSW_EU_ECALL_EVENT_EXTEND_STATE_START_RECV_SYN                =  0,
    GSW_EU_ECALL_EVENT_EXTEND_STATE_T9_TIMEOUT                    =  1,
    GSW_EU_ECALL_EVENT_EXTEND_STATE_T10_TIMEOUT                   =  2,
    GSW_EU_ECALL_EVENT_EXTEND_STATE_IVS_ALACK_RECEIVED            =  3,
    GSW_EU_ECALL_EVENT_EXTEND_STATE_IVS_LLACK_RECEIVED            =  4,
    GSW_EU_ECALL_EVENT_EXTEND_STATE_STOPPED                       =  5,
    GSW_EU_ECALL_EVENT_EXTEND_STATE_ANSWERING_INCOMING_PSAP_ECALL =  6,
    GSW_EU_ECALL_EVENT_EXTEND_STATE_CLEARDOWN_RECEIVED            =  7,
    GSW_EU_ECALL_EVENT_EXTEND_STATE_CALLBACK_TIMEOUT              =  8,
    GSW_EU_ECALL_EVENT_IVS_NORMAL_CLEARING                        =  9,
    GSW_EU_ECALL_EVENT_IVS_ABNORMAL_CLEARING                      =  10,
} gsw_eu_ecall_event_extend_state_e;

typedef struct
{
    uint8_t  ori_remainder_times;
    uint16_t time;
} gsw_eu_ecall_event_originate_fail_redial_t;

typedef struct
{
    uint8_t  drop_remainder_times;
    uint16_t time; /* The minimum time duration between the previous call attempt */
} gsw_eu_ecall_event_drop_redial_t;


typedef struct
{
    gsw_eu_ecall_event_fail_e                  fail;
    gsw_eu_ecall_event_process_e               process;
    gsw_eu_ecall_event_msdupdate_e             msdupdate;
    gsw_eu_ecall_event_establish_e             establish;
    uint16_t                                   hack_code;
    gsw_eu_ecall_event_originate_fail_redial_t ori_redial;
    gsw_eu_ecall_event_drop_redial_t           drop_redial;
    gsw_eu_ecall_event_extend_state_e          extend_state;
} gsw_eu_ecall_event_t;

typedef void (*gsw_eu_ecall_event_cb_f)(gsw_eu_ecall_event_t *p_event);


typedef enum {
    GSW_EU_ECALL_MSD_TRANS_STATUS_NONE     = -1,
    GSW_EU_ECALL_MSD_TRANS_STATUS_SUCCESS  =  0,
    GSW_EU_ECALL_MSD_TRANS_STATUS_FAILURE  =  1,
} gsw_eu_ecall_msd_trans_status_e;

typedef void (*gsw_eu_ecall_status_cb_f)(uint32_t id, gsw_eu_ecall_msd_trans_status_e status);



typedef int32_t (*gsw_eu_ecall_voice_init)(void);


typedef int32_t (*gsw_eu_ecall_voice_deinit)(void);
typedef int32_t (*gsw_eu_ecall_start)(gsw_eu_ecall_info_t *p_info);  
typedef int32_t (*gsw_eu_ecall_hangup)(void);   
typedef int32_t (*gsw_eu_ecall_updateMsd)(const uint8_t *msd, uint32_t msd_len);    
typedef int32_t (*gsw_eu_ecall_pushMsd)(gsw_eu_ecall_state_e state);    
typedef int32_t (*gsw_eu_ecall_getConfig)(gsw_eu_ecall_config_t *p_config);    
typedef int32_t (*gsw_eu_ecall_setConfig)(int32_t item, gsw_eu_ecall_config_t *p_config);    
typedef int32_t (*gsw_eu_ecall_setEventCB)(gsw_eu_ecall_event_cb_f cb);    
typedef int32_t (*gsw_eu_ecall_setStatusCB)(gsw_eu_ecall_status_cb_f cb);

st_api_test_case api_testcases[] = 
{
    {0,    "print_help"},
    {1,    "gsw_eu_ecall_voice_init"},
    {2,    "gsw_eu_ecall_voice_deinit"},
    {3,    "gsw_eu_ecall_start"},
    {4,    "gsw_eu_ecall_hangup"},
    {5,    "gsw_eu_ecall_updateMsd"},
    {6,    "gsw_eu_ecall_pushMsd"},
    {7,    "gsw_eu_ecall_getConfig"},
    {8,    "gsw_eu_ecall_setConfig"},
    {9,    "gsw_eu_ecall_setEventCB"},
    {10,   "gsw_eu_ecall_setStatusCB"},
    {-1,   NULL}
    
};
void sigint_handler(int sig)
{
    printf("sigint_handler\n");
    dlclose(ecall_handle);
    ecall_handle = NULL;

    exit(0);
}
static void gsw_eu_ecall_status_cb(uint32_t id, gsw_eu_ecall_msd_trans_status_e status)
{
    printf("id is %u\n",id);
    printf("status is %d\n",status);

}


static void gsw_eu_ecall_event_cb(gsw_eu_ecall_event_t *p_event)
{
    printf("p_event->fail: %ud\n",p_event->fail);
    printf("p_event->process: %d\n",p_event->process);
    printf("p_event->msdupdate:  %d\n",p_event->msdupdate);
    printf("p_event->establish: %d\n",p_event->establish);
    printf("p_event->hack_code: %d\n",p_event->hack_code);
    printf("p_event->ori_redial.ori_remainder_times: %d\n",p_event->ori_redial.ori_remainder_times);
    printf("p_event->ori_redial.time: %d\n",p_event->ori_redial.time);
    printf("p_event->drop_redial.drop_remainder_times: %d\n",p_event->drop_redial.drop_remainder_times);
    printf("p_event->drop_redial.time: %d\n",p_event->drop_redial.time);
    printf("p_event->extend_state: %d\n",p_event->extend_state);

}


static void set_config(gsw_eu_ecall_config_t *p_config)
{   
 
    int ret = -1;   
    p_config->enable = 0;
    p_config->voice_mute = 0;
    p_config->mode = 0;
    p_config->report_event = 0;
    p_config->start_timer = 0;
    p_config->hack_timer = 0;
    p_config->trans_timer = 0;
    p_config->cleardown_timer = 0;
    p_config->drop_redial = 0;
    p_config->init_timer = 0;
    p_config->nad_reg_timer = 0;
    p_config->nad_dereg_timer = 0;
    p_config->standard = 0;
    p_config->era_glonass_redial = 0;
    p_config->auto_answer = 0;
    
    printf("input p_config->fail_redial\n");
    ret = scanf("%hhu", &p_config->fail_redial);
    if(ret)
    {
        printf("input ret is %d\n",ret);
    }
    

}

static void print_get_config(gsw_eu_ecall_config_t p_config)
{   
    
    printf("input p_config.enable: %d\n",p_config.enable);
    printf("input p_config.voice_mute:%d\n",p_config.voice_mute);
    printf("input p_config.mode:%d\n",p_config.mode);
    printf("input p_config.report_event:%d\n",p_config.report_event);
    printf("input p_config.start_timer:%d\n",p_config.start_timer);
    printf("input p_config.hack_timer:%d\n",p_config.hack_timer);
    printf("input p_config.trans_timer:%d\n",p_config.start_timer);
    printf("input p_config.fail_redial:%d\n",p_config.fail_redial);
    printf("input p_config.drop_redial:%d\n",p_config.drop_redial);
    printf("input p_config.cleardown_timer:%d\n",p_config.cleardown_timer);
    printf("input p_config.init_timer:%d\n",p_config.init_timer);
    printf("input p_config.nad_reg_timer:%d\n",p_config.nad_reg_timer);
    printf("input p_config.nad_dereg_timer:%d\n",p_config.nad_dereg_timer);
    printf("input p_config.standard:%d\n",p_config.standard);
    printf("input p_config.era_glonass_redial:%d\n",p_config.era_glonass_redial);
    printf("input p_config.auto_answer:%d\n",p_config.auto_answer);
    

}
void print_help(void)
{
    int i;

    printf("Supported test cases:\n");
    for(i = 0; ; i++)
    {
        if(api_testcases[i].cmdIdx == -1)
        {
            break;
        }
        printf("%d:\t%s\n", api_testcases[i].cmdIdx, api_testcases[i].funcName);
    }
}



//static ecall_init_flag = 0;
int main(int argc,char *argv[])
{
    gsw_eu_ecall_voice_init gsw_eu_ecall_voice_init_ptr = NULL;
    gsw_eu_ecall_voice_deinit gsw_eu_ecall_voice_deinit_ptr = NULL;
    gsw_eu_ecall_start gsw_eu_ecall_start_ptr = NULL;
    gsw_eu_ecall_hangup gsw_eu_ecall_hangup_ptr = NULL;
    gsw_eu_ecall_updateMsd gsw_eu_ecall_updateMsd_ptr = NULL;
    gsw_eu_ecall_pushMsd gsw_eu_ecall_pushMsd_ptr = NULL;
    gsw_eu_ecall_getConfig gsw_eu_ecall_getConfig_ptr = NULL;
    gsw_eu_ecall_setConfig gsw_eu_ecall_setConfig_ptr = NULL;
    gsw_eu_ecall_setEventCB gsw_eu_ecall_setEventCB_ptr = NULL;
    gsw_eu_ecall_setStatusCB gsw_eu_ecall_setStatusCB_ptr = NULL;

    void *ota_handle = dlopen("/lib/libgsw_lib.so", RTLD_NOW );
    if(ota_handle == NULL)
    {
            printf("open lib failed\n");
            return -1;
    }


    signal(SIGINT, sigint_handler);
    
    ecall_handle = dlopen("/lib/libgsw_lib.so", RTLD_NOW );
    if(ecall_handle == NULL)
    {
            printf("open lib failed\n");
            return -1;
    }
    gsw_eu_ecall_voice_init_ptr = (gsw_eu_ecall_voice_init)dlsym(ecall_handle, "gsw_eu_ecall_voice_init");
    if(gsw_eu_ecall_voice_init_ptr == NULL)
    {
            printf("dlsym gsw_eu_ecall_voice_init failed\n");
            return -1;
    }
    gsw_eu_ecall_voice_deinit_ptr = (gsw_eu_ecall_voice_deinit)dlsym(ecall_handle, "gsw_eu_ecall_voice_deinit");
    if(gsw_eu_ecall_voice_deinit_ptr == NULL)
    {
            printf("dlsym gsw_eu_ecall_voice_deinit failed\n");
            return -1;
    }
    gsw_eu_ecall_start_ptr = (gsw_eu_ecall_start)dlsym(ecall_handle, "gsw_eu_ecall_start");
    if(gsw_eu_ecall_start_ptr == NULL)
    {
            printf("dlsym gsw_eu_ecall_start failed\n");
            return -1;
    }
    gsw_eu_ecall_hangup_ptr = (gsw_eu_ecall_hangup)dlsym(ecall_handle, "gsw_eu_ecall_hangup");
    if(gsw_eu_ecall_hangup_ptr == NULL)
    {
            printf("dlsym gsw_eu_ecall_hangup failed\n");
            return -1;
    }
    gsw_eu_ecall_updateMsd_ptr = (gsw_eu_ecall_updateMsd)dlsym(ecall_handle, "gsw_eu_ecall_updateMsd");
    if(gsw_eu_ecall_updateMsd_ptr == NULL)
    {
            printf("dlsym gsw_eu_ecall_updateMsd failed\n");
            return -1;
    }
    gsw_eu_ecall_pushMsd_ptr = (gsw_eu_ecall_pushMsd)dlsym(ecall_handle, "gsw_eu_ecall_pushMsd");
    if(gsw_eu_ecall_pushMsd_ptr == NULL)
    {
            printf("dlsym gsw_eu_ecall_pushMsd failed\n");
            return -1;
    }
    gsw_eu_ecall_getConfig_ptr = (gsw_eu_ecall_getConfig)dlsym(ecall_handle, "gsw_eu_ecall_getConfig");
    if(gsw_eu_ecall_getConfig_ptr == NULL)
    {
            printf("dlsym gsw_eu_ecall_getConfig failed\n");
            return -1;
    }
    gsw_eu_ecall_setConfig_ptr = (gsw_eu_ecall_setConfig)dlsym(ecall_handle, "gsw_eu_ecall_setConfig");
    if(gsw_eu_ecall_setConfig_ptr == NULL)
    {
            printf("dlsym gsw_eu_ecall_setConfig failed\n");
            return -1;
    }
    gsw_eu_ecall_setEventCB_ptr = (gsw_eu_ecall_setEventCB)dlsym(ecall_handle, "gsw_eu_ecall_setEventCB");
    if(gsw_eu_ecall_setEventCB_ptr == NULL)
    {
            printf("dlsym gsw_eu_ecall_setEventCB failed\n");
            return -1;
    }   
    gsw_eu_ecall_setStatusCB_ptr = (gsw_eu_ecall_setStatusCB)dlsym(ecall_handle, "gsw_eu_ecall_setStatusCB");
    if(gsw_eu_ecall_setStatusCB_ptr == NULL)
    {
            printf("dlsym gsw_eu_ecall_setStatusCB failed\n");
            return -1;
    }   



    printf("Enter ecall api test \n");
    int opt = -1;
    
    while (1)
    {
        
        print_help();
        int ret = scanf("%d",&opt);
        if (ret == 1)
        {
            printf("输入的整数是：%d\n", opt);
        }
        
        switch(opt)
        {
            case 0 :
            {
                print_help();
                break;
            } 
            case 1 :
            {
                int32_t ret = -1;
                printf("enter gsw_eu_ecall_voice_init");
                ret = gsw_eu_ecall_voice_init_ptr();
                printf("gsw_eu_ecall_voice_init ret = %d\n", ret);
                
                
                break;
            }
            case 2 :
            {
                int32_t ret = -1;
                printf("enter gsw_eu_ecall_voice_deinit\n");
                ret = gsw_eu_ecall_voice_deinit_ptr();
                printf("gsw_eu_ecall_voice_deinit ret = %d\n", ret);
                break;
            }
            case 3 :
            {
                printf("enter gsw_eu_ecall_start\n");
                gsw_eu_ecall_info_t info;
                memset(&info,0,sizeof(info));
                
                int type;
                printf("Enter MSD data (hex values, space-separated): ");
 
                ret = scanf("%140s",info.msd); 
                if(ret)
                {
                    printf("input ret is %d\n",ret);
                }
                info.msd_len = (uint32_t)strlen((char*)info.msd);
                
                
                printf("Enter eCall type (1: Test, 2: Emergency, 3: Reconfig):\n ");
                ret = scanf("%d", &type);
                 if(ret)
                {
                    printf("input ret is %d\n",ret);
                }
                info.type = (gsw_eu_ecall_type_e)type;
                
                printf("Enter auto trigger (0: No, 1: Yes): \n");
                ret=scanf("%d", &info.auto_trigger);
                if(ret)
                {
                    printf("input ret is %d\n",ret);
                }

                if(type == 1 || type == 3)
                {
                    // 输入 eCall 号码
                    printf("Enter eCall number: \n");
                    ret = scanf("%82s", info.ecall_number);
                    if(ret)
                    {
                        printf("input ret is %d\n",ret);
                    }
                }
                ret = gsw_eu_ecall_start_ptr(&info);
                printf("gsw_eu_ecall_start ret = %d\n", ret);
                break;
            }
            case 4 :
            {
                int32_t ret = -1;
                printf("enter gsw_eu_ecall_hangup\n");
                ret = gsw_eu_ecall_hangup_ptr();
                printf("gsw_eu_ecall_hangup ret = %d\n", ret);
                break;
            }
            case 5 :
            {
                uint8_t msd[100] = "235646023026565";
                int32_t ret = -1;
                printf("enter gsw_eu_ecall_updateMsd\n");
                ret = gsw_eu_ecall_updateMsd_ptr(msd, 100);
                printf("gsw_eu_ecall_updateMsd ret = %d\n", ret);
                break;
            }
            case 6 :
            {
                printf("enter gsw_eu_ecall_pushMsd\n");
                gsw_eu_ecall_state_e state = -1;
                int32_t ret = -1;
                ret = gsw_eu_ecall_pushMsd_ptr(state);
                printf("gsw_eu_ecall_pushMsd ret = %d\n", ret);
                break;
            }
            case 7 :
            {
                printf("enter gsw_eu_ecall_getConfig\n");   
                gsw_eu_ecall_config_t config;
                int32_t ret = -1;
                memset(&config,0,sizeof(config));
                ret = gsw_eu_ecall_getConfig_ptr(&config);
                printf("gsw_eu_ecall_getConfig ret = %d\n", ret);
                print_get_config(config);
                break;
            }
            case 8 :
            {
                printf("enter gsw_eu_ecall_setConfig\n");
                gsw_eu_ecall_config_t config;
                //config.ori_timeout = 10;
                int32_t ret = -1;
                int32_t item = 128;
                printf("item value %d\n",item);
                set_config(&config);
                ret = gsw_eu_ecall_setConfig_ptr(item, &config);
                printf("gsw_eu_ecall_setConfig ret = %d\n", ret);
                break;
            }
            case 9 :
            {
                printf("enter gsw_eu_ecall_setEventCB\n");
                //gsw_eu_ecall_event_cb_f cb = NULL;
                int32_t ret = -1;
                ret = gsw_eu_ecall_setEventCB_ptr(gsw_eu_ecall_event_cb);
                printf("gsw_eu_ecall_setEventCB ret = %d\n", ret);
                break;      
            }
            case 10 :
            {
                printf("""enter gsw_eu_ecall_setStatusCB\n");
                int32_t ret = -1;
                ret = gsw_eu_ecall_setStatusCB_ptr(gsw_eu_ecall_status_cb);   
                printf("gsw_eu_ecall_setStatusCB ret = %d\n", ret);     
                break;

            }        
            default:
            {
                printf("default");
                print_help();
                break;
            }
        }
    }
    
    return 0;
}