[Feature]add MT2731_MP2_MR2_SVN388 baseline version
Change-Id: Ief04314834b31e27effab435d3ca8ba33b499059
diff --git a/src/lynq/lib/liblynq-tele-ril/lynq-riltel/lynq_network.cpp b/src/lynq/lib/liblynq-tele-ril/lynq-riltel/lynq_network.cpp
new file mode 100644
index 0000000..8ba3149
--- /dev/null
+++ b/src/lynq/lib/liblynq-tele-ril/lynq-riltel/lynq_network.cpp
@@ -0,0 +1,744 @@
+//#include "common.h"
+#include "lynq_common.h"
+#include "lynq_network.h"
+//#include <stateManager/stateManager.h>
+#define CELL_LIST_MAX 10
+#undef LOG_TAG
+#define LOG_TAG "LYNQ_NETWORK"
+
+//moblietek add @2020.12.for add Network api
+int copyCellInfoList(Parcel &p,cellInfoList *cellinfo)
+{
+ int32_t v=0;
+ int64_t v6=0;
+ int32_t num = 0;
+ p.readInt32(&v);
+ 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(cellinfo->cellinfo.cellInfoType) {
+ case RIL_CELL_INFO_TYPE_GSM: {
+ p.readInt32(&cellinfo->cellinfo.CellInfo.gsm.cellIdentityGsm.mcc);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.gsm.cellIdentityGsm.mnc);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.gsm.cellIdentityGsm.lac);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.gsm.cellIdentityGsm.cid);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.gsm.signalStrengthGsm.signalStrength);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.gsm.signalStrengthGsm.bitErrorRate);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.gsm.signalStrengthGsm.timingAdvance);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_WCDMA: {
+ p.readInt32(&cellinfo->cellinfo.CellInfo.wcdma.cellIdentityWcdma.mcc);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.wcdma.cellIdentityWcdma.mnc);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.wcdma.cellIdentityWcdma.lac);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.wcdma.cellIdentityWcdma.cid);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.wcdma.cellIdentityWcdma.psc);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.wcdma.signalStrengthWcdma.signalStrength);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_CDMA: {
+ p.readInt32(&cellinfo->cellinfo.CellInfo.cdma.cellIdentityCdma.networkId);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.cdma.cellIdentityCdma.systemId);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.cdma.cellIdentityCdma.basestationId);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.cdma.cellIdentityCdma.longitude);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.cdma.cellIdentityCdma.latitude);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.cdma.signalStrengthCdma.dbm);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.cdma.signalStrengthCdma.ecio);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.cdma.signalStrengthEvdo.dbm);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.cdma.signalStrengthEvdo.ecio);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio);
+
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_LTE: {
+ p.readInt32(&cellinfo->cellinfo.CellInfo.lte.cellIdentityLte.mcc);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.lte.cellIdentityLte.mnc);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.lte.cellIdentityLte.ci);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.lte.cellIdentityLte.pci);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.lte.cellIdentityLte.tac);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.lte.signalStrengthLte.signalStrength);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.lte.signalStrengthLte.rsrp);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.lte.signalStrengthLte.rsrq);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.lte.signalStrengthLte.rssnr);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.lte.signalStrengthLte.cqi);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.lte.signalStrengthLte.timingAdvance);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_TD_SCDMA: {
+ p.readInt32(&cellinfo->cellinfo.CellInfo.tdscdma.cellIdentityTdscdma.mcc);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.tdscdma.cellIdentityTdscdma.mnc);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.tdscdma.cellIdentityTdscdma.lac);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.tdscdma.cellIdentityTdscdma.cid);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.tdscdma.cellIdentityTdscdma.cpid);
+ p.readInt32(&cellinfo->cellinfo.CellInfo.tdscdma.signalStrengthTdscdma.rscp);
+ break;
+ }
+ }
+ return 0;
+}
+int checkRespErrno(const int32_t token,const int time,RIL_Errno & err)
+{
+ int time_net = time;
+ int status=0;
+ lynqQueue *node = NULL;
+ lynqQueue *temp =NULL;
+ while(time_net--)
+ {
+ millli_sleep_with_restart(10);
+ temp=LynqQueueHead;
+ if(temp==NULL)
+ {
+ LYDBGLOG("[%s][%d][%s] Queue head is NULL, maybe malloc fail!\n",__FUNCTION__,__LINE__,__FILE__);
+ continue;
+ }
+ node = searchTokeninQueue(token, temp);
+ if(node ==NULL)
+ {
+ LYDBGLOG("[%s][%d][%s] can not find token %x\n",__FUNCTION__,__LINE__,__FILE__,token);
+ err=-1;
+ return -1;
+ }
+ node->parcel.setDataPosition(0);
+ if (node->parcel.dataAvail() > 0)
+ {
+ node->parcel.readInt32(&status);
+ LYDBGLOG("[%s][%d][%s] message number is %d\n",__FUNCTION__,__LINE__,__FILE__,status);
+ if(status!=0)
+ {
+ if(node->t_Errno!=RIL_E_SUCCESS)
+ {
+ LYDBGLOG("[%s][%d][%s] get err success,but the event is fail,the error code is %d\n",__FUNCTION__,__LINE__,__FILE__,node->t_Errno);
+ err=node->t_Errno;
+ return -1;
+ }
+ else
+ {
+ LYDBGLOG("[%s][%d][%s] get success, the error code is %d",__FUNCTION__,__LINE__,__FILE__,node->t_Errno);
+ err=node->t_Errno;
+ return 0;
+ }
+ }
+ }
+ else
+ {
+ continue;
+ }
+ }
+ if(time_net<0)
+ {
+ LYDBGLOG("[%s][%d][%s] time out,can not find network selection mode message!",__FUNCTION__,__LINE__,__FILE__);
+ err=-1;
+ }
+ return -1;
+}
+int checkNetworkSelectionMode(const int32_t token,const int time,networkSelecttionMode *netselMode)
+{
+ int time_net = time;
+ int num=0;
+ //int status =0;
+ Parcel parcel;
+ RIL_Errno err;
+ lynqQueue *node = NULL;
+ lynqQueue *temp =NULL;
+ node = commonFindParcelmsg(token,time,err);
+ if(node!=NULL)
+ {
+ node->parcel.readInt32(&num);
+ LYDBGLOG("[%s][%d][%s] message number is %d",__FUNCTION__,__LINE__,__FILE__,num);
+ node->parcel.readInt32(&netselMode->mode);
+ netselMode->base.e=err;
+ return 0;
+ }
+ netselMode->base.e=err;
+ return -1;
+}
+int updateRegStateInfo(int32_t request,int32_t token,registrationStateInfo *regStateInfo)
+{
+ RIL_Errno err;
+ Parcel parcel;
+ int res = 0;
+ int num=0;
+ lynqQueue *node=NULL;
+ regStateInfo->base.request=request;
+ regStateInfo->base.token = token;
+ switch(request)
+ {
+ case RIL_REQUEST_VOICE_REGISTRATION_STATE:
+ {
+ node = commonFindParcelmsg(token, 500,err);
+ if (node != NULL)
+ {
+ node->parcel.setDataPosition(0);
+ node->parcel.readInt32(&num);
+ LYDBGLOG("[RIL_REQUEST_DATA_REGISTRATION_STATE] the num is %d\n",num);
+ if(num==15)
+ {
+ regStateInfo->regState = atoi(lynqStrdupReadString(node->parcel));
+ lynqStrdupReadString(node->parcel);
+ lynqStrdupReadString(node->parcel);
+ regStateInfo->netType =atoi( lynqStrdupReadString(node->parcel));
+ }
+ }
+ regStateInfo->base.e=err;
+ break;
+ }
+ case RIL_REQUEST_DATA_REGISTRATION_STATE:
+ {
+ node = commonFindParcelmsg(token, 500,err);
+ if (node != NULL)
+ {
+ node->parcel.setDataPosition(0);
+ node->parcel.readInt32(&num);
+ //char * temp=NULL;
+ LYDBGLOG("[RIL_REQUEST_DATA_REGISTRATION_STATE] the num is %d\n",num);
+ if(num==11)
+ {
+ regStateInfo->regState = atoi(lynqStrdupReadString(node->parcel));
+ regStateInfo->LAC = lynqStrdupReadString(node->parcel);
+ regStateInfo->CID = lynqStrdupReadString(node->parcel);
+ regStateInfo->netType =atoi( lynqStrdupReadString(node->parcel));
+ }
+ }
+ regStateInfo->base.e=err;
+ break;
+ }
+ case RIL_REQUEST_IMS_REGISTRATION_STATE:
+ {
+ node = commonFindParcelmsg(token, 500,err);
+ if (node != NULL)
+ {
+ node->parcel.setDataPosition(0);
+ node->parcel.readInt32(&num);
+ //char * temp=NULL;
+ LYDBGLOG("[RIL_REQUEST_DATA_REGISTRATION_STATE] the num is %d\n",num);
+ if(num==2)
+ {
+ node->parcel.readInt32(®StateInfo->imsRegState);
+ node->parcel.readInt32(&res);
+ regStateInfo->radioTechFam = (RIL_RadioTechnologyFamily)res;
+ }
+ }
+ regStateInfo->base.e=err;
+ break;
+ }
+ default:
+ break;
+ }
+ return 0;
+}
+int lynq_query_operater(operatorInfo * currentOperator)
+{
+ int32_t token = 0;
+ int time_net =100;
+ int num=0;
+ lynqQueue *node = NULL;
+ RIL_Errno err = -1;
+ char requestStr[MAX_LEN] = {"RIL_REQUEST_OPERATOR"};
+ if(token = lynqNoneParame(requestStr))
+ {
+ currentOperator->base.request = RIL_REQUEST_OPERATOR;
+ currentOperator->base.token=token;
+ node = commonUpdateEstatus(token, time_net, err);
+ currentOperator->base.e = err;
+ if(err!=RIL_E_SUCCESS)
+ {
+ currentOperator->OperatorFN = NULL;
+ currentOperator->OperatorSH = NULL;
+ currentOperator->MccMnc = NULL;
+ lynqDeQueue(token);
+ return token;
+ }
+ node->parcel.setDataPosition(0);
+ if (node->parcel.dataAvail() > 0)
+ {
+ node->parcel.readInt32(&num);
+ LYDBGLOG("[%s][%d][%s] Message number is %d",__FUNCTION__,__LINE__,__FILE__,num);
+ if(num == 3)
+ {
+ currentOperator->OperatorFN = lynqStrdupReadString(node->parcel);
+ currentOperator->OperatorSH = lynqStrdupReadString(node->parcel);
+ currentOperator->MccMnc = lynqStrdupReadString(node->parcel);
+ }
+ }
+ lynqDeQueue(token);
+ }
+ return token;
+}
+
+int lynq_query_network_selection_mode(networkSelecttionMode *netselMode)
+{
+ int32_t token=0;
+ int time_net = 100;//1s
+ //int num=0;
+ //lynqQueue *node = NULL;
+ //lynqQueue *temp =NULL;
+ char requestStr[MAX_LEN] = {"RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE"};
+ token=lynqNoneParame(requestStr);
+ netselMode->base.token=token;
+ netselMode->base.request=RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE;
+ checkNetworkSelectionMode(token,time_net,netselMode);
+ lynqDeQueue(token);
+ return token;
+}
+int lynq_set_network_selection_mode(const char *mode,const char* mccmnc,lynqBase *base)//0:auto selection 1:manual selection
+{
+ const char *argv[MAX_LEN] = {};
+ int32_t token=0;
+ RIL_Errno err;
+ lynqQueue * node = NULL;
+ int time_net = 100;//1s
+ char mccmncStr[MAX_QUEST_LEN] = "";
+ if(!strcmp(mode,"Auto"))
+ {
+ //printf("--------->[%s,%d] Auto!!! \n",__FUNCTION__,__LINE__);
+ argv[0] = "RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC";
+ argv[1] = "Auto";
+ if(token = android::getRequestData(argv, 1))
+ {
+ base->request=RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC;
+ base->token = token;
+ node = commonFindParcelmsg(token,time_net,err);
+ base->e=err;
+ lynqDeQueue(token);
+ }
+ return token;
+ }else if(!strcmp(mode,"Manual")){
+ //printf("--------->[%s,%d] manual,mccmnc=%d \n",__FUNCTION__,__LINE__,mccmnc);
+ //sprintf(mccmncStr, "%d", mccmnc);
+ argv[0] = "RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL";
+ argv[1] = mccmnc;
+ //argv[2] = mccmnc;
+ if(token = android::getRequestData(argv, 2))
+ {
+ base->request=RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL;
+ base->token = token;
+ node = commonFindParcelmsg(token,time_net,err);
+ base->e=err;
+ lynqDeQueue(token);
+ }
+ return token;
+ }
+}
+
+int lynq_query_available_network(availableNetwork *availNet)
+{
+ int32_t token;
+ char requestStr[MAX_LEN] = {"RIL_REQUEST_QUERY_AVAILABLE_NETWORKS"};
+ int time_net =6000;//60second
+ int num=0;//the number of available network data
+ int range = 0;/*response is const char ** that should be an array of n*4 strings, where "range" is the number of available networks*/
+ RIL_Errno err = -1;
+ lynqQueue *node = NULL;
+ lynqQueue *temp =NULL;
+ if(token = lynqNoneParame(requestStr))
+ {
+ availNet->base.request = RIL_REQUEST_OPERATOR;
+ availNet->base.token=token;
+ node = commonFindParcelmsg(token, time_net, err);
+ availNet->base.e=err;
+ if (node !=NULL)
+ {
+ node->parcel.readInt32(&num);
+ LYDBGLOG("[%s][%d] message number is %d\n",__FUNCTION__,__LINE__,num);
+ if((num/4)>0 &&(num%4)==0)//Integer multiples of 4
+ {
+ range = num/4;
+ /*Temporary plan.the real situation should be for(int i=0;i<range;i++)*/
+ availNet->OperatorFN = lynqStrdupReadString(node->parcel);
+ availNet->OperatorSH = lynqStrdupReadString(node->parcel);
+ availNet->MccMnc = lynqStrdupReadString(node->parcel);
+ availNet->NetStatus = lynqStrdupReadString(node->parcel);
+ }
+ else
+ {
+ if(num/4>0)
+ {
+ availNet->OperatorFN = lynqStrdupReadString(node->parcel);
+ availNet->OperatorSH = lynqStrdupReadString(node->parcel);
+ availNet->MccMnc = lynqStrdupReadString(node->parcel);
+ availNet->NetStatus = lynqStrdupReadString(node->parcel);
+ }
+ }
+ }
+ lynqDeQueue(token);
+ }
+ return 0;
+}
+
+//network state
+int lynq_query_registration_state(const char *type,registrationStateInfo *regStateInfo)//type:vioce/data/ims
+{
+ char requestStr[MAX_LEN]="";
+ int32_t request=0;
+ int32_t token=0;
+ char str[10];
+ if (strlen(type)>10)
+ {
+ LYERRLOG("[%s]the parameter is inavaliable !\n",__FUNCTION__);
+ return -1;
+ }
+ memcpy(str,type,strlen(type)+1);
+ strUpper(str);
+ //printf("upper str is %s\n",str);
+ if(!strcmp(str,"VOICE")){
+ strcpy(requestStr,"RIL_REQUEST_VOICE_REGISTRATION_STATE");
+ request=RIL_REQUEST_VOICE_REGISTRATION_STATE;
+ }else if(!strcmp(str,"DATA")){
+ strcpy(requestStr,"RIL_REQUEST_DATA_REGISTRATION_STATE");
+ request= RIL_REQUEST_DATA_REGISTRATION_STATE;
+ }else if(!strcmp(str,"IMS")){
+ strcpy(requestStr,"RIL_REQUEST_IMS_REGISTRATION_STATE");
+ request = RIL_REQUEST_IMS_REGISTRATION_STATE;
+ }else{
+ LYERRLOG("[%s,%d] query ims registration state about voice, data, and ims!!! \n",__FUNCTION__,__LINE__);
+ return -1;
+ }
+ token = lynqNoneParame(requestStr);
+ updateRegStateInfo(request,token,regStateInfo);
+ lynqDeQueue(token);
+ return token;
+}
+//preferred network
+int lynq_query_prefferred_networktype(prefferredNetworkType * preNetType)
+{
+ int32_t token=0;
+ lynqQueue *node =NULL;
+ RIL_Errno err=-1;
+ int num =0;
+ int res = 0;
+ char requestStr[MAX_LEN] = {"RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE"};
+ token = lynqNoneParame(requestStr);
+ preNetType->base.request = RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE;
+ preNetType->base.token=token;
+ node = commonFindParcelmsg(token, 500, err);
+ if (node !=NULL)
+ {
+ node->parcel.readInt32(&num);
+ node->parcel.readInt32(&res);
+ preNetType->pnt=res;
+ }
+ preNetType->base.e=err;
+ lynqDeQueue(token);
+ return token;
+}
+
+int lynq_set_prefferred_networktype(const int preffertype,lynqBase * base)//preffertype:0~22
+{
+ char *argv[MAX_LEN] = {};
+ char preffertypeStr[MAX_QUEST_LEN] = "";
+ int32_t token=0;
+ int status = 0;
+ RIL_Errno err=-1;
+ lynqQueue * node = NULL;
+
+ sprintf(preffertypeStr, "%d", preffertype);
+ argv[0] = "RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE";
+ argv[1] = preffertypeStr;
+ if(token = android::getRequestData(argv, 2))
+ {
+ base->request = RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE;
+ base->token=token;
+ node = commonFindParcelmsg(token,500,err);
+ base->e=err;
+ lynqDeQueue(token);
+ }
+ return token;
+}
+
+//cell info
+int lynq_query_cell_info(cellInfoList ** cellinfo,const int listNum,int *realNum)
+{
+ int32_t token = 0;
+ lynqQueue *node = NULL;
+ RIL_Errno err = -1;
+ int num = 0;
+ *realNum = 0;
+ if(listNum>CELL_LIST_MAX)
+ {
+ LYERRLOG("the list number is more than 10\n");
+ return -1;
+ }
+ char requestStr[MAX_LEN] = {"RIL_REQUEST_GET_CELL_INFO_LIST"};
+ if(token = lynqNoneParame(requestStr))
+ {
+ cellinfo[0]->base.request=RIL_REQUEST_GET_CELL_INFO_LIST;
+ cellinfo[0]->base.token = token;
+ //node = commonFindParcelmsg(token,500,err);
+ if(node = commonFindParcelmsg(token,500,err))
+ {
+ node->parcel.readInt32(&num);
+ if (listNum<num)
+ {
+ num=listNum;
+ LYDBGLOG("[%s,%d]listNum<num!",__FUNCTION__,__LINE__);
+ }
+ *realNum = num;
+ for(int i = 0;i<num;i++)
+ {
+ copyCellInfoList(node->parcel,cellinfo[i]);
+ //cellinfo[i]->base.request=RIL_REQUEST_GET_CELL_INFO_LIST;
+ //cellinfo[i]->base.token = token;
+ }
+ }
+ cellinfo[0]->base.e=err;
+ lynqDeQueue(token);
+ }
+ cellinfo[0]->base.e=err;
+ return token;
+}
+
+int lynq_set_unsol_cell_info_listrate(const int rate,lynqBase * base) //rate:0<=rate<=0x7fffffff, minimum time in milliseconds
+{
+ int32_t token=0;
+ char *argv[MAX_LEN] = {};
+ char rateStr[MAX_QUEST_LEN] = "";
+ int status = 0;
+ RIL_Errno err=-1;
+ lynqQueue * node = NULL;
+ sprintf(rateStr, "%d", rate);
+ argv[0] = "RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE";
+ argv[1] = rateStr;
+ if(token = android::getRequestData(argv, 2))
+ {
+ base->request = RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE;
+ base->token=token;
+ node = commonFindParcelmsg(token,500,err);
+ base->e=err;
+ lynqDeQueue(token);
+ }
+ return token;
+}
+
+int lynq_query_neighboring_cellids(neighboringCellIDs **neiCeIDs,const int listNum,int *realNum)
+{
+ int32_t token = 0;
+ lynqQueue *node = NULL;
+ RIL_Errno err = -1;
+ int num = 0;
+ int res=0;
+ *realNum = 0;
+ if(listNum>CELL_LIST_MAX)
+ {
+ LYERRLOG("the list number is more than 10\n");
+ return -1;
+ }
+ char requestStr[MAX_LEN] = {"RIL_REQUEST_GET_NEIGHBORING_CELL_IDS"};
+ if(token = lynqNoneParame(requestStr))
+ {
+ neiCeIDs[0]->base.request=RIL_REQUEST_GET_NEIGHBORING_CELL_IDS;
+ neiCeIDs[0]->base.token = token;
+ //node = commonFindParcelmsg(token,500,err);
+ if(node = commonFindParcelmsg(token,500,err))
+ {
+ node->parcel.readInt32(&num);
+ if (listNum<num)
+ {
+ num=listNum;
+ LYDBGLOG("[%s,%d]listNum<num!",__FUNCTION__,__LINE__);
+ }
+ *realNum = num;
+ for(int i = 0;i<num;i++)
+ {
+ neiCeIDs[i]->cid = lynqStrdupReadString(node->parcel);
+ node->parcel.readInt32(&res);
+ neiCeIDs[i]->rssi = res;
+ }
+ }
+ neiCeIDs[0]->base.e=err;
+ lynqDeQueue(token);
+ }
+ neiCeIDs[0]->base.e=err;
+ return token;
+}
+
+//band mode
+int lynq_set_band_mode(const int bandmode,lynqBase *base)//bandmode:0~18
+{
+ char *argv[MAX_LEN] = {};
+ int32_t token=0;
+ char bandmodeStr[MAX_QUEST_LEN] = "";
+ int status = 0;
+ RIL_Errno err=-1;
+ lynqQueue * node = NULL;
+ sprintf(bandmodeStr, "%d", bandmode);
+ argv[0] = "RIL_REQUEST_SET_BAND_MODE";
+ argv[1] = bandmodeStr;
+ token = android::getRequestData(argv, 2);
+ base->request=RIL_REQUEST_SET_BAND_MODE;
+ base->token = token;
+ node = commonFindParcelmsg(token,1000,err);
+ base->e=err;
+ lynqDeQueue(token);
+ return token;
+}
+
+int lynq_query_available_bandmode(availableBandMode*availBanMode)
+{
+ int32_t token = 0;
+ RIL_Errno err=-1;
+ lynqQueue * node = NULL;
+ int num = 0;
+ int res = 0;
+ char requestStr[MAX_LEN] = {"RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE"};
+ token = lynqNoneParame(requestStr);
+ availBanMode->base.request = RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE;
+ availBanMode->base.token = token;
+ node = commonFindParcelmsg(token,500,err);
+ for(int i = 0;i<20;i++)
+ {
+ availBanMode->bandmode[i]=0;
+ }
+ if (node!=NULL)
+ {
+ node->parcel.readInt32(&num);
+ availBanMode->bandmode[0]=num;
+ LYDBGLOG("[%s] available band mode num is %d\n",__FUNCTION__,num);
+ for(int i=1;i<=num;i++)
+ {
+ node->parcel.readInt32(&res);
+ availBanMode->bandmode[i]=res;
+ }
+ }
+ availBanMode->base.e=err;
+ lynqDeQueue(token);
+ return 0;
+}
+
+//radio power
+int lynq_radio_on(const int data,lynqBase *base)//0:off other:on
+{
+ char *argv[MAX_LEN] = {};
+ char dataStr[MAX_QUEST_LEN] = "";
+ int32_t token = 0;
+ lynqQueue *node = NULL;
+ RIL_Errno err=-1;
+ sprintf(dataStr, "%d", data);
+ argv[0] = "RIL_REQUEST_RADIO_POWER";
+ argv[1] = dataStr;
+ if(token = android::getRequestData(argv, 2))
+ {
+ base->request=RIL_REQUEST_RADIO_POWER;
+ base->token = token;
+ node = commonFindParcelmsg(token,500,err);
+ base->e=err;
+ lynqDeQueue(token);
+ }
+ return token;
+}
+
+//radio tech
+int lynq_query_radio_tech(radioTechnology *radioTech)
+{
+ char requestStr[MAX_LEN] = {"RIL_REQUEST_VOICE_RADIO_TECH"};
+ int32_t token=0;
+ RIL_Errno err=-1;
+ lynqQueue *node =NULL;
+ int num = 0;
+ int res = 0;
+ token = lynqNoneParame(requestStr);
+ radioTech->base.request = RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE;
+ radioTech->base.token=token;
+ node = commonFindParcelmsg(token, 500, err);
+ if (node !=NULL)
+ {
+ node->parcel.readInt32(&num);
+ node->parcel.readInt32(&res);
+ radioTech->radioTech=res;
+ }
+ radioTech->base.e=err;
+ lynqDeQueue(token);
+ return token;
+}
+
+//signal strength
+int lynq_solicited_signal_strength(solicitedSignalStrength *solSigStren)
+{
+ char requestStr[MAX_LEN] = {"RIL_REQUEST_SIGNAL_STRENGTH"};
+ int32_t token=0;
+ RIL_Errno err=-1;
+ lynqQueue *node =NULL;
+ int num = 0;
+ int res = 0;
+ token = lynqNoneParame(requestStr);
+ solSigStren->base.request = RIL_REQUEST_SIGNAL_STRENGTH;
+ solSigStren->base.token=token;
+ node = commonFindParcelmsg(token, 500, err);
+ solSigStren->base.e=err;
+ if (node !=NULL)
+ {
+ node->parcel.readInt32(&num);
+ if(num ==0)
+ {
+ LYDBGLOG("[%s] the signal strength is null!\n",__FUNCTION__);
+ if(err==RIL_E_SUCCESS)
+ {
+ solSigStren->base.e=-1;
+ }
+ lynqDeQueue(token);
+ return token;
+ }
+ node->parcel.readInt32(&solSigStren->signalStrength.GW_SignalStrength.signalStrength);
+ node->parcel.readInt32(&solSigStren->signalStrength.GW_SignalStrength.bitErrorRate);
+ node->parcel.readInt32(&solSigStren->signalStrength.GW_SignalStrength.timingAdvance);
+ node->parcel.readInt32(&solSigStren->signalStrength.CDMA_SignalStrength.dbm);
+ node->parcel.readInt32(&solSigStren->signalStrength.CDMA_SignalStrength.ecio);
+ node->parcel.readInt32(&solSigStren->signalStrength.EVDO_SignalStrength.dbm);
+ node->parcel.readInt32(&solSigStren->signalStrength.EVDO_SignalStrength.ecio);
+ node->parcel.readInt32(&solSigStren->signalStrength.EVDO_SignalStrength.signalNoiseRatio);
+ node->parcel.readInt32(&solSigStren->signalStrength.LTE_SignalStrength.signalStrength);
+ node->parcel.readInt32(&solSigStren->signalStrength.LTE_SignalStrength.rsrp);
+ node->parcel.readInt32(&solSigStren->signalStrength.LTE_SignalStrength.rsrq);
+ node->parcel.readInt32(&solSigStren->signalStrength.LTE_SignalStrength.rssnr);
+ node->parcel.readInt32(&solSigStren->signalStrength.LTE_SignalStrength.cqi);
+ node->parcel.readInt32(&solSigStren->signalStrength.LTE_SignalStrength.timingAdvance);
+ node->parcel.readInt32(&solSigStren->signalStrength.TD_SCDMA_SignalStrength.signalStrength);
+ node->parcel.readInt32(&solSigStren->signalStrength.TD_SCDMA_SignalStrength.bitErrorRate);
+ node->parcel.readInt32(&solSigStren->signalStrength.TD_SCDMA_SignalStrength.rscp);
+ node->parcel.readInt32(&solSigStren->signalStrength.WCDMA_SignalStrength.signalStrength);
+ node->parcel.readInt32(&solSigStren->signalStrength.WCDMA_SignalStrength.bitErrorRate);
+ node->parcel.readInt32(&solSigStren->signalStrength.WCDMA_SignalStrength.rscp);
+ node->parcel.readInt32(&solSigStren->signalStrength.WCDMA_SignalStrength.ecno);
+ }
+ lynqDeQueue(token);
+ return token;
+
+}
+
+//modem
+int lynq_modem_on(const int data,lynqBase *base)//data: 0:off,other:on
+{
+ char *argv[MAX_LEN] = {};
+ char dataStr[MAX_QUEST_LEN] = "";
+ argv[0] = data == 0 ? "RIL_REQUEST_MODEM_POWEROFF" : "RIL_REQUEST_MODEM_POWERON" ;
+ sprintf(dataStr, "%d", data);
+ argv[1] = dataStr;
+ int32_t token = 0;
+ lynqQueue *node = NULL;
+ RIL_Errno err=-1;
+ if(token = android::getRequestData(argv, 2))
+ {
+ base->request=(data == 0 ? RIL_REQUEST_MODEM_POWEROFF:RIL_REQUEST_MODEM_POWERON );
+ base->token = token;
+ node = commonFindParcelmsg(token,500,err);
+ base->e=err;
+ lynqDeQueue(token);
+ }
+ return token;
+}
+
+#if 0
+int lynq_enter_network_depersonalization(char *code)//code:network/depersonalization code
+{
+ char *argv[MAX_LEN] = {};
+ char dataStr[MAX_QUEST_LEN] = "";
+
+ argv[0] = "RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION";
+ argv[1] = code;
+
+ return android::getRequestData(argv, 2);
+}
+#endif