[Feature]Add Network feature and bb
Change-Id: Ie2ea14ab99278940e001bffa7879d27b79d5dbe2
diff --git a/src/lynq/lib/liblynq-network/LICENSE b/src/lynq/lib/liblynq-network/LICENSE
new file mode 100755
index 0000000..77f59ed
--- /dev/null
+++ b/src/lynq/lib/liblynq-network/LICENSE
@@ -0,0 +1,31 @@
+Copyright Statement:
+
+This software/firmware and related documentation ("MediaTek Software") are
+protected under relevant copyright laws. The information contained herein is
+confidential and proprietary to MediaTek Inc. and/or its licensors. Without
+the prior written permission of MediaTek inc. and/or its licensors, any
+reproduction, modification, use or disclosure of MediaTek Software, and
+information contained herein, in whole or in part, shall be strictly
+prohibited.
+
+MediaTek Inc. (C) 2015. All rights reserved.
+
+BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
+THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
+RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
+ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
+RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
+INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
+TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
+RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
+OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
+SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
+RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
+STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
+ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
+RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
+MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
+CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
diff --git a/src/lynq/lib/liblynq-network/include/lynq_network/lynq_network.h b/src/lynq/lib/liblynq-network/include/lynq_network/lynq_network.h
new file mode 100755
index 0000000..dc8aa82
--- /dev/null
+++ b/src/lynq/lib/liblynq-network/include/lynq_network/lynq_network.h
@@ -0,0 +1,77 @@
+#ifndef LYNQ_NETWORK_H
+#define LYNQ_NETWORK_H
+#include <vendor-ril/telephony/ril.h>
+#include <pthread.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CELLINFO_MAX_NUM 10
+/*T800 platform support gsm,wcdma lte,nr */
+typedef struct{
+ int gw_sig_valid; /*1 valid,1 invalid*/
+ int rssi; /* Valid values are (0-31, 99) as defined in TS 27.007 8.5 */
+ int wcdma_sig_valid;/*1 valid,0 invalid*/
+ int rscp; /* The Received Signal Code Power in dBm multipled by -1.
+ * Range : 25 to 120
+ * INT_MAX: 0x7FFFFFFF denotes invalid value.
+ * Reference: 3GPP TS 25.123, section 9.1.1.1 */
+ int ecno; /* Valid values are positive integers. This value is the actual Ec/Io multiplied
+ * by -10. Example: If the actual Ec/Io is -12.5 dB, then this response value
+ * will be 125.*/
+ int lte_sig_valid;/*1 valid,0 invalid*/
+ int rsrp; /* The current Reference Signal Receive Power in dBm multipled by -1.
+ * Range: 44 to 140 dBm
+ * INT_MAX: 0x7FFFFFFF denotes invalid value.
+ * Reference: 3GPP TS 36.133 9.1.4 */
+ int rsrq; /* The current Reference Signal Receive Quality in dB multiplied by -1.
+ * Range: 20 to 3 dB.
+ * INT_MAX: 0x7FFFFFFF denotes invalid value.
+ * Reference: 3GPP TS 36.133 9.1.7 */
+ int rssnr; /* The current reference signal signal-to-noise ratio in 0.1 dB units.
+ * Range: -200 to +300 (-200 = -20.0 dB, +300 = 30dB).
+ * INT_MAX : 0x7FFFFFFF denotes invalid value.
+ * Reference: 3GPP TS 36.101 8.1.1 */
+ int nr_sig_valid;/*1 valid,0 invalid*/
+ int ssRsrp; /* SS(Synchronization Signal) reference signal received power, multipled by -1.
+ * Reference: 3GPP TS 38.215.
+ * Range [44, 140], INT_MAX means invalid/unreported.*/
+ int ssRsrq; /* SS reference signal received quality, multipled by -1.
+ * Reference: 3GPP TS 38.215.
+ * Range [3, 20], INT_MAX means invalid/unreported.*/
+ int ssSinr; /* SS signal-to-noise and interference ratio.
+ * Reference: 3GPP TS 38.215 section 5.1.*, 3GPP TS 38.133 section 10.1.16.1.
+ * Range [-23, 40], INT_MAX means invalid/unreported.*/
+ int csiRsrp; /* CSI reference signal received power, multipled by -1.
+ * Reference: 3GPP TS 38.215.
+ * Range [44, 140], INT_MAX means invalid/unreported.*/
+ int csiRsrq; /* CSI reference signal received quality, multipled by -1.
+ * Reference: 3GPP TS 38.215.
+ * Range [3, 20], INT_MAX means invalid/unreported.*/
+ int csiSinr; /* CSI signal-to-noise and interference ratio.
+ * Reference: 3GPP TS 138.215 section 5.1.*, 3GPP TS 38.133 section 10.1.16.1.
+ * Range [-23, 40], INT_MAX means invalid/unreported.*/
+}signalStrength_t;
+
+int lynq_network_init(int utoken);
+int lynq_network_deinit(void);
+int lynq_query_operater(char *OperatorFN,char *OperatorSH,char *MccMnc);
+int lynq_query_network_selection_mode(int *netselMode);
+int lynq_set_network_selection_mode(const char *mode,const char* mccmnc);
+int lynq_query_available_network(char *OperatorFN,char *OperatorSH,char *MccMnc,char * NetStatus);
+int lynq_query_registration_state(const char *type,int* regState,int* imsRegState,char * LAC,char * CID,int *netType,int *radioTechFam);
+int lynq_query_prefferred_networktype(int *preNetType);
+int lynq_set_prefferred_networktype(const int preffertype);
+int lynq_query_cell_info(int cellinfo[CELLINFO_MAX_NUM],int * realNum);
+int lynq_set_unsol_cell_info_listrate(const int rate);
+int lynq_set_band_mode(const int bandmode);
+int lynq_query_available_bandmode(int availBanMode[]);
+int lynq_radio_on(const int data);
+int lynq_query_radio_tech(int* radioTech);
+int lynq_solicited_signal_strength(signalStrength_t *solSigStren);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/lynq/lib/liblynq-network/lynq_network.cpp b/src/lynq/lib/liblynq-network/lynq_network.cpp
new file mode 100755
index 0000000..3ed0512
--- /dev/null
+++ b/src/lynq/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;
+}
diff --git a/src/lynq/lib/liblynq-network/makefile b/src/lynq/lib/liblynq-network/makefile
new file mode 100755
index 0000000..7174f89
--- /dev/null
+++ b/src/lynq/lib/liblynq-network/makefile
@@ -0,0 +1,72 @@
+SHELL = /bin/sh
+RM = rm -f
+
+LOCAL_CFLAGS := -Wall \
+ -g -Os \
+ -flto \
+ -fPIC \
+ -DRIL_SHLIB \
+ -DATCI_PARSE \
+ -DKEEP_ALIVE \
+ -DECALL_SUPPORT
+
+
+
+$(warning ################# lynq network demo ROOT: $(ROOT),includedir:$(includedir))
+LOCAL_PATH = .
+
+LOCAL_C_INCLUDES = \
+ -I. \
+ -I$(LOCAL_PATH)/include/lynq_network \
+ -I$(ROOT)$(includedir)/logger \
+ -I$(ROOT)$(includedir)/liblog \
+ -I$(ROOT)$(includedir)/vendor-ril \
+ -I$(ROOT)$(includedir)/include \
+
+
+
+LOCAL_LIBS := \
+ -L. \
+ -ldl \
+ -llog \
+ -lbinder \
+ -lpthread \
+ -llynq-log \
+ -lutils \
+ -lcutils \
+
+SOURCES = $(wildcard *.cpp)
+
+EXECUTABLE = liblynq-network.so
+
+OBJECTS=$(SOURCES:.c=.o)
+all: $(EXECUTABLE)
+
+$(EXECUTABLE): $(OBJECTS)
+ $(CXX) -shared -Wl,--no-undefined $(OBJECTS) $(LOCAL_LIBS) $(LOCAL_CFLAGS) $(LOCAL_C_INCLUDES) -o $@
+
+%.o : %.c
+ $(CC) $(LOCAL_C_INCLUDES) $(LOCAL_CFLAGS) $(LOCAL_LIBS) -o $@ -c $<
+
+build: $(EXECUTABLE)
+ $(warning ########## build $(EXECUTABLE) ##########)
+
+install:
+ $(warning ################# lynq network demo EXECUTABLE: $(EXECUTABLE),base:$(base_libdir))
+ mkdir -p $(ROOT)$(base_libdir)/
+ install $(EXECUTABLE) $(ROOT)$(base_libdir)/
+
+pack_rootfs:
+ $(warning ################# lynq network demo PACK: $(PACK_INITRAMFS_TO),base:$(base_libdir))
+ mkdir -p $(PACK_INITRAMFS_TO)$(base_libdir)/
+ cp -af $(EXECUTABLE) $(PACK_INITRAMFS_TO)$(base_libdir)/
+ $(CROSS)strip $(PACK_INITRAMFS_TO)$(base_libdir)/$(EXECUTABLE)
+ mkdir -p $(PACK_TO)$(base_libdir)/
+ cp -af $(EXECUTABLE) $(PACK_TO)$(base_libdir)/
+ $(CROSS)strip $(PACK_TO)$(base_libdir)/$(EXECUTABLE)
+
+.PHONY: clean
+clean:
+ $(RM) $(OBJECTS) $(EXECUTABLE)
+
+