[Feature]Add Network feature and bb
Change-Id: Ie2ea14ab99278940e001bffa7879d27b79d5dbe2
diff --git a/lib/liblynq-network/lynq_network.cpp b/lib/liblynq-network/lynq_network.cpp
new file mode 100755
index 0000000..3ed0512
--- /dev/null
+++ b/lib/liblynq-network/lynq_network.cpp
@@ -0,0 +1,1234 @@
+#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(¬hing);
+ // 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(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(cellinfo);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_WCDMA: {
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(cellinfo);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_CDMA: {
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ cellinfo = 0;
+
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_LTE: {
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(cellinfo);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_TD_SCDMA: {
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(cellinfo);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_NR: {
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(cellinfo);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ p.readInt32(¬hing);
+ 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[128];
+ 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])
+ {
+ memcpy(OperatorFN,resp[0],strlen(resp[0]));
+ }
+ if(NULL != resp[1])
+ {
+ memcpy(OperatorSH,resp[1],strlen(resp[1]));
+ }
+ if(NULL != resp[2])
+ {
+ memcpy(MccMnc,resp[2],strlen(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);
+ }
+
+
+ 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])
+ {
+ memcpy(OperatorFN,resp[0],strlen(resp[0]));
+ }
+ if(NULL != resp[1])
+ {
+ memcpy(OperatorSH,resp[1],strlen(resp[1]));
+ }
+ if(NULL != resp[2])
+ {
+ memcpy(MccMnc,resp[2],strlen(resp[2]));
+ }
+ if(NULL != resp[3])
+ {
+ memcpy(NetStatus,resp[2],strlen(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};
+ 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));
+ LAC = lynqStrdupReadString(p);
+ CID = lynqStrdupReadString(p);
+ *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(<E_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->lte_sig_valid = 1;
+ }else{
+ solSigStren->lte_sig_valid = 0;
+ }
+ 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;
+}