src/lynq/lib/liblynq-network/lynq_network.cpp

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <binder/Parcel.h>
#include <log/log.h>
#include <cutils/jstring.h>
#include <pthread.h>
#include <vendor-ril/telephony/ril.h>

#include "lynq_network.h"
#include "liblog/lynq_deflog.h"
#define LYNQ_SERVICE_PORT 8088
#define LYNQ_URC_SERVICE_PORT 8086
#define LYNQ_URC_ADDRESS "0.0.0.0"
#define LYNQ_ADDRESS "127.0.0.1"
#define LYNQ_REQUEST_PARAM_BUF 8192
#define LYNQ_REC_BUF 8192
#define LYNQ_RESP_BUF 128
#define LYNQ_TYPE_BUF 10
#define USER_LOG_TAG "LYNQ_NETWORK"


using ::android::Parcel;


typedef struct{
    int uToken;
    int request;
    int paramLen;
    char param[LYNQ_REQUEST_PARAM_BUF];
}lynq_client_t;

typedef struct{
    int resp_type;
    int request;
    int slot_id;
    int error;
}lynq_resp_t;

lynq_client_t client_t;
lynq_resp_t response;
/*socket*/


int len_addr_serv;
int len_urc_addr_serv;
struct sockaddr_in addr_serv;
struct sockaddr_in urc_addr_serv;
static int sock_fd = 0;
int lynq_client_sockfd;
int urc_sock_fd = 0;
int Global_uToken = 0;
int slot_id = -1;
int urc_status = 1;

typedef enum{
    LYNQ_E_CARDSTATE_ERROR=8000,
    /* The voice service state is out of service*/
    LYNQ_E_STATE_OUT_OF_SERVICE=8001,
    /* The voice service state is EMERGENCY_ONLY*/
    LYNQ_E_STATE_EMERGENCY_ONLY=8002,
    /* The radio power is power off*/
    LYNQ_E_STATE_POWER_OFF=8003,
    LYNQ_E_TIME_OUT=8004,
    /*create or open sms DB fail */
    LYNQ_E_SMS_DB_FAIL=8005,
    /*Failed to execute sql statement*/
    LYNQ_E_SMS_SQL_FAIL = 8006,
    LYNQ_E_SMS_NOT_FIND = 8007,
    /* The logic conflict*/
    LYNQ_E_CONFLICT=9000,
    /*Null anomaly*/
    LYNQ_E_NULL_ANONALY=9001
}LYNQ_E;

void *thread_urc_recv(void *p)
{
    Parcel *urc_p =NULL;
    char urc_data[LYNQ_REC_BUF];
    int slot_id = -1;
    int resp_type = -1;
    int urc_id = -1;
    int res = 0;
    int none = 0;
    int NR_sum = 0;
    signalStrength_t urc_solSigStren;
    int urc_LTE_signalstrength = 0;
    int urc_WCDMA_signalstrength = 0;

    LYINFLOG("urc thread is running");
    while(urc_status)
    {
        bzero(urc_data,LYNQ_REC_BUF);
        res = recvfrom(urc_sock_fd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&urc_addr_serv,(socklen_t*)&len_urc_addr_serv);
        if(res<=0)
        {
            LYERRLOG("thread_urc_recv step2 fail:");
            break;
        }
        urc_p = new Parcel();
        urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
        urc_p->setDataPosition(0);
        if(urc_p->dataAvail()>0)
        {
            urc_p->readInt32(&resp_type);
            urc_p->readInt32(&urc_id);
            urc_p->readInt32(&slot_id);
            switch(urc_id)
            {
                case 1002: //RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED
                {
                    LYINFLOG("slot_id = %d",slot_id);
                }
                case 1009: //RIL_UNSOL_SIGNAL_STRENGTH
                {
                    urc_p->readInt32(&urc_solSigStren.rssi);
                    if((urc_solSigStren.rssi!=99)&&(urc_solSigStren.rssi!=0))
                    {
                        urc_solSigStren.gw_sig_valid = 1;
                    }else{
                        urc_solSigStren.gw_sig_valid = 0;
                    }

                    urc_p->readInt32(&none);
                    urc_p->readInt32(&none);
                    urc_p->readInt32(&none);
                    urc_p->readInt32(&none);
                    urc_p->readInt32(&none);
                    urc_p->readInt32(&none);
                    urc_p->readInt32(&none);
                    urc_p->readInt32(&urc_LTE_signalstrength);
                    // p.readInt32(&solSigStren->signalStrength.LTE_SignalStrength.signalStrength);
                    urc_p->readInt32(&urc_solSigStren.rsrp);
                    urc_p->readInt32(&urc_solSigStren.rsrq);
                    urc_p->readInt32(&urc_solSigStren.rssnr);
                    LYINFLOG("urc_LTE_signalstrength:%d",urc_LTE_signalstrength);
                    if((urc_LTE_signalstrength!=99)&&(urc_LTE_signalstrength!=0))
                    {
                        urc_solSigStren.lte_sig_valid = 1;
                    }else{
                        urc_solSigStren.lte_sig_valid = 0;
                    }

                    urc_p->readInt32(&none);
                    urc_p->readInt32(&none);
                    urc_p->readInt32(&none);
                    urc_p->readInt32(&none);
                    urc_p->readInt32(&none);
                    urc_p->readInt32(&urc_WCDMA_signalstrength);
                    urc_p->readInt32(&none);
                    urc_p->readInt32(&urc_solSigStren.rscp);
                    urc_p->readInt32(&urc_solSigStren.ecno);
                    LYINFLOG("urc_WCDMA_signalstrength:%d",urc_WCDMA_signalstrength);
                    if((urc_WCDMA_signalstrength!=99)&&(urc_WCDMA_signalstrength!=0))
                    {
                        urc_solSigStren.lte_sig_valid = 1;
                    }else{
                        urc_solSigStren.lte_sig_valid = 0;
                    }
                    urc_p->readInt32(&urc_solSigStren.ssRsrp);
                    urc_p->readInt32(&urc_solSigStren.ssRsrq);
                    urc_p->readInt32(&urc_solSigStren.ssSinr);
                    urc_p->readInt32(&urc_solSigStren.csiRsrp);
                    urc_p->readInt32(&urc_solSigStren.csiRsrq);
                    urc_p->readInt32(&urc_solSigStren.csiSinr);
                    NR_sum = (urc_solSigStren.ssRsrp) + (urc_solSigStren.ssRsrq) + (urc_solSigStren.ssSinr) + (urc_solSigStren.csiRsrp)+\
                    (urc_solSigStren.csiRsrq) + (urc_solSigStren.csiSinr);
                    if(NR_sum != 0)
                    {
                        urc_solSigStren.nr_sig_valid = 1;
                    }else{
                        LYERRLOG("None of NR signal info");
                    }
                }
            }
        }
    }
}


int lynq_server_socket_start()
{
    sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if(-1 == sock_fd)
    {
        LYERRLOG("socket open error");
        return -1;
    }
    LYINFLOG("sock_fd = %d",sock_fd);

    memset(&addr_serv, 0, sizeof(addr_serv));
    addr_serv.sin_family = AF_INET;
    addr_serv.sin_addr.s_addr = inet_addr(LYNQ_ADDRESS);
    addr_serv.sin_port = htons(LYNQ_SERVICE_PORT);
    len_addr_serv = sizeof(addr_serv);
    return 0;
}

int lynq_urc_socket_start()
{
    pthread_t tid;
    pthread_attr_t attr;
    int on = 1;
    urc_sock_fd = -1;
    int ret = 0;
    len_urc_addr_serv = sizeof(sockaddr_in);
    urc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (urc_sock_fd <0){
        LYERRLOG("urc socket error");
        ret = -1;
    }
    urc_addr_serv.sin_family = AF_INET;
    urc_addr_serv.sin_port = htons(LYNQ_URC_SERVICE_PORT);
    urc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_URC_ADDRESS);
    /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
    ret = setsockopt(urc_sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
    if(ret <0)
    {
        LYERRLOG("urc socket set error");
        return -1;
    }
    ret = bind(urc_sock_fd ,(struct sockaddr*)&urc_addr_serv, sizeof(urc_addr_serv));
    if(ret <0)
    {
        LYERRLOG("urc socket bind error");
        return -1;
    }
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    ret = pthread_create(&tid,&attr,thread_urc_recv,(void *)urc_sock_fd);
    if(ret <0)
    {
        LYERRLOG("urc pthread create error");
        return -1;
    }
    LYINFLOG("urc start success");
    return 0;
}

int lynq_network_init(int utoken){
    if(utoken <0){
        LYERRLOG("init err");
        return -1;
    }
    urc_status = 1;
    Global_uToken = utoken;
    LYLOGSET(LOG_INFO);
    LYLOGEINIT(USER_LOG_TAG);
    int ret = 0;

    ret = lynq_server_socket_start();
    if(ret !=0)
    {
        LYERRLOG("init socket client fail!!!");
        return -1;
    }
    ret = lynq_urc_socket_start();
    if(ret != 0)
    {
        LYERRLOG("init socket urc fail!!!");
        return -1;
    }
    return 0;
}

int strUpper(char * str)
{
    int i=0;
    while(1)
    {
        if(str[i]=='\0')
        {
            break;
        }
        if(str[i]>='a'&&str[i]<='z')
        {
             str[i]=str[i]-32;
        }
        i++;
    }
    return 0;
}

int copyCellInfoList(Parcel &p,int *cellinfo)
{
    int32_t v=0;
    int64_t v6=0;
    if(NULL == cellinfo)
    {
        LYERRLOG("*cellinfo error");
    }

    int nothing = 0;
    p.readInt32(&v);
    RIL_CellInfoType cellinfoType  = RIL_CellInfoType(v);
    p.readInt32(&nothing);
    // cellinfo->cellinfo.cellInfoType = RIL_CellInfoType(v);
    // p.readInt32(&cellinfo->cellinfo.registered);
    p.readInt32(&v);
    // cellinfo->cellinfo.timeStampType = RIL_TimeStampType(v);
    p.readInt64(&v6);
    // cellinfo->cellinfo.timeStamp = v6;
    switch(cellinfoType) {
        case RIL_CELL_INFO_TYPE_GSM: {
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(cellinfo);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            break;
        }
        case RIL_CELL_INFO_TYPE_WCDMA: {
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(cellinfo);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            break;
        }
        case RIL_CELL_INFO_TYPE_CDMA: {
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            cellinfo = 0;

            break;
        }
        case RIL_CELL_INFO_TYPE_LTE: {
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(cellinfo);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            break;
        }
        case RIL_CELL_INFO_TYPE_TD_SCDMA: {
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(cellinfo);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            break;
        }
        case RIL_CELL_INFO_TYPE_NR: {
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(cellinfo);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            p.readInt32(&nothing);
            break;
        }
    }
    LYINFLOG("CID in fUNC :%d",*cellinfo);
    return 0;
}

int lynq_network_deinit(void){
    close(sock_fd);
    urc_status = 0;
    return 0;
}

static char * lynqStrdupReadString(Parcel &p) {
    size_t stringlen;
    const char16_t *s16;

    s16 = p.readString16Inplace(&stringlen);
    return strndup16to8(s16, stringlen);
}

int lynq_query_operater(char *OperatorFN,char *OperatorSH,char *MccMnc)
{
    int ret = -1;
    if(NULL == OperatorFN||NULL == OperatorSH|| NULL == MccMnc)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    int num = 0;
    lynq_client_t client_t;
    char res_data[LYNQ_REQUEST_PARAM_BUF] = {0};
    char *resp[LYNQ_RESP_BUF];
    memset(&client_t,0,sizeof(client_t));
    client_t.request = RIL_REQUEST_OPERATOR;
    client_t.paramLen = 0;
    client_t.uToken = Global_uToken;
    memset(client_t.param,0,sizeof(client_t.param));

    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return ret;
    }

    //get data
    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
        if(response.error != 0)
        {
            LYERRLOG("response return error");
            return response.error;
        }
        p.readInt32(&num);
        if(num == 0)
        {
            LYERRLOG("no paramters");
        }else{
            for(int i = 0; i<num;i++)
            {
                resp[i] = lynqStrdupReadString(p);
            }
            if(NULL != resp[0])
            {
                strcpy(OperatorFN,resp[0]);
            }
            if(NULL != resp[1])
            {
                strcpy(OperatorSH,resp[1]);
            }
            if(NULL != resp[2])
            {
                strcpy(MccMnc,resp[2]);
            }
        }
    }
    return response.error;
}

int lynq_query_network_selection_mode(int *netselMode)
{
    int ret = -1;
    if(NULL == netselMode)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    int readnum = 0;
    lynq_client_t client_t;
    char res_data[LYNQ_REC_BUF] = {0};
    memset(&client_t,0,sizeof(client_t));
    client_t.request = RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE;
    client_t.paramLen = 0;
    client_t.uToken = Global_uToken;

    memset(client_t.param,0,sizeof(client_t.param));
    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return -1;
    }

    //get data
    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
        if(response.error != 0)
        {
            LYERRLOG("response return error");
            return response.error;
        }
        p.readInt32(&readnum);
        p.readInt32(netselMode);
    }
    return response.error;
}

int lynq_set_network_selection_mode(const char *mode,const char* mccmnc)
{
    int ret = -1;
    if(NULL == mode ||NULL == mccmnc)
        return ret;
    int send_num = 0;
    lynq_client_t client_t;
    int recv_num = 0;
    char res_data[LYNQ_REC_BUF] = {0};
    memset(&client_t,0,sizeof(client_t));
    if(!strcmp(mode,"Auto"))
    {
        client_t.request = RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC;
        client_t.paramLen = 0;
        client_t.uToken = Global_uToken;
        memset(client_t.param,0,sizeof(client_t.param));
    }else if(!strcmp(mode,"Manual")){
        client_t.request = RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL;
        client_t.paramLen = 1;
        client_t.uToken = Global_uToken;
        sprintf(client_t.param,"%s",mccmnc);
    }else{
        LYERRLOG("request error");
        return ret;
    }


    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return ret;
    }

    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }

    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
    }
    return response.error;
}

int lynq_query_available_network(char *OperatorFN,char *OperatorSH,char *MccMnc,char * NetStatus)
{
    int ret = -1;
    if(NULL == OperatorFN||NULL == OperatorSH||NULL == MccMnc||NULL == NetStatus)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    char res_data[LYNQ_REC_BUF] = {0};
    char *resp[128];
    lynq_client_t client_t;
    memset(&client_t,0,sizeof(client_t));
    client_t.request = RIL_REQUEST_QUERY_AVAILABLE_NETWORKS;
    client_t.paramLen = 0;
    client_t.uToken = Global_uToken;
    memset(client_t.param,0,sizeof(client_t.param));

    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return ret;
    }

    //get data
    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
        if(response.error != 0)
        {
            LYERRLOG("response return error");
            return response.error;
        }
        int num =p.readInt32();
        if(num == 0)
        {
            LYERRLOG("no paramters");
        }else{
            for(int i = 0; i<num;i++)
            {
                resp[i] = lynqStrdupReadString(p);
            }
            if(NULL != resp[0])
            {
                strcpy(OperatorFN,resp[0]);
            }
            if(NULL != resp[1])
            {
                strcpy(OperatorSH,resp[1]);
            }
            if(NULL != resp[2])
            {
                strcpy(MccMnc,resp[2]);
            }
            if(NULL != resp[3])
            {
                strcpy(NetStatus,resp[2]);
            }
        }
    }
    return response.error;
}

int lynq_query_registration_state(const char *type,int* regState,int* imsRegState,char * LAC,char * CID,int *netType,int *radioTechFam)
{
    int ret = -1;
    if(NULL == type || NULL ==regState ||NULL ==imsRegState ||NULL ==LAC ||NULL ==CID ||NULL ==netType ||NULL ==radioTechFam)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    int num = 0;
    char str[LYNQ_TYPE_BUF];
    char res_data[LYNQ_REC_BUF] = {0};
    char *resp[LYNQ_RESP_BUF];
    lynq_client_t client_t;
    memset(&client_t,0,sizeof(client_t));
    if(strlen(type)>LYNQ_TYPE_BUF)
    {
        LYERRLOG("[%s]the parameter is inavaliable !",__FUNCTION__);
    }
    memcpy(str,type,strlen(type)+1);
    strUpper(str);
    if(!strcmp(str,"VOICE"))
    {
        client_t.request = RIL_REQUEST_VOICE_REGISTRATION_STATE;
    }else if(!strcmp(str,"DATA")){
        client_t.request = RIL_REQUEST_DATA_REGISTRATION_STATE;
    }else if(!strcmp(str,"IMS")){
        client_t.request = RIL_REQUEST_IMS_REGISTRATION_STATE;
    }else{
        LYERRLOG("request error");
        return ret;
    }
    client_t.paramLen = 0;
    client_t.uToken = Global_uToken;
    memset(client_t.param,0,sizeof(client_t.param));

    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return ret;
    }

    //get data
    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
        if(response.error != 0)
        {
            LYERRLOG("response return error");
            return response.error;
        }
        if(!strcmp(str,"VOICE"))
        {
            p.readInt32(&num);
            if(num == 15)
            {
                *regState = atoi(lynqStrdupReadString(p));
                lynqStrdupReadString(p);
                lynqStrdupReadString(p);
                *netType = atoi(lynqStrdupReadString(p));
            }
        }else if(!strcmp(str,"DATA")){
            p.readInt32(&num);
            if(num == 11)
            {
                *regState = atoi(lynqStrdupReadString(p));
                resp[0] = lynqStrdupReadString(p);
                strcpy(LAC,resp[0]);

                resp[1] = lynqStrdupReadString(p);
                strcpy(CID,resp[1]);
                *netType = atoi(lynqStrdupReadString(p));
            }

        }else if(!strcmp(str,"IMS")){
            p.readInt32(&num);
            if(num == 2)
            {
                p.readInt32(imsRegState);
                p.readInt32(radioTechFam);
            }
        }else{
            LYERRLOG("request error");
            return ret;
        }
    }
    return response.error;
}

int lynq_query_prefferred_networktype(int *preNetType)
{
    int ret = -1;
    int send_num = 0;
    int recv_num = 0;
    int num = 0;
    char res_data[LYNQ_REC_BUF] = {0};
    lynq_client_t client_t;
    memset(&client_t,0,sizeof(client_t));
    client_t.request = RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE;
    client_t.paramLen = 0;
    client_t.uToken = Global_uToken;
    memset(client_t.param,0,sizeof(client_t.param));

    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return ret;
    }

    //get data 
    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
        if(response.error != 0)
        {
            LYERRLOG("response return error");
            return response.error;
        }
        p.readInt32(&num);
        p.readInt32(preNetType);
    }
    return response.error;
}

int lynq_set_prefferred_networktype(const int preffertype)
{
    int ret = -1;
    if(preffertype < 0||preffertype >33)
        return ret;
    int send_num = 0;
    lynq_client_t client_t;
    int recv_num = 0;
    char res_data[LYNQ_REC_BUF] = {0};
    memset(&client_t,0,sizeof(client_t));
    client_t.request = RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE;
    client_t.paramLen = 1;
    client_t.uToken = Global_uToken;
    sprintf(client_t.param,"%d",preffertype);
    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return ret;
    }

    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }

    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
    }

    return response.error;

}

int lynq_query_cell_info(int cellinfo[CELLINFO_MAX_NUM],int * realNum)
{
    int ret = -1;
    if(NULL == realNum)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    int num = 0;
    char res_data[LYNQ_REC_BUF] = {0};
    lynq_client_t client_t;
    memset(&client_t,0,sizeof(client_t));
    client_t.request = RIL_REQUEST_GET_CELL_INFO_LIST;
    client_t.paramLen = 0;
    client_t.uToken = Global_uToken;
    memset(client_t.param,0,sizeof(client_t.param));
    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return ret;
    }

    //get data
    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
        if(response.error != 0)
        {
            LYERRLOG("response return error");
            return response.error;
        }
        p.readInt32(&num);
        LYINFLOG("cell info num:%d",num);
        *realNum = num;
        for(int i = 0;i<num;i++)
        {
            copyCellInfoList(p,&cellinfo[i]);
        }
    }
    return response.error;

}

int lynq_set_unsol_cell_info_listrate(const int rate)
{
    int ret = -1;
    int send_num = 0;
    int recv_num = 0;
    char res_data[LYNQ_REC_BUF] = {0};
    lynq_client_t client_t;
    memset(&client_t,0,sizeof(client_t));
    client_t.request = RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE;
    client_t.paramLen = 1;
    client_t.uToken = Global_uToken;
    sprintf(client_t.param,"%d",rate);

    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return ret;
    }
    
    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }

    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
    }

    return response.error;
}

int lynq_set_band_mode(const int bandmode)
{
    int ret = -1;
    int send_num = 0;
    int recv_num = 0;
    char res_data[LYNQ_REC_BUF] = {0};
    lynq_client_t client_t;
    memset(&client_t,0,sizeof(client_t));
    client_t.request = RIL_REQUEST_SET_BAND_MODE;
    client_t.paramLen = 1;
    client_t.uToken = Global_uToken;
    sprintf(client_t.param,"%d",bandmode);

    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return ret;
    }
    
    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }

    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
    }

    return response.error;
}

int lynq_query_available_bandmode(int availBanMode[])
{
    int ret = -1;
    if(NULL == availBanMode)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    int num = 0;
    int res = 0;
    char res_data[LYNQ_REC_BUF] = {0};
    lynq_client_t client_t;
    memset(&client_t,0,sizeof(client_t));
    client_t.request = RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE;
    client_t.paramLen = 0;
    client_t.uToken = Global_uToken;
    memset(client_t.param,0,sizeof(client_t.param));
    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return ret;
    }

    //get data
    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }
    for(int i = 0;i<20;i++)
    {
        availBanMode[i]=0;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);

    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
        if(response.error != 0)
        {
            LYERRLOG("response return error");
            return response.error;
        }
        p.readInt32(&num);
        LYINFLOG("num = %d",num);
        availBanMode[0] = num;
        for(int i=1 ;i<=num;i++)
        {
            p.readInt32(&res);
            availBanMode[i]=res;
        }
    }

    return response.error;
}

int lynq_radio_on(const int data)
{
    int ret = -1;
    if(data < 0)
        return ret;
    int send_num = 0;
    char res_data[LYNQ_REC_BUF] = {0};
    int recv_num = 0;
    lynq_client_t client_t;
    memset(&client_t,0,sizeof(client_t));
    client_t.request = RIL_REQUEST_RADIO_POWER;
    client_t.paramLen = 1;
    client_t.uToken = Global_uToken;
    sprintf(client_t.param,"%d",data);

    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return ret;
    }

    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }

    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
    }

    return response.error;
}

int lynq_query_radio_tech(int* radioTech)
{
    int ret = -1;
    if(NULL == radioTech)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    int num = 0;
    char res_data[LYNQ_REC_BUF] = {0};
    lynq_client_t client_t;
    memset(&client_t,0,sizeof(client_t));
    client_t.request = RIL_REQUEST_VOICE_RADIO_TECH;
    client_t.paramLen = 0;
    client_t.uToken = Global_uToken;
    memset(client_t.param,0,sizeof(client_t.param));

    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");  
        return ret;
    }

    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);

    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
        if(response.error != 0)
        {
            LYERRLOG("response return error");
            return response.error;
        }
        p.readInt32(&num);
        p.readInt32(radioTech);
    }
    return response.error;
}

int lynq_solicited_signal_strength(signalStrength_t *solSigStren)
{
    int ret = -1;
    if(NULL == solSigStren)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    int sum = 0;
    int LTE_signalstrength = 0;
    int WCDMA_signalstrength = 0;
    int none = 0;

    char res_data[LYNQ_REC_BUF] = {0};
    lynq_client_t client_t;
    memset(&client_t,0,sizeof(client_t));
    client_t.request = RIL_REQUEST_SIGNAL_STRENGTH;
    client_t.paramLen = 0;
    client_t.uToken = Global_uToken;
    memset(client_t.param,0,sizeof(client_t.param));

    send_num = sendto(sock_fd,&client_t,sizeof(client_t),0,(struct sockaddr *)&addr_serv,len_addr_serv);
    if(send_num<0)
    {
        LYERRLOG("sendto error:");
        return ret;
    }

    //get data 
    recv_num = recvfrom(sock_fd,res_data,sizeof(res_data),0,(struct sockaddr *)&addr_serv,(socklen_t *)&len_addr_serv);
    if(recv_num == 0 ||recv_num <0)
    {
        LYERRLOG("recvfrom error");
        return -1;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(res_data));
    p.setDataPosition(0);

    if(p.dataAvail() > 0)
    {
        p.readInt32(&response.resp_type);
        p.readInt32(&response.request);
        p.readInt32(&response.slot_id);
        p.readInt32(&response.error);
        if(response.error != 0)
        {
            LYERRLOG("response return error");
            return response.error;
        }

        p.readInt32(&solSigStren->rssi);
        if((solSigStren->rssi!=99)&&(solSigStren->rssi!=0))
        {
            solSigStren->gw_sig_valid = 1;
        }else{
            solSigStren->gw_sig_valid = 0;
        }

        p.readInt32(&none);
        p.readInt32(&none);
        p.readInt32(&none);
        p.readInt32(&none);
        p.readInt32(&none);
        p.readInt32(&none);
        p.readInt32(&none);
        p.readInt32(&LTE_signalstrength);
        // p.readInt32(&solSigStren->signalStrength.LTE_SignalStrength.signalStrength);
        p.readInt32(&solSigStren->rsrp);
        p.readInt32(&solSigStren->rsrq);
        p.readInt32(&solSigStren->rssnr);
        LYINFLOG("LTE_signalstrength:%d",LTE_signalstrength);
        if((LTE_signalstrength!=99)&&(LTE_signalstrength!=0))
        {
            solSigStren->lte_sig_valid = 1;
        }else{
            solSigStren->lte_sig_valid = 0;
        }

        p.readInt32(&none);
        p.readInt32(&none);
        p.readInt32(&none);
        p.readInt32(&none);
        p.readInt32(&none);
        p.readInt32(&WCDMA_signalstrength);
        p.readInt32(&none);
        p.readInt32(&solSigStren->rscp);
        p.readInt32(&solSigStren->ecno);
        LYINFLOG("WCDMA_signalstrength:%d",WCDMA_signalstrength);
        if((WCDMA_signalstrength!=99)&&(WCDMA_signalstrength!=0))
        {
            solSigStren->wcdma_sig_valid = 1;
        }else{
            solSigStren->wcdma_sig_valid = 0;
        }
        /*bug fix*/
        p.readInt32(&solSigStren->ssRsrp);
        p.readInt32(&solSigStren->ssRsrq);
        p.readInt32(&solSigStren->ssSinr);
        p.readInt32(&solSigStren->csiRsrp);
        p.readInt32(&solSigStren->csiRsrq);
        p.readInt32(&solSigStren->csiSinr);
        sum = (solSigStren->ssRsrp) + (solSigStren->ssRsrq) + (solSigStren->ssSinr) + (solSigStren->csiRsrp)+\
        (solSigStren->csiRsrq) + (solSigStren->csiSinr);
        if(sum != 0)
        {
            solSigStren->nr_sig_valid = 1;
        }else{
            LYERRLOG("None of NR signal info");
        }
    }
    return response.error;
}