[Feature]SDK service add
Change-Id: Idc75b210fba44f45ee098c447fe2d3aab83e4e20
diff --git a/src/lynq/lib/liblynq-call/LICENSE b/src/lynq/lib/liblynq-call/LICENSE
new file mode 100755
index 0000000..77f59ed
--- /dev/null
+++ b/src/lynq/lib/liblynq-call/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-call/include/libcall/lynq_call.h b/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h
new file mode 100755
index 0000000..c37f86a
--- /dev/null
+++ b/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h
@@ -0,0 +1,58 @@
+#ifndef LYNQ_CALL_H
+#define LYNQ_CALL_H 1
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define LYNQ_PHONE_NUMBER_MAX 32
+#define INDEX_IS_NUMBER( alpha_char ) \
+ ( ( (alpha_char >= '0') && (alpha_char <= '9') ) ? 1 : 0 )
+#define LYNQ_CALL_MAX 10
+#define LYNQ_CALL_FAIL_VENDOR_CAUSE 64
+typedef enum {
+ CALL_FAIL_UNOBTAINABLE_NUMBER = 1,
+ CALL_FAIL_NORMAL = 16,
+ CALL_FAIL_BUSY = 17,
+ CALL_FAIL_CONGESTION = 34,
+ CALL_FAIL_ACM_LIMIT_EXCEEDED = 68,
+ CALL_FAIL_CALL_BARRED = 240,
+ CALL_FAIL_FDN_BLOCKED = 241,
+ CALL_FAIL_IMSI_UNKNOWN_IN_VLR = 242,
+ CALL_FAIL_IMEI_NOT_ACCEPTED = 243,
+ CALL_FAIL_DIAL_MODIFIED_TO_USSD = 244, /* STK Call Control */
+ CALL_FAIL_DIAL_MODIFIED_TO_SS = 245,
+ CALL_FAIL_DIAL_MODIFIED_TO_DIAL = 246,
+ CALL_FAIL_CDMA_LOCKED_UNTIL_POWER_CYCLE = 1000,
+ CALL_FAIL_CDMA_DROP = 1001,
+ CALL_FAIL_CDMA_INTERCEPT = 1002,
+ CALL_FAIL_CDMA_REORDER = 1003,
+ CALL_FAIL_CDMA_SO_REJECT = 1004,
+ CALL_FAIL_CDMA_RETRY_ORDER = 1005,
+ CALL_FAIL_CDMA_ACCESS_FAILURE = 1006,
+ CALL_FAIL_CDMA_PREEMPTED = 1007,
+ CALL_FAIL_CDMA_NOT_EMERGENCY = 1008, /* For non-emergency number dialed
+ during emergency callback mode */
+ CALL_FAIL_CDMA_ACCESS_BLOCKED = 1009, /* CDMA network access probes blocked */
+ CALL_FAIL_ERROR_UNSPECIFIED = 0xffff
+} lynq_last_call_fail_cause_t;
+typedef struct
+{
+ lynq_last_call_fail_cause_t cause_code;
+ char vendor_cause[LYNQ_CALL_FAIL_VENDOR_CAUSE];
+}lynqLastCallFailCause;
+int lynq_init_call(int uToken);
+int lynq_deinit_call();
+int lynq_call(int *handle,char addr[]);
+int lynq_call_answer();
+int lynq_call_hungup(int*handle);
+int lynq_call_hungup_all();
+int lynq_wait_incoming_call(int *handle);
+int lynq_set_auto_answercall(const int mode);
+int lynq_get_mute_status(int *status);
+int lynq_set_mute_mic(const int enable);
+int lynq_set_DTMF(const char callnum);
+int lynq_set_DTMF_volume(const int volume);
+int lynq_get_current_call_state(int *handle, int *call_state,int *toa,int *direction,char addr[]);
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/lynq/lib/liblynq-call/lynq_call.cpp b/src/lynq/lib/liblynq-call/lynq_call.cpp
new file mode 100755
index 0000000..cb9cde6
--- /dev/null
+++ b/src/lynq/lib/liblynq-call/lynq_call.cpp
@@ -0,0 +1,901 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <binder/Parcel.h>
+#include <log/log.h>
+#include "lynq_call.h"
+#include <cutils/jstring.h>
+#include <pthread.h>
+#include "liblog/lynq_deflog.h"
+#include <sys/time.h>
+
+#define LYNQ_SERVICE_PORT 8088
+#define LYNQ_URC_SERVICE_PORT 8086
+#define LYNQ_REC_BUF 8192
+#define LYNQ_REQUEST_PARAM_BUF 8192
+#define LYQN_SEDN_BUF 1024*8+sizeof(int)*3
+#define USER_LOG_TAG "LYNQ_CALL"
+
+using ::android::Parcel;
+ typedef enum {
+ LYNQ_CALL_ACTIVE = 0,
+ LYNQ_CALL_HOLDING = 1,
+ LYNQ_CALL_DIALING = 2, /* MO call only */
+ LYNQ_CALL_ALERTING = 3, /* MO call only */
+ LYNQ_CALL_INCOMING = 4, /* MT call only */
+ LYNQ_CALL_WAITING = 5 ,/* MT call only */
+}lynq_call_state_t;
+
+typedef struct{
+ int uToken;
+ int request;
+ int paramLen;
+ char param[LYNQ_REQUEST_PARAM_BUF];
+}lynq_client_t;
+typedef struct
+{
+ int used;
+ int call_id;
+ int call_state;
+ int toa;
+ int direction;/*0: MO call,1:MT call*/
+ char addr[LYNQ_PHONE_NUMBER_MAX];
+ int hasTimeout;
+}lynq_call_list_e_t;
+typedef struct
+{
+ int call_id;
+ int call_state;
+ int toa;
+ int direction;/*0: MO call,1:MT call*/
+ char addr[LYNQ_PHONE_NUMBER_MAX];
+}lynq_call_list_t;
+
+lynq_call_list_e_t lynq_call_lists[LYNQ_CALL_MAX]={};
+static pthread_mutex_t call_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t call_state_change_cond = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t s_urc_call_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_urc_call_state_change_cond = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t s_incoming_call_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_incoming_call_cond = PTHREAD_COND_INITIALIZER;
+
+
+int s_urc_event_complete = 1;
+
+enum{
+ CALL_OFF=0,
+ CALL_ON=1
+}call_state;
+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;
+
+int lynq_call_state =CALL_OFF;
+int lynq_client_sockfd = 0;
+int Global_uToken = 0;
+int global_call_count =0;
+int global_call_auto_answer = 0;
+bool urc_recive_status = 1;
+bool call_list_loop = 1;
+int isDial = 0;
+int lynqIncomingCallId = 0;
+
+int JumpHeader(Parcel &p,int *resp_type,int *request,int *slot_id,int *error)
+{
+ if(p.dataAvail() > 0)
+ {
+ p.readInt32(resp_type);
+ p.readInt32(request);
+ p.readInt32(slot_id);
+ p.readInt32(error);
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+int send_request(int sockfd,lynq_client_t *client_tmp)
+{
+ int ret=0;
+ ret = write(sockfd, client_tmp, LYQN_SEDN_BUF);
+ if(ret==-1)
+ {
+ perror("write error");
+ return -1;
+ }
+ return 0;
+}
+
+int get_response(int sockfd,Parcel &p)
+{
+ int len = 0;
+ char recvline[LYNQ_REC_BUF];
+ bzero(recvline,LYNQ_REC_BUF);
+ /* receive data from server */
+ len = read(sockfd, recvline, LYNQ_REC_BUF);
+ if(len == -1)
+ {
+ perror("read error");
+ return -1;
+ }
+ printf("===>n=%d\n",len);
+ if (recvline != NULL) {
+ p.setData((uint8_t *)recvline,len); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ }
+ return 0;
+}
+static char *strdupReadString(Parcel &p) {
+ size_t stringlen;
+ const char16_t *s16;
+ s16 = p.readString16Inplace(&stringlen);
+ return strndup16to8(s16, stringlen);
+}
+
+int lynq_get_current_call_list(lynq_call_list_t call_list[LYNQ_CALL_MAX])
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ int call_num = 0;
+ int temp = 0;
+ char *remote_phoneNum = NULL;
+ char *remote_name= NULL;
+ char *uusData = NULL;
+ client.uToken = Global_uToken;
+ client.request = 9;//RIL_REQUEST_GET_CURRENT_CALLS
+ client.paramLen = 0;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ LYDBGLOG("uToken=%d,request=%d,paralen=%d,param=%s\n",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_CALL] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ if(error == 0)
+ {
+ p.readInt32(&call_num);
+ global_call_count = call_num;
+ if(call_num<=0)
+ {
+ lynq_call_state = CALL_OFF;
+ return 0;
+ }
+ for(int i = 0;i < call_num;i++)
+ {
+ p.readInt32(&temp);
+ call_list[i].call_state = temp;
+ p.readInt32(&call_list[i].call_id);
+ p.readInt32(&call_list[i].toa);
+ p.readInt32(&temp);
+ p.readInt32(&temp);
+ call_list[i].direction = temp;
+ p.readInt32(&temp);
+ p.readInt32(&temp);
+ p.readInt32(&temp);
+ remote_phoneNum = strdupReadString(p);
+ memcpy(call_list[i].addr,remote_phoneNum,strlen(remote_phoneNum));
+ LYINFLOG("call_id=%d,call_state=%d,direction=%d,addr=%s,toa=%d",call_list[i].call_id,call_list[i].call_state,
+ call_list[i].direction,call_list[i].addr,call_list[i].toa);
+ p.readInt32(&temp);
+ remote_name = strdupReadString(p);
+ p.readInt32(&temp);
+ p.readInt32(&temp);
+ if(temp==0)
+ {
+ continue;
+ }
+ p.readInt32(&temp); /* UUS Information is present */
+ p.readInt32(&temp);
+ p.readInt32(&temp);
+ p.read(uusData,temp);
+ }
+ }
+ return 0;
+}
+
+void cleanCallList(int lynq_call_id)
+{
+ lynq_call_lists[lynq_call_id].call_id = 0;
+ lynq_call_lists[lynq_call_id].call_state = 0;
+ lynq_call_lists[lynq_call_id].toa = 0;
+ lynq_call_lists[lynq_call_id].direction = 0;
+ lynq_call_lists[lynq_call_id].used = 0;
+ lynq_call_lists[lynq_call_id].hasTimeout = 0;
+ memset(lynq_call_lists[lynq_call_id].addr,0,sizeof(lynq_call_lists[lynq_call_id].addr));
+}
+int getUnusedElement()
+{
+ for(int i=0;i < LYNQ_CALL_MAX; i++)
+ {
+ if(lynq_call_lists[i].used!=1)
+ {
+ return i;
+ }
+ }
+ return -1;
+}
+int updateAddr(char addr[])
+{
+ int ret = 0;
+ ret = getUnusedElement();
+ memcpy(lynq_call_lists[ret].addr,addr,strlen(addr)+1);
+ lynq_call_lists[ret].used = 1;
+ return ret;
+}
+void updateCallList(lynq_call_list_e_t *callList, int call_id,int call_state,int toa,int direction)
+{
+ callList->call_id = call_id;
+ callList->call_state = call_state;
+ callList->toa = toa;
+ callList->direction = direction;
+ callList->used = 1;
+ callList->hasTimeout = 0;
+ return;
+}
+int waitCallstateChange(int mtime)
+{
+ int ret = 0;
+ int sec = 0;
+ int usec = 0;
+ struct timeval now;
+ struct timespec timeout;
+ gettimeofday(&now,NULL);
+ sec = mtime/1000;
+ usec = mtime%1000;
+ timeout.tv_sec = now.tv_sec+sec;
+ timeout.tv_nsec = now.tv_usec*1000+usec*1000000;
+ pthread_mutex_lock(&call_state_change_mutex);
+ ret = pthread_cond_timedwait(&call_state_change_cond,&call_state_change_mutex,&timeout);
+ pthread_mutex_unlock(&call_state_change_mutex);
+ return ret;
+}
+int waitIncomingCall()
+{
+ int ret = 0;
+ pthread_mutex_lock(&s_incoming_call_mutex);
+ ret = pthread_cond_wait(&s_incoming_call_cond,&s_incoming_call_mutex);
+ pthread_mutex_unlock(&s_incoming_call_mutex);
+ return ret;
+}
+int checkHasCall(char addr[])
+{
+ for(int i = 0;i<LYNQ_CALL_MAX;i++)
+ {
+ if(strcmp(lynq_call_lists[i].addr,addr)==0)
+ {
+ return 1;
+ }
+ }
+ return 0;
+}
+void sendSignalToWaitCallStateChange()
+{
+ pthread_mutex_lock(&call_state_change_mutex);
+ pthread_cond_signal(&call_state_change_cond);
+ pthread_mutex_unlock(&call_state_change_mutex);
+}
+void sendSignalIncomingCall()
+{
+ pthread_mutex_lock(&s_incoming_call_mutex);
+ pthread_cond_signal(&s_incoming_call_cond);
+ pthread_mutex_unlock(&s_incoming_call_mutex);
+}
+
+void addCallListToLynqCallList(lynq_call_list_e_t *callList, int call_id,int call_state,int toa,int direction,char addr[LYNQ_PHONE_NUMBER_MAX])
+{
+ callList->call_id = call_id;
+ callList->call_state = call_state;
+ callList->toa = toa;
+ callList->direction = direction;
+ memcpy(callList->addr,addr,strlen(addr)+1);
+ callList->used = 1;
+ callList->hasTimeout = 0;
+ return;
+}
+
+void *triggerGetCallList(void *parg)
+{
+ int ret=0;
+ lynq_call_list_t call_list[LYNQ_CALL_MAX];
+ while(call_list_loop)
+ {
+ pthread_mutex_lock(&s_urc_call_state_change_mutex);
+ pthread_cond_wait(&s_urc_call_state_change_cond, &s_urc_call_state_change_mutex);
+ LYDBGLOG("triggerGetCallList event!!!\n");
+ memset(call_list,0,sizeof(call_list));
+ ret = lynq_get_current_call_list(call_list);
+ if(ret != 0)
+ {
+ printf("get current call list failure!!!\n");
+ break;
+ }
+ for(int i = 0;i < LYNQ_CALL_MAX;i++)
+ {
+ if(call_list[i].direction == 1)//MT call
+ {
+ if(call_list[i].call_state ==4)//LYNQ_CALL_INCOMING = 4, /* MT call only */
+ {
+ if(!checkHasCall(call_list[i].addr))
+ {
+ lynqIncomingCallId = getUnusedElement();
+ addCallListToLynqCallList(&lynq_call_lists[lynqIncomingCallId],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction,call_list[i].addr);
+ sendSignalIncomingCall();
+ }
+ }
+ }
+ else
+ {
+ if(call_list[i].call_id==0)
+ {
+ break;
+ }
+ for(int n = 0 ; n < LYNQ_CALL_MAX; n++)
+ {
+ if(lynq_call_lists[n].hasTimeout==1)
+ {
+ /*hangup call with id*/
+ lynq_call_hungup(&n);
+ lynq_call_lists[n].hasTimeout==0;
+ continue;
+ }
+ if(strcmp(call_list[i].addr,lynq_call_lists[n].addr)==0)
+ {
+ updateCallList(&lynq_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
+ }
+ }
+ LYDBGLOG("[count:%d]call_id=%d,call_state=%d,direction=%d,addr=%s,toa=%d",i,call_list[i].call_id,call_list[i].call_state,
+ call_list[i].direction,call_list[i].addr,call_list[i].toa);
+ }
+ }
+ s_urc_event_complete = 1;
+ if(isDial==1)
+ {
+ sendSignalToWaitCallStateChange();
+ isDial = 0;
+ }
+ pthread_mutex_unlock(&s_urc_call_state_change_mutex);
+ }
+ return NULL;
+}
+
+void lynqRespWatingEvent()
+{
+ if(s_urc_event_complete==1)
+ {
+ pthread_mutex_lock(&s_urc_call_state_change_mutex);
+ pthread_cond_signal(&s_urc_call_state_change_cond);
+ s_urc_event_complete = 0;
+ pthread_mutex_unlock(&s_urc_call_state_change_mutex);
+ }
+ return;
+}
+
+/*Warren add for T800 platform 2021/11/19 start*/
+int lynq_socket_client_start()
+{
+ struct sockaddr_in lynq_socket_server_addr;
+ /* init lynq_socket_server_addr */
+ bzero(&lynq_socket_server_addr, sizeof(lynq_socket_server_addr));
+ lynq_socket_server_addr.sin_family = AF_INET;
+ lynq_socket_server_addr.sin_port = htons(LYNQ_SERVICE_PORT);
+ lynq_socket_server_addr.sin_addr.s_addr = htons(INADDR_ANY);
+ /*
+ if(inet_pton(AF_INET,"127.0.0.1", &lynq_socket_server_addr.sin_addr) <= 0)
+ {
+ printf("[%s] is not a valid IPaddress\n", argv[1]);
+ exit(1);
+ }
+*/
+ lynq_client_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+ if(connect(lynq_client_sockfd, (struct sockaddr *)&lynq_socket_server_addr, sizeof(lynq_socket_server_addr)) == -1)
+ {
+ perror("connect error");
+ return -1;
+ }
+ return 0;
+}
+int lynq_update_call_list_loop()
+{
+ int ret = 0;
+ pthread_t tid;
+ pthread_attr_t attr;
+ pthread_attr_init(&attr);
+ pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ ret = pthread_create(&tid,&attr,triggerGetCallList,NULL);
+ if(ret < 0)
+ {
+ LYERRLOG("lynq_update_call_list_loop fail!!!");
+ return -1;
+ }
+ LYDBGLOG("lynq_update_call_list_loop success!!!\n");
+ return 0;
+
+}
+void *thread_urc_recv(void *parg)
+{
+ int socket_fd = (int64_t)parg;
+ int len=0;
+ socklen_t addr_len=0;
+ uint8_t *dataLength = NULL;
+ char urc_data[LYNQ_REC_BUF];
+ int slot_id = -1;
+ int resp_type = -1;
+ int urcid = -1;
+ Parcel *p = NULL;
+ struct sockaddr_in dest_addr;
+ LYINFLOG("thread_urc_recv in running....\n");
+ while(urc_recive_status)
+ {
+ bzero(urc_data,LYNQ_REC_BUF);
+ //get data msg
+ len = recvfrom(socket_fd,urc_data,LYNQ_REC_BUF,0,(struct sockaddr *)&dest_addr,&addr_len);
+ if(len <= 0)
+ {
+ perror("thread_urc_recv step2 fail:");
+ break;
+ }
+ LYDBGLOG("=====>urc data len<=====:%d\n",len);
+ p = new Parcel();
+ if(p==NULL)
+ {
+ RLOGD("new parcel failure!!!");
+ break;
+ }
+ p->setData((uint8_t *)urc_data,len); // p.setData((uint8_t *) buffer, buflen);
+ p->setDataPosition(0);
+ if(p->dataAvail() > 0)
+ {
+ p->readInt32(&resp_type);
+ p->readInt32(&urcid);
+ p->readInt32(&slot_id);
+ //LYDBGLOG("*******Warren test*******:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
+ switch (urcid)
+ {
+ case 1001://RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED
+ {
+ LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
+ lynqRespWatingEvent();
+ break;
+ }
+ case 1018://RIL_UNSOL_CALL_RING
+ {
+ if(global_call_auto_answer==1)
+ {
+ lynq_call_answer();
+ }
+ break;
+ }
+ case 1029://RIL_UNSOL_RINGBACK_TONE
+ case 3049://RIL_UNSOL_CALL_INFO_INDICATION
+ {
+ LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ delete p;
+ p = NULL;
+ }
+ close(socket_fd);
+}
+int lynq_socket_urc_start()
+{
+ int socket_fd=0;
+ int rt=0;
+ int len=0;
+ int on=1;
+ struct sockaddr_in urc_local_addr;
+ pthread_t tid;
+ pthread_attr_t attr;
+ socket_fd = socket(AF_INET,SOCK_DGRAM,0);
+ printf("test 001\n");
+ if(socket_fd < 0)
+ {
+ perror("creaet socket for udp fail");
+ return -1;
+ }
+ urc_local_addr.sin_family = AF_INET;
+ urc_local_addr.sin_port = htons(LYNQ_URC_SERVICE_PORT);
+ urc_local_addr.sin_addr.s_addr = htons(INADDR_ANY);
+ /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
+ rt = setsockopt(socket_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
+ if(rt<0)
+ {
+ perror("SO_REUSEADDR fail\n");
+ return -1;
+ }
+ rt = bind(socket_fd ,(struct sockaddr*)&urc_local_addr, sizeof(urc_local_addr));
+ if (rt == -1)
+ {
+ perror("bind failed");
+ return -1;
+ }
+ pthread_attr_init(&attr);
+ pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ rt = pthread_create(&tid,&attr,thread_urc_recv,(void *)socket_fd);
+ if(rt < 0)
+ {
+ printf("urc loop failure!!!\n");
+ return -1;
+ }
+ printf("urc loop success!!!\n");
+ return 0;
+}
+int getSelfElement(char addr[])
+{
+ for(int i=0;i < LYNQ_CALL_MAX; i++)
+ {
+ if(lynq_call_lists[i].used==1)
+ {
+ if(strcmp(lynq_call_lists[i].addr,addr)==0)
+ {
+ return i;
+ }
+
+ }
+ }
+ return -1;
+}
+
+void lynq_call_state_change_test(int soc_id)
+{
+ printf("call state change,sim:%d\n",soc_id);
+}
+int lynq_init_call(int uToken)
+{
+ int result = 0;
+ Global_uToken = uToken;
+ LYLOGSET(LOG_INFO);
+ LYLOGEINIT(USER_LOG_TAG);
+ result = lynq_socket_client_start();
+ if(result!=0)
+ {
+ return -1;
+ }
+ result = lynq_socket_urc_start();
+ if(result!=0)
+ {
+ return -1;
+ }
+ result = lynq_update_call_list_loop();
+ if(result!=0)
+ {
+ return -1;
+ }
+ memset(lynq_call_lists,0,sizeof(lynq_call_lists));
+ LYDBGLOG("lynq init call success!!!");
+ return 0;
+}
+int lynq_deinit_call()
+{
+ close(lynq_client_sockfd);
+ urc_recive_status = 0;
+ call_list_loop = 0;
+ return 0;
+}
+int lynq_call(int* handle,char addr[])
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ int lynq_call_id = -1;
+ if(addr==NULL)
+ {
+ LYERRLOG("Phone num is null!!!");
+ return -1;
+ }
+ client.uToken = Global_uToken;
+ client.request = 10;//RIL_REQUEST_DIAL
+ client.paramLen = 2;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ memcpy(client.param,addr,strlen(addr)+1);
+ strcat(client.param," 0");
+ LYERRLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_CALL] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ lynq_call_id = updateAddr(addr);
+ if(error==0)
+ {
+ isDial = 1;
+ if(waitCallstateChange(3000)==ETIMEDOUT)//3000ms
+ {
+ error = LYNQ_E_TIME_OUT;
+ LYERRLOG("timeout:wait Call state fail!!!");
+ lynq_call_lists[lynq_call_id].hasTimeout = 1;
+ *handle = lynq_call_id;
+ return error;
+ }
+ *handle = lynq_call_id;
+ }
+ return error;
+}
+int lynq_call_answer()
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ client.uToken = Global_uToken;
+ client.request = 40;//RIL_REQUEST_DIAL
+ client.paramLen = 0;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ LYDBGLOG("uToken=%d,request=%d,paralen=%d,param=%s\n",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_CALL] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ return error;
+}
+int lynq_call_hungup(int* handle)
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ int call_id = 0;
+ int lynq_call_id = 0;
+ client.uToken = Global_uToken;
+ client.request = 12;//RIL_REQUEST_HUNGUP
+ client.paramLen = 1;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ lynq_call_id = *handle;
+ call_id = lynq_call_lists[lynq_call_id].call_id;
+ sprintf(client.param,"%d",call_id);
+ LYDBGLOG("uToken=%d,request=%d,paralen=%d,param=%s\n",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_CALL] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ if(error==0)
+ {
+ cleanCallList(lynq_call_id);
+ }
+ return error;
+}
+int lynq_call_hungup_all()
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ client.uToken = Global_uToken;
+ client.request = 17;//RIL_REQUEST_UDUB
+ client.paramLen = 0;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ LYDBGLOG("uToken=%d,request=%d,paralen=%d,param=%s\n",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_CALL] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ return error;
+}
+int lynq_wait_incoming_call(int *handle)
+{
+ waitIncomingCall();
+ *handle = lynqIncomingCallId;
+ LYINFLOG("lynq incoming call id:%d",lynqIncomingCallId);
+ return 0;
+}
+
+int lynq_set_auto_answercall(const int mode)
+{
+ global_call_auto_answer = mode;
+ LYINFLOG("auto answer call mode =%d",mode);
+ return 0;
+}
+int lynq_get_mute_status(int *status)
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ if(status==NULL)
+ {
+ LYERRLOG("status is null");
+ return -1;
+ }
+ client.uToken = Global_uToken;
+ client.request = 54;//RIL_REQUEST_GET_MUTE
+ client.paramLen = 0;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ LYDBGLOG("uToken=%d,request=%d,paralen=%d,param=%s\n",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_CALL] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ p.readInt32(status);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ return error;
+}
+int lynq_set_mute_mic(const int enable)
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ client.uToken = Global_uToken;
+ client.request = 53;//RIL_REQUEST_SET_MUTE
+ client.paramLen = 1;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ sprintf(client.param,"%d",enable);
+ LYDBGLOG("uToken=%d,request=%d,paralen=%d,param=%s\n",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_CALL] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ return error;
+}
+int lynq_set_DTMF(const char callnum)
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ if(!lynq_call_state)
+ {
+ LYERRLOG("LYNQ_E_CONFLICT");
+ return LYNQ_E_CONFLICT;
+ }
+ client.uToken = Global_uToken;
+ client.request = 24;//RIL_REQUEST_DTMF
+ client.paramLen = 1;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ sprintf(client.param,"%c",callnum);
+ LYDBGLOG("uToken=%d,request=%d,paralen=%d,param=%s\n",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_CALL] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ return error;
+
+}
+int lynq_set_DTMF_volume(const int volume)
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ //if(!lynq_call_state)
+ //{
+ // LYERRLOG("LYNQ_E_CONFLICT");
+ // return LYNQ_E_CONFLICT;
+ //}
+ client.uToken = Global_uToken;
+ client.request = 8003;//LYNQ_REQUEST_SET_DTMF_VOLUME
+ client.paramLen = 1;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ sprintf(client.param,"%d",volume);
+ LYDBGLOG("uToken=%d,request=%d,paralen=%d,param=%s\n",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_CALL] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ return 0;
+}
+int lynq_get_current_call_state(int *handle, int *call_state,int *toa,int *direction,char addr[])
+{
+ int lynq_call_id = 0;
+ if(handle==NULL)
+ {
+ return LYNQ_E_NULL_ANONALY;
+ }
+ lynq_call_id = *handle;
+ *call_state = lynq_call_lists[lynq_call_id].call_state;
+ *toa = lynq_call_lists[lynq_call_id].toa;
+ *direction = lynq_call_lists[lynq_call_id].direction;
+ memcpy(addr,lynq_call_lists[lynq_call_id].addr,strlen(lynq_call_lists[lynq_call_id].addr)+1);
+ return 0;
+}
+
+#if 0
+int main(int argc,char **argv)
+{
+ int n = 0;
+ n = lynq_init_call(lynq_call_state_change_test,2222);
+ if(n<0)
+ {
+ printf("lynq init call fail!!!\n");
+ return -1;
+ }
+ printf("lynq call init success!!!\n");
+ char phoneNum[LYNQ_PHONE_NUMBER_MAX];
+ sprintf(phoneNum,"18180053406 0",strlen("18180053406 0")+1);
+ lynq_call(phoneNum);
+ while(1)
+ {
+ sleep(1);
+ }
+ return 0;
+}
+#endif
+/*Warren add for T800 platform 2021/11/19 end*/
diff --git a/src/lynq/lib/liblynq-call/makefile b/src/lynq/lib/liblynq-call/makefile
new file mode 100755
index 0000000..cacaf71
--- /dev/null
+++ b/src/lynq/lib/liblynq-call/makefile
@@ -0,0 +1,70 @@
+SHELL = /bin/sh
+RM = rm -f
+
+LOCAL_CFLAGS := -Wall \
+ -std=gnu++14 \
+ -g -Os \
+ -flto \
+ -DRIL_SHLIB \
+ -DATCI_PARSE \
+ -fPIC \
+ -DKEEP_ALIVE \
+ -DECALL_SUPPORT \
+ -fpermissive \
+
+
+
+$(warning ################# lynq data demo ROOT: $(ROOT),includedir:$(includedir))
+LOCAL_PATH = .
+
+LOCAL_C_INCLUDES = \
+ -I. \
+ -I$(LOCAL_PATH)/include/libcall \
+ -I$(ROOT)$(includedir)/logger \
+ -I$(ROOT)$(includedir)/liblog \
+
+
+LOCAL_LIBS := \
+ -L. \
+ -ldl \
+ -lstdc++ \
+ -llog \
+ -lcutils \
+ -lutils \
+ -lbinder \
+ -lpthread \
+ -llynq-log \
+
+
+SOURCES = $(wildcard *.cpp)
+
+EXECUTABLE = liblynq-call.so
+
+OBJECTS=$(SOURCES:.cpp=.o)
+
+
+.PHONY: build clean install pack_rootfs
+all: build
+$(EXECUTABLE): $(OBJECTS)
+ $(CXX) -shared -Wl,--no-undefined $(OBJECTS) $(LOCAL_LIBS) $(LOCAL_CFLAGS) $(LOCAL_C_INCLUDES) -o $@
+
+%.o : %.cpp
+ $(CXX) $(LOCAL_C_INCLUDES) $(LOCAL_CFLAGS) $(LOCAL_LIBS) -o $@ -c $<
+
+build: $(EXECUTABLE)
+ $(warning ########## build $(EXECUTABLE) ##########)
+install:
+ mkdir -p $(ROOT)$(base_libdir)/
+ install $(EXECUTABLE) $(ROOT)$(base_libdir)/
+ mkdir -p $(ROOT)$(includedir)/$(NAME)/sdk
+pack_rootfs:
+ 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)
+ -find . -name "*.o" -delete
diff --git a/src/lynq/lib/liblynq-data/LICENSE b/src/lynq/lib/liblynq-data/LICENSE
new file mode 100755
index 0000000..77f59ed
--- /dev/null
+++ b/src/lynq/lib/liblynq-data/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-data/include/libdata/lynq_data.h b/src/lynq/lib/liblynq-data/include/libdata/lynq_data.h
new file mode 100755
index 0000000..2503f5d
--- /dev/null
+++ b/src/lynq/lib/liblynq-data/include/libdata/lynq_data.h
@@ -0,0 +1,63 @@
+#ifndef LYNQ_DATA_H
+#define LYNQ_DATA_H 1
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define LYNQ_APN_CHANNEL_MAX 10
+#define LYNQ_PDP_TYPE_MAX_LEN 16
+#define LYNQ_IFACE_NAME_MAX_LEN 50
+#define LYNQ_APN_MAX_LEN 50
+#define LYNQ_APN_TYPE_MAX_LEN 50
+#define LYNQ_PDP_ADDR_MAX_LEN 64
+#define LYNQ_DNS_ADDR_MAX_LEN 64
+#define LYNQ_GETWAYS_ADDR_MAX_LEN 64
+#define LYNQ_POXY_ADDR_MAX_LEN 64
+
+typedef struct {
+ int status; /* A RIL_DataCallFailCause, 0 which is PDP_FAIL_NONE if no error */
+ int suggestedRetryTime; /* If status != 0, this fields indicates the suggested retry
+ back-off timer value RIL wants to override the one
+ pre-configured in FW.
+ The unit is miliseconds.
+ The value < 0 means no value is suggested.
+ The value 0 means retry should be done ASAP.
+ The value of INT_MAX(0x7fffffff) means no retry. */
+ int cid; /* Context ID, uniquely identifies this call */
+ int active; /* 0=inactive, 1=active/physical link down, 2=active/physical link up */
+ char type[LYNQ_PDP_TYPE_MAX_LEN]; /* One of the PDP_type values in TS 27.007 section 10.1.1.
+ For example, "IP", "IPV6", "IPV4V6", or "PPP". If status is
+ PDP_FAIL_ONLY_SINGLE_BEARER_ALLOWED this is the type supported
+ such as "IP" or "IPV6" */
+ char ifname[LYNQ_IFACE_NAME_MAX_LEN]; /* The network interface name */
+ char addresses[LYNQ_PDP_ADDR_MAX_LEN]; /* A space-delimited list of addresses with optional "/" prefix length,
+ e.g., "192.0.1.3" or "192.0.1.11/16 2001:db8::1/64".
+ May not be empty, typically 1 IPv4 or 1 IPv6 or
+ one of each. If the prefix length is absent the addresses
+ are assumed to be point to point with IPv4 having a prefix
+ length of 32 and IPv6 128. */
+ char dnses[LYNQ_DNS_ADDR_MAX_LEN]; /* A space-delimited list of DNS server addresses,
+ e.g., "192.0.1.3" or "192.0.1.11 2001:db8::1".
+ May be empty. */
+ char gateways[LYNQ_GETWAYS_ADDR_MAX_LEN]; /* A space-delimited list of default gateway addresses,
+ e.g., "192.0.1.3" or "192.0.1.11 2001:db8::1".
+ May be empty in which case the addresses represent point
+ to point connections. */
+ char pcscf[LYNQ_POXY_ADDR_MAX_LEN]; /* the Proxy Call State Control Function address
+ via PCO(Protocol Configuration Option) for IMS client. */
+ int mtu; /* MTU received from network
+ Value <= 0 means network has either not sent a value or
+ sent an invalid value */
+} lynq_data_call_response_v11_t;
+int lynq_init_data(int uToken);
+int lynq_deinit_data();
+int lynq_setup_data_call(int *handle);
+int lynq_deactive_data_call(int *handle);
+int lynq_setup_data_call_sp(int *handle,char *apn,char *apnType,char *user,char *password,char *authType,char *normalProtocol,char *roamingProtocol);
+//int lynq_deactive_data_call_sp(int *handle,char *apnType);
+int lynq_get_data_call_list(int *handle,lynq_data_call_response_v11_t dataCallList);
+int lynq_wait_data_call_state_change(int *handle);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/lynq/lib/liblynq-data/lynq_data.cpp b/src/lynq/lib/liblynq-data/lynq_data.cpp
new file mode 100755
index 0000000..b1f8512
--- /dev/null
+++ b/src/lynq/lib/liblynq-data/lynq_data.cpp
@@ -0,0 +1,772 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <binder/Parcel.h>
+#include <log/log.h>
+#include "lynq_data.h"
+#include <cutils/jstring.h>
+#include <pthread.h>
+#include "liblog/lynq_deflog.h"
+#include <sys/time.h>
+#define LYNQ_SERVICE_PORT 8088
+#define LYNQ_URC_SERVICE_PORT 8086
+#define LYNQ_REC_BUF 8192
+#define LYNQ_REQUEST_PARAM_BUF 8192
+#define LYQN_SEDN_BUF 1024*8+sizeof(int)*3
+#define USER_LOG_TAG "LYNQ_DATA"
+
+using ::android::Parcel;
+typedef struct{
+ int uToken;
+ int request;
+ int paramLen;
+ char param[LYNQ_REQUEST_PARAM_BUF];
+}lynq_client_t;
+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;
+
+int lynq_client_sockfd = 0;
+int Global_uToken = 0;
+bool urc_recive_status = 1;
+int lynq_data_call_change_id = -1;
+static pthread_mutex_t s_data_call_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_data_call_state_change_cond = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t s_pdn_change_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_pdn_change_cond = PTHREAD_COND_INITIALIZER;
+
+typedef struct{
+ char apn[LYNQ_APN_MAX_LEN];
+ char apnType[LYNQ_APN_TYPE_MAX_LEN];
+ char ifaceName[LYNQ_IFACE_NAME_MAX_LEN];
+ int hasUsed;
+ int hasTimeout;
+}lynq_apn_t;
+lynq_apn_t lynq_apn_table[LYNQ_APN_CHANNEL_MAX] = {};
+lynq_data_call_response_v11_t lynq_data_call_lists[LYNQ_APN_CHANNEL_MAX] = {};
+int lynq_data_call = 0;
+
+int getLynqApnID(char apnType[])
+{
+ int ret = 0;
+ for(ret;ret<LYNQ_APN_CHANNEL_MAX;ret++)
+ {
+ if(strcmp(lynq_apn_table[ret].apnType,apnType)==0)
+ {
+ return ret;
+ }
+ }
+ return -1;
+}
+void updateApnTable(lynq_apn_t *apn_table,char apn[],char apntype[],char ifaceName[])
+{
+ if(apn_table==NULL)
+ {
+ LYERRLOG("apn_table is null");
+ return;
+ }
+ memcpy(apn_table->apn,apn,strlen(apn)+1);
+ memcpy(apn_table->apnType,apntype,strlen(apntype)+1);
+ memcpy(apn_table->ifaceName,ifaceName,strlen(ifaceName)+1);
+ apn_table->hasTimeout = 0;
+ apn_table->hasUsed = 1;
+ return;
+}
+void cleanOnceApnTable(int apnId)
+{
+ if((apnId < 0) || (apnId > LYNQ_APN_CHANNEL_MAX-1))
+ {
+ LYERRLOG("apn id is invalid!!!");
+ return;
+ }
+ lynq_apn_table[apnId].hasTimeout = 0;
+ lynq_apn_table[apnId].hasUsed = 0;
+ bzero(lynq_apn_table[apnId].apn,LYNQ_APN_MAX_LEN);
+ bzero(lynq_apn_table[apnId].apnType,LYNQ_APN_TYPE_MAX_LEN);
+ bzero(lynq_apn_table[apnId].ifaceName,LYNQ_IFACE_NAME_MAX_LEN);
+ return;
+}
+int getUnusedElement()
+{
+ for(int i=0;i < LYNQ_APN_CHANNEL_MAX; i++)
+ {
+ if(lynq_apn_table[i].hasUsed!=1)
+ {
+ return i;
+ }
+ }
+ return -1;
+}
+int updateApn(char apnType[])
+{
+ int ret = 0;
+ ret = getUnusedElement();
+ memcpy(lynq_apn_table[ret].apnType,apnType,strlen(apnType)+1);
+ lynq_apn_table[ret].hasUsed = 1;
+ return ret;
+}
+
+int waitPdnChange()
+{
+ int ret = 0;
+ pthread_mutex_lock(&s_pdn_change_mutex);
+ ret = pthread_cond_wait(&s_pdn_change_cond,&s_pdn_change_mutex);
+ pthread_mutex_unlock(&s_pdn_change_mutex);
+ return ret;
+}
+int waitDataCallstateChange(int mtime)
+{
+ int ret = 0;
+ int sec = 0;
+ int usec = 0;
+ struct timeval now;
+ struct timespec timeout;
+ gettimeofday(&now,NULL);
+ sec = mtime/1000;
+ usec = mtime%1000;
+ timeout.tv_sec = now.tv_sec+sec;
+ timeout.tv_nsec = now.tv_usec*1000+usec*1000000;
+ pthread_mutex_lock(&s_data_call_state_change_mutex);
+ ret = pthread_cond_timedwait(&s_data_call_state_change_cond,&s_data_call_state_change_mutex,&timeout);
+ pthread_mutex_unlock(&s_data_call_state_change_mutex);
+ return ret;
+}
+void sendSignalDataCallStateChange()
+{
+ pthread_mutex_lock(&s_data_call_state_change_mutex);
+ pthread_cond_signal(&s_data_call_state_change_cond);
+ pthread_mutex_unlock(&s_data_call_state_change_mutex);
+ return;
+}
+void sendSignalPdnChange()
+{
+ pthread_mutex_lock(&s_pdn_change_mutex);
+ pthread_cond_signal(&s_pdn_change_cond);
+ pthread_mutex_unlock(&s_pdn_change_mutex);
+ return;
+}
+
+int get_response(int sockfd,Parcel &p)
+{
+ int len = 0;
+ char recvline[LYNQ_REC_BUF];
+ bzero(recvline,LYNQ_REC_BUF);
+ /* receive data from server */
+ len = read(sockfd, recvline, LYNQ_REC_BUF);
+ if(len == -1)
+ {
+ perror("read error");
+ return -1;
+ }
+ printf("===>n=%d\n",len);
+ if (recvline != NULL) {
+ p.setData((uint8_t *)recvline,len); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ }
+ return 0;
+}
+int JumpHeader(Parcel &p,int *resp_type,int *request,int *slot_id,int *error)
+{
+ if(p.dataAvail() > 0)
+ {
+ p.readInt32(resp_type);
+ p.readInt32(request);
+ p.readInt32(slot_id);
+ p.readInt32(error);
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+int send_request(int sockfd,lynq_client_t *client_tmp)
+{
+ int ret=0;
+ ret = write(sockfd, client_tmp, LYQN_SEDN_BUF);
+ if(ret==-1)
+ {
+ perror("write error");
+ return -1;
+ }
+ return 0;
+}
+static char *strdupReadString(Parcel &p) {
+ size_t stringlen;
+ const char16_t *s16;
+ s16 = p.readString16Inplace(&stringlen);
+ return strndup16to8(s16, stringlen);
+}
+static char *strdupReadString_p(Parcel *p) {
+ size_t stringlen;
+ const char16_t *s16;
+ s16 = p->readString16Inplace(&stringlen);
+ return strndup16to8(s16, stringlen);
+}
+
+
+/*Warren add for T800 platform 2021/11/19 start*/
+int lynq_socket_client_start()
+{
+ struct sockaddr_in lynq_socket_server_addr;
+ /* init lynq_socket_server_addr */
+ bzero(&lynq_socket_server_addr, sizeof(lynq_socket_server_addr));
+ lynq_socket_server_addr.sin_family = AF_INET;
+ lynq_socket_server_addr.sin_port = htons(LYNQ_SERVICE_PORT);
+ lynq_socket_server_addr.sin_addr.s_addr = htons(INADDR_ANY);
+ /*
+ if(inet_pton(AF_INET,"127.0.0.1", &lynq_socket_server_addr.sin_addr) <= 0)
+ {
+ printf("[%s] is not a valid IPaddress\n", argv[1]);
+ exit(1);
+ }
+*/
+ lynq_client_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+ if(connect(lynq_client_sockfd, (struct sockaddr *)&lynq_socket_server_addr, sizeof(lynq_socket_server_addr)) == -1)
+ {
+ perror("connect error");
+ return -1;
+ }
+ return 0;
+}
+void *thread_urc_recv(void *parg)
+{
+ int socket_fd = (int64_t)parg;
+ int len=0;
+ socklen_t addr_len=0;
+ uint8_t *dataLength = NULL;
+ char urc_data[LYNQ_REC_BUF];
+ char apn[LYNQ_APN_MAX_LEN];
+ char apnType[LYNQ_APN_TYPE_MAX_LEN];
+ int pdnState = 0;
+ char ifaceName[LYNQ_IFACE_NAME_MAX_LEN];
+ int slot_id = -1;
+ int resp_type = -1;
+ int urcid = -1;
+ char *urc_msg = NULL;
+ Parcel *p = NULL;
+ struct sockaddr_in dest_addr;
+ LYINFLOG("thread_urc_recv in running....\n");
+ while(urc_recive_status)
+ {
+ bzero(urc_data,LYNQ_REC_BUF);
+ //get data msg
+ len = recvfrom(socket_fd,urc_data,LYNQ_REC_BUF,0,(struct sockaddr *)&dest_addr,&addr_len);
+ if(len <= 0)
+ {
+ perror("thread_urc_recv step2 fail:");
+ break;
+ }
+ LYDBGLOG("=====>urc data len<=====:%d\n",len);
+ p = new Parcel();
+ if(p==NULL)
+ {
+ RLOGD("new parcel failure!!!");
+ break;
+ }
+ p->setData((uint8_t *)urc_data,len); // p.setData((uint8_t *) buffer, buflen);
+ p->setDataPosition(0);
+ if(p->dataAvail() > 0)
+ {
+ p->readInt32(&resp_type);
+ p->readInt32(&urcid);
+ p->readInt32(&slot_id);
+ //LYDBGLOG("*******Warren test*******:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
+ switch (urcid)
+ {
+ case 9003://LYNQ_URC_DATA_CALL_STATUS_IND
+ {
+ LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
+ p->readInt32(&pdnState);
+ bzero(apn,LYNQ_APN_MAX_LEN);
+ bzero(apnType,LYNQ_APN_TYPE_MAX_LEN);
+ bzero(ifaceName,LYNQ_IFACE_NAME_MAX_LEN);
+ if(pdnState!=4)//PDN_DISCONNECTED
+ {
+ urc_msg = strdupReadString_p(p);
+ int len = strlen(urc_msg);
+ if(len < LYNQ_APN_MAX_LEN-1)
+ {
+ memcpy(apn,urc_msg,len+1);
+ }
+ urc_msg = strdupReadString_p(p);
+ len = strlen(urc_msg);
+ if(len < LYNQ_APN_TYPE_MAX_LEN-1)
+ {
+ memcpy(apnType,urc_msg,len+1);
+ }
+ urc_msg = strdupReadString_p(p);
+ len = strlen(urc_msg);
+ if(len < LYNQ_IFACE_NAME_MAX_LEN-1)
+ {
+ memcpy(ifaceName,urc_msg,strlen(urc_msg)+1);
+ }
+ //sendSignalDataCallStateChange();
+ }
+ int apnId = getLynqApnID(apnType);
+ if(lynq_apn_table[apnId].hasTimeout==1)
+ {
+ LYERRLOG("apn:%s has time out",lynq_apn_table[apnId].apn);
+ lynq_deactive_data_call(&apnId);
+ continue;
+ }
+ updateApnTable(&lynq_apn_table[apnId], apn,apnType,ifaceName);
+ sendSignalPdnChange();
+ lynq_data_call_change_id = apnId;
+ if(lynq_data_call==1)
+ {
+ sendSignalDataCallStateChange();
+ lynq_data_call = 0;
+ }
+ /*
+ if(dataCb!=NULL)
+ {
+ (*dataCb)(apn,apnType,pdnState,ifaceName);
+ }
+ */
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ delete p;
+ p = NULL;
+ }
+ close(socket_fd);
+}
+int lynq_socket_urc_start()
+{
+ int socket_fd=0;
+ int rt=0;
+ int len=0;
+ int on=1;
+ struct sockaddr_in urc_local_addr;
+ pthread_t tid;
+ pthread_attr_t attr;
+ socket_fd = socket(AF_INET,SOCK_DGRAM,0);
+ printf("test 001\n");
+ if(socket_fd < 0)
+ {
+ perror("creaet socket for udp fail");
+ return -1;
+ }
+ urc_local_addr.sin_family = AF_INET;
+ urc_local_addr.sin_port = htons(LYNQ_URC_SERVICE_PORT);
+ urc_local_addr.sin_addr.s_addr = htons(INADDR_ANY);
+ /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
+ rt = setsockopt(socket_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
+ if(rt<0)
+ {
+ perror("SO_REUSEADDR fail\n");
+ return -1;
+ }
+ rt = bind(socket_fd ,(struct sockaddr*)&urc_local_addr, sizeof(urc_local_addr));
+ if (rt == -1)
+ {
+ perror("bind failed");
+ return -1;
+ }
+ pthread_attr_init(&attr);
+ pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ rt = pthread_create(&tid,&attr,thread_urc_recv,(void *)socket_fd);
+ if(rt < 0)
+ {
+ printf("urc loop failure!!!\n");
+ return -1;
+ }
+ printf("urc loop success!!!\n");
+ return 0;
+}
+void lynq_call_state_change_test(int soc_id)
+{
+ printf("call state change,sim:%d\n",soc_id);
+}
+void lynq_data_call_state_cb_test(char apn[LYNQ_APN_MAX_LEN],char apnType[LYNQ_APN_TYPE_MAX_LEN],int pdnState,char ifaceName[LYNQ_IFACE_NAME_MAX_LEN])
+{
+ printf("data state change,apn=%s,apntype=%s,pdnstate=%d,ifacename=%s:%d\n",apn,apnType,pdnState,ifaceName);
+}
+
+int lynq_init_data(int uToken)
+{
+ int result = 0;
+ Global_uToken = uToken;
+ LYLOGSET(LOG_INFO);
+ LYLOGEINIT(USER_LOG_TAG);
+ result = lynq_socket_client_start();
+ if(result!=0)
+ {
+ LYERRLOG("init socket client fail!!!");
+ return -1;
+ }
+ result = lynq_socket_urc_start();
+ if(result!=0)
+ {
+ LYERRLOG("init socket urc fail!!!");
+ return -1;
+ }
+ memset(lynq_apn_table,0,sizeof(lynq_apn_table));
+ LYDBGLOG("lynq init call success!!!");
+ return 0;
+
+}
+int lynq_deinit_data()
+{
+ close(lynq_client_sockfd);
+ for(int i =0;i<LYNQ_APN_CHANNEL_MAX;i++)
+ {
+ if(lynq_apn_table[i].apnType!=NULL)
+ {
+ lynq_deactive_data_call(&i);
+ }
+ }
+ urc_recive_status = 0;
+ return 0;
+}
+int lynq_setup_data_call(int *handle)
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ char iface = NULL;
+ int lynq_data_call_id = 0;
+ if(handle==NULL)
+ {
+ LYERRLOG("handle is null!!!");
+ return LYNQ_E_NULL_ANONALY;
+ }
+ client.uToken = Global_uToken;
+ client.request = 27;//RIL_REQUEST_SETUP_DATA_CALL
+ client.paramLen = 0;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ LYERRLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_DATA] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ lynq_data_call_id = updateApn("default");
+ lynq_data_call = 1;
+ if(error==0)
+ {
+ if(waitDataCallstateChange(1000)==ETIMEDOUT)//1000ms
+ {
+ error = LYNQ_E_TIME_OUT;
+ LYERRLOG("timeout:wait data Call state fail!!!");
+ lynq_apn_table[lynq_data_call_id].hasTimeout = 1;
+ return error;
+ }
+ *handle = lynq_data_call_id;
+ }
+ return error;
+}
+int lynq_deactive_data_call(int *handle)
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ int lynq_data_call_id = -1;
+ lynq_data_call_id = *handle;
+ if(handle==NULL)
+ {
+ LYERRLOG("handle is null!!!");
+ return -1;
+ }
+ client.uToken = Global_uToken;
+ client.request = 41;//RIL_REQUEST_DEACTIVATE_DATA_CALL
+ if(strcmp(lynq_apn_table[lynq_data_call_id].apnType,"default")==0)
+ {
+ client.paramLen = 0;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ }
+ else
+ {
+ client.paramLen = 1;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ sprintf(client.param,"%s",lynq_apn_table[lynq_data_call_id].apnType);
+ }
+ LYERRLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_DATA] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ cleanOnceApnTable(lynq_data_call_id);
+ return error;
+}
+int lynq_setup_data_call_sp(int *handle,char *apn,char *apnType,char *user,char *password,char *authType,char *normalProtocol,char *roamingProtocol)
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ char iface = NULL;
+ int lynq_data_call_id = -1;
+ char *argv[10] = {};
+ if(handle==NULL||apn==NULL||apnType==NULL)
+ {
+ LYERRLOG("handle ,apn or apntype is null!!!");
+ return -1;
+ }
+ if(user==NULL)
+ {
+ argv[1] = "null";
+ }
+ else
+ {
+ argv[1] = user;
+ }
+ if(password==NULL)
+ {
+ argv[2] = "null";
+ }
+ else
+ {
+ argv[2] = password;
+ }
+ if(authType==NULL)
+ {
+ argv[3] = "null";
+ }
+ else
+ {
+ argv[3] = authType;
+ }
+ if(normalProtocol==NULL)
+ {
+ argv[4] = "null";
+ }
+ else
+ {
+ argv[4] = normalProtocol;
+ }
+ if(roamingProtocol==NULL)
+ {
+ argv[5] = "null";
+ }
+ else
+ {
+ argv[5] = roamingProtocol;
+ }
+ client.uToken = Global_uToken;
+ client.request = 27;//RIL_REQUEST_SETUP_DATA_CALL
+ client.paramLen = 7;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ sprintf(client.param,"%s %s %s %s %s %s %s",apn,apnType,argv[1],argv[2],argv[3],argv[4],argv[5]);
+ LYERRLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_DATA] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ lynq_data_call_id = updateApn(apnType);
+ if(error==0)
+ {
+ if(waitDataCallstateChange(1000)==ETIMEDOUT)//1000ms
+ {
+ error = LYNQ_E_TIME_OUT;
+ LYERRLOG("timeout:wait data Call state fail!!!");
+ lynq_apn_table[lynq_data_call_id].hasTimeout = 1;
+ return error;
+ }
+ *handle = lynq_data_call_id;
+ }
+ return error;
+}
+/*
+int lynq_deactive_data_call_sp(int *handle,char *apnType)
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ if(handle==NULL||apnType==NULL)
+ {
+ LYERRLOG("handle is null!!!");
+ return -1;
+ }
+ client.uToken = Global_uToken;
+ client.request = 41;//RIL_REQUEST_DEACTIVATE_DATA_CALL
+ client.paramLen = 1;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ sprintf(client.param,"%s",apnType);
+ LYERRLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_DATA] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ return error;
+}
+*/
+int getDataCallLists(lynq_data_call_response_v11_t dataCallList[LYNQ_APN_CHANNEL_MAX],int *realNum)
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ int version =0;
+ int num = 0;
+ int temp_int =0;
+ char *temp_char = NULL;
+ if(dataCallList==NULL)
+ {
+ LYERRLOG("dataCallList is null!!!");
+ return -1;
+ }
+ client.uToken = Global_uToken;
+ client.request = 57;//RIL_REQUEST_DATA_CALL_LIST
+ client.paramLen = 0;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ LYERRLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_DATA] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ p.readInt32(&version);
+ if(version==11)
+ {
+ p.readInt32(&num);
+ *realNum = num;
+ for (int i = 0; i < num; i++)
+ {
+ p.readInt32(&dataCallList[i].status);
+ p.readInt32(&dataCallList[i].suggestedRetryTime);
+ p.readInt32(&dataCallList[i].cid);
+ p.readInt32(&dataCallList[i].active);
+ temp_char = strdupReadString(p);
+ memcpy(dataCallList[i].type,temp_char,strlen(temp_char)+1);
+ temp_char = strdupReadString(p);
+ memcpy(dataCallList[i].ifname,temp_char,strlen(temp_char)+1);
+ temp_char = strdupReadString(p);
+ memcpy(dataCallList[i].addresses,temp_char,strlen(temp_char)+1);
+ temp_char = strdupReadString(p);
+ memcpy(dataCallList[i].dnses,temp_char,strlen(temp_char)+1);
+ temp_char = strdupReadString(p);
+ memcpy(dataCallList[i].gateways,temp_char,strlen(temp_char)+1);
+ temp_char = strdupReadString(p);
+ memcpy(dataCallList[i].pcscf,temp_char,strlen(temp_char)+1);
+ p.readInt32(&dataCallList[i].mtu);
+ }
+ }
+ return error;
+}
+int lynq_get_data_call_list(int *handle,lynq_data_call_response_v11_t dataCallList)
+{
+ lynq_data_call_response_v11_t interDataCallList[LYNQ_APN_CHANNEL_MAX]={};
+ int number = 0;
+ int lynq_data_call_id = 0;
+ int error = 0;
+ lynq_data_call_id = *handle;
+ if(handle==NULL)
+ {
+ LYERRLOG("handle is NULL");
+ return LYNQ_E_NULL_ANONALY;
+ }
+ memset(interDataCallList,0,sizeof(interDataCallList));
+ error = getDataCallLists(interDataCallList,&number);
+ if(error == 0)
+ {
+ for(int i = 0;i < number;i++)
+ {
+ if(strcmp(interDataCallList[i].ifname,lynq_apn_table[lynq_data_call_id].ifaceName)==0)
+ {
+ dataCallList.active = interDataCallList[i].active;
+ dataCallList.suggestedRetryTime = interDataCallList[i].suggestedRetryTime;
+ dataCallList.cid = interDataCallList[i].cid;
+ dataCallList.status = interDataCallList[i].status;
+ dataCallList.mtu = interDataCallList[i].mtu;
+ memcpy(dataCallList.addresses,interDataCallList[i].addresses,sizeof(interDataCallList[i].addresses));
+ memcpy(dataCallList.ifname,interDataCallList[i].ifname,sizeof(interDataCallList[i].ifname));
+ memcpy(dataCallList.dnses,interDataCallList[i].dnses,sizeof(interDataCallList[i].dnses));
+ memcpy(dataCallList.type,interDataCallList[i].type,sizeof(interDataCallList[i].type));
+ memcpy(dataCallList.gateways,interDataCallList[i].gateways,sizeof(interDataCallList[i].gateways));
+ memcpy(dataCallList.pcscf,interDataCallList[i].pcscf,sizeof(interDataCallList[i].pcscf));
+ }
+ }
+ }
+ return error;
+}
+int lynq_wait_data_call_state_change(int *handle)
+{
+ waitPdnChange();
+ *handle = lynq_data_call_change_id;
+ LYINFLOG("lynq data call id:%d",lynq_data_call_change_id);
+ return 0;
+}
+#if 0
+int main(int argc,char **argv)
+{
+ int n = 0;
+ n = lynq_init_call(lynq_call_state_change_test,2222);
+ if(n<0)
+ {
+ printf("lynq init call fail!!!\n");
+ return -1;
+ }
+ printf("lynq call init success!!!\n");
+ char phoneNum[LYNQ_PHONE_NUMBER_MAX];
+ sprintf(phoneNum,"18180053406 0",strlen("18180053406 0")+1);
+ lynq_call(phoneNum);
+ while(1)
+ {
+ sleep(1);
+ }
+ return 0;
+}
+#endif
+/*Warren add for T800 platform 2021/11/19 end*/
diff --git a/src/lynq/lib/liblynq-data/makefile b/src/lynq/lib/liblynq-data/makefile
new file mode 100755
index 0000000..0a02ec8
--- /dev/null
+++ b/src/lynq/lib/liblynq-data/makefile
@@ -0,0 +1,70 @@
+SHELL = /bin/sh
+RM = rm -f
+
+LOCAL_CFLAGS := -Wall \
+ -std=gnu++14 \
+ -g -Os \
+ -flto \
+ -DRIL_SHLIB \
+ -DATCI_PARSE \
+ -fPIC \
+ -DKEEP_ALIVE \
+ -DECALL_SUPPORT \
+ -fpermissive \
+
+
+
+$(warning ################# lynq data demo ROOT: $(ROOT),includedir:$(includedir))
+LOCAL_PATH = .
+
+LOCAL_C_INCLUDES = \
+ -I. \
+ -I$(LOCAL_PATH)/include/libdata \
+ -I$(ROOT)$(includedir)/logger \
+ -I$(ROOT)$(includedir)/liblog \
+
+
+LOCAL_LIBS := \
+ -L. \
+ -ldl \
+ -lstdc++ \
+ -llog \
+ -lcutils \
+ -lutils \
+ -lbinder \
+ -lpthread \
+ -llynq-log \
+
+
+SOURCES = $(wildcard *.cpp)
+
+EXECUTABLE = liblynq-data.so
+
+OBJECTS=$(SOURCES:.cpp=.o)
+
+
+.PHONY: build clean install pack_rootfs
+all: build
+$(EXECUTABLE): $(OBJECTS)
+ $(CXX) -shared -Wl,--no-undefined $(OBJECTS) $(LOCAL_LIBS) $(LOCAL_CFLAGS) $(LOCAL_C_INCLUDES) -o $@
+
+%.o : %.cpp
+ $(CXX) $(LOCAL_C_INCLUDES) $(LOCAL_CFLAGS) $(LOCAL_LIBS) -o $@ -c $<
+
+build: $(EXECUTABLE)
+ $(warning ########## build $(EXECUTABLE) ##########)
+install:
+ mkdir -p $(ROOT)$(base_libdir)/
+ install $(EXECUTABLE) $(ROOT)$(base_libdir)/
+ mkdir -p $(ROOT)$(includedir)/$(NAME)/sdk
+pack_rootfs:
+ 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)
+ -find . -name "*.o" -delete
diff --git a/src/lynq/lib/liblynq-sim/LICENSE b/src/lynq/lib/liblynq-sim/LICENSE
new file mode 100755
index 0000000..77f59ed
--- /dev/null
+++ b/src/lynq/lib/liblynq-sim/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-sim/Makefile b/src/lynq/lib/liblynq-sim/Makefile
new file mode 100755
index 0000000..d01b9ca
--- /dev/null
+++ b/src/lynq/lib/liblynq-sim/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/ \
+ -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 wildcard *.h src/*.cpp)
+
+EXECUTABLE = liblynq-sim.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)
+
+
diff --git a/src/lynq/lib/liblynq-sim/include/lynq_sim.h b/src/lynq/lib/liblynq-sim/include/lynq_sim.h
new file mode 100755
index 0000000..9b9593f
--- /dev/null
+++ b/src/lynq/lib/liblynq-sim/include/lynq_sim.h
@@ -0,0 +1,89 @@
+/*=============================================================================
+# FileName: lynq_sim.cpp
+# Desc: about SIMAPI
+# Author: mobiletek
+# Version: V1.0
+# LastChange: 2020-07-29
+# History:
+# If you need to use any API under lynq_sim, you must first call the init_sim() function to initialize these functions.
+=============================================================================*/
+#ifndef __LYNQ_SIM__
+#define __LYNQ_SIM__
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#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>
+#define MAX_BUF 20
+#define MAX_NUM 80
+#ifdef __cplusplus
+
+#define RIL_REQUEST_GET_SIM_STATUS 1
+#define RIL_REQUEST_GET_IMSI 11
+#define RIL_REQUEST_QUERY_ICCID 2026
+#define RIL_REQUEST_SET_FACILITY_LOCK 43
+#define RIL_REQUEST_QUERY_FACILITY_LOCK 42
+#define RIL_REQUEST_ENTER_SIM_PIN 2
+#define RIL_REQUEST_ENTER_SIM_PUK 3
+#define RIL_REQUEST_CHANGE_SIM_PIN 6
+#define RIL_REQUEST_OEM_HOOK_RAW 59
+
+
+extern "C" {
+#endif
+
+
+#define MAX_LEN 1024*8
+
+typedef struct{
+ int uToken;
+ int request;
+ int paramLen;
+ char param[MAX_LEN];
+}lynq_client_t;
+
+typedef struct
+{
+ char *MCCMCN;
+ char *buf;
+ char *MCN;
+}FindOperator;
+
+
+
+
+
+
+int lynq_get_sim_status(int *card_status);
+int lynq_get_imsi(char buf[]);
+
+/*add by lei*/
+int lynq_sim_init(int utoken);
+int lynq_sim_deinit(void);
+int lynq_enable_pin(char *pin);
+int lynq_disable_pin(char *pin);
+int lynq_query_operator(char buf[]);
+int lynq_get_iccid(char buf[]);
+int lynq_query_pin_lock(char *pin,int buf[]);
+int lynq_verify_pin(char *pin);
+int lynq_change_pin(char *old_pin, char *new_pin);
+int lynq_unlock_pin(char *puk, char *pin);
+int lynq_query_phone_number(char buf[]);
+/*add by lei*/
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/src/lynq/lib/liblynq-sim/include/operator.h b/src/lynq/lib/liblynq-sim/include/operator.h
new file mode 100755
index 0000000..8001868
--- /dev/null
+++ b/src/lynq/lib/liblynq-sim/include/operator.h
@@ -0,0 +1,32 @@
+
+/*=============================================================================
+** FileName: command.h
+** Desc: about operator
+** Author: lei
+** Version: V1.0
+** LastChange: 2021-02-26
+** History:
+=============================================================================*/
+
+{"45400", "CSL", "HK" },
+{"45401", "NEW WORLD", "HK" },
+{"45402", "CSL", "HK" },
+{"45404", "Orange", "HK" },
+{"45406", "SMC", "HK" },
+{"45410", "NEW WORLD", "HK" },
+{"45412", "PEOPLES", "HK" },
+{"45416", "SUNDAY", "HK" },
+{"45418", "HK TELECOM", "HK" },
+{"46000", "CHINA MOBILE", "CN" },
+{"46001", "CHN-CUGSM", "CN" },
+{"46002", "CHINA MOBILE", "CN" },
+{"46003", "CHINA TELECOM", "CN" },
+{"46601", "Far EasTone", "TW" },
+{"46606", "TUNTEX", "TW" },
+{"46668", "ACeS", "TW" },
+{"46688", "KGT", "TW" },
+{"46692", "Chunghwa", "TW" },
+{"46693", "MobiTai", "TW" },
+{"46697", "TWN GSM", "TW" },
+{"46699", "TransAsia", "TW" },
+{(char *)NULL, (char *)NULL, (char *)NULL},
\ No newline at end of file
diff --git a/src/lynq/lib/liblynq-sim/src/lynq_sim.cpp b/src/lynq/lib/liblynq-sim/src/lynq_sim.cpp
new file mode 100755
index 0000000..1a1f38e
--- /dev/null
+++ b/src/lynq/lib/liblynq-sim/src/lynq_sim.cpp
@@ -0,0 +1,602 @@
+/*=============================================================================
+# FileName: lynq_sim.cpp
+# Desc: about SIM API
+# Author: mobiletek
+# Version: V1.0
+# LastChange: 2021-12-29
+# History:
+=============================================================================*/
+#include <dlfcn.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include "lynq_sim.h"
+
+#include <errno.h>
+
+
+#define MAX_NUM 10
+#define USER_LOG_TAG "LYNQ_SIM"
+
+using ::android::Parcel;
+#define DEST_PORT 8088
+#define DSET_IP_ADDRESS "127.0.0.1"
+lynq_client_t client_t;
+/* socket文件描述符 */
+int len_addr_serv;
+struct sockaddr_in addr_serv;
+static int sock_fd = 0;
+int Global_uToken = 0;
+int resp_type = -1;
+int request = -1;
+int slot_id = -1;
+int error1 = -1;
+
+FindOperator findOperator[] = {
+#include "include/operator.h"
+};
+
+static FindOperator*find_ope_command (char *name,FindOperator *Class){
+ if(name == NULL || Class == NULL){
+ return ((FindOperator *)NULL);
+ }
+ register int i;
+ for (i = 0; Class[i].MCCMCN; i++)
+ if (strncmp (name, Class[i].MCCMCN, 5) == 0)
+ return (&Class[i]);
+ return ((FindOperator *)NULL);
+}
+
+int lynq_sim_init(int utoken){
+ if(utoken < 0){
+ printf("init err.");
+ return -1;
+ }
+ // LYLOGSET(LOG_INFO);
+ // LYLOGEINIT(USER_LOG_TAG);
+ Global_uToken = utoken;
+ sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if (-1 == sock_fd)
+ {
+ printf("socket open err.");
+ return -1;
+ }
+ /* 设置address */
+ memset(&addr_serv, 0, sizeof(addr_serv));
+ addr_serv.sin_family = AF_INET;
+ addr_serv.sin_addr.s_addr = inet_addr(DSET_IP_ADDRESS);
+ addr_serv.sin_port = htons(DEST_PORT);
+ len_addr_serv = sizeof(addr_serv);
+ /*test*/
+ return 0;
+}
+
+int lynq_sim_deinit(void){
+ close(sock_fd);
+ return 0;
+}
+
+static char * lynqStrdupReadString(Parcel &p) {
+ size_t stringlen;
+ const char16_t *s16;
+ s16 = p.readString16Inplace(&stringlen);
+ return strndup16to8(s16, stringlen);
+}
+
+static void delete_char(char str[],char target){
+ int i,j;
+ for(i=j=0;str[i]!='\0';i++){
+ if(str[i]!=target){
+ str[j++]=str[i];
+ }
+ }
+ str[j]='\0';
+}
+
+/*If you need to use any API under lynq_sim, you mustfirst call the init_sim() function to initialize these functions.*/
+int lynq_get_sim_status(int *card_status)
+{
+ int ret = -1;
+ if(card_status == NULL)
+ return ret;
+ int send_num = 0;
+ int recv_num = 0;
+ int len = 0;
+ lynq_client_t client_t1;
+ memset(&client_t1, 0, sizeof(client_t1) );
+ client_t1.request = RIL_REQUEST_GET_SIM_STATUS;
+ client_t1.paramLen = 0;
+ client_t1.uToken = Global_uToken;
+ char res_data[MAX_LEN] = {0};
+ int len1 = sizeof(client_t1.param);
+ memset(client_t1.param, 0, sizeof(char)*MAX_LEN);
+ printf("client_t1 %d\n", sizeof(client_t1));
+ send_num = sendto(sock_fd, &client_t1, sizeof(client_t1), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
+ if(send_num < 0)
+ {
+ perror("sendto error:");
+ return ret;
+ }
+ //get data msg
+ recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN, 0, (struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
+ if(recv_num < 0 || recv_num == 0)
+ {
+ perror("recvfrom step2 fail:");
+ return ret;
+ }
+ printf("=====>resp data len<=====:%d,,,%d\n",recv_num,MAX_LEN);
+ Parcel p;;
+ p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ if(p.dataAvail() > 0)
+ {
+ p.readInt32(&resp_type);
+ p.readInt32(&request);
+ p.readInt32(&slot_id);
+ p.readInt32(&error1);
+ p.readInt32(card_status);
+ }
+ return error1;
+}
+/*AT> AT+CIMI AT< IMSI*/
+int lynq_get_imsi(char buf[])
+{
+ int ret = -1;
+ if(buf == NULL)
+ return ret;
+ int send_num = 0;
+ int recv_num = 0;
+ int len = 0;
+ lynq_client_t client_t1;
+ memset(&client_t1, 0, sizeof(client_t1) );
+ client_t1.request = RIL_REQUEST_GET_IMSI;
+ client_t1.paramLen = 0;
+ client_t1.uToken = Global_uToken;
+ char res_data[MAX_LEN] = {0};
+ memset(client_t1.param, 0, sizeof(client_t1.param));
+ send_num = sendto(sock_fd, &client_t1, sizeof(client_t1), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
+ if(send_num < 0)
+ {
+ perror("sendto error:");
+ return ret;
+ }
+ //get data msg
+ recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
+ if(recv_num < 0 || recv_num == 0)
+ {
+ perror("recvfrom step2 fail:");
+ return -1;
+ }
+ printf("=====>resp data len<=====:%d,,,%d\n",recv_num,MAX_LEN);
+ Parcel p;
+ p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ if(p.dataAvail() > 0)
+ {
+ p.readInt32(&resp_type);
+ p.readInt32(&request);
+ p.readInt32(&slot_id);
+ p.readInt32(&error1);
+ if(!error1){
+ char * test = lynqStrdupReadString(p);
+ memcpy(buf, test, strlen(test));
+ }
+ printf("---->test<----resp_type=%d,request=%d,slot_id=%d,error=%d\n",resp_type,request,slot_id,error1);
+ }
+ return error1;
+}
+
+
+/*add by lei*/
+
+int lynq_get_iccid(char buf[]){
+ int ret = -1;
+ if(buf == NULL)
+ return ret;
+ int send_num = 0;
+ int recv_num = 0;
+ int len = 0;
+ client_t.request = RIL_REQUEST_QUERY_ICCID;
+ client_t.paramLen = 0;
+ client_t.uToken = Global_uToken;
+ char res_data[MAX_LEN] = {0};
+ 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)
+ {
+ perror("sendto error:");
+ return ret;
+ }
+ //get data msg
+ recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
+ if(recv_num < 0 || recv_num == 0)
+ {
+ perror("recvfrom step2 fail:");
+ return -1;
+ }
+ printf("=====>resp data len<=====:%d,,,%d\n",recv_num,MAX_LEN);
+ Parcel p;
+ p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ if(p.dataAvail() > 0)
+ {
+ p.readInt32(&resp_type);
+ p.readInt32(&request);
+ p.readInt32(&slot_id);
+ p.readInt32(&error1);
+ if(!error1){
+ char * test = lynqStrdupReadString(p);
+ memcpy(buf, test, strlen(test));
+ }
+ printf("---->test<----resp_type=%d,request=%d,slot_id=%d,error=%d\n",resp_type,request,slot_id,error1);
+ }
+ return error1;
+}
+
+int lynq_enable_pin(char *pin){
+ int ret = -1;
+ if(pin == NULL)
+ return ret;
+ int send_num = 0;
+ int recv_num = 0;
+ char res_data[MAX_LEN] = {0};
+ client_t.request = RIL_REQUEST_SET_FACILITY_LOCK;
+ client_t.paramLen = 4;
+ client_t.uToken = Global_uToken;
+ sprintf(client_t.param, "%s %s %s %s\n", "SC", pin, "11", "1");
+ send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
+ if(send_num < 0)
+ {
+ perror("sendto error:");
+ return ret;
+ }
+
+ //get data msg
+ recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
+ if(recv_num < 0 || recv_num == 0)
+ {
+ perror("recvfrom step2 fail:");
+ return -1;
+ }
+ printf("=====>resp data len<=====:%d,,,%d\n",recv_num,MAX_LEN);
+ Parcel p;
+ p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ if(p.dataAvail() > 0)
+ {
+ p.readInt32(&resp_type);
+ p.readInt32(&request);
+ p.readInt32(&slot_id);
+ p.readInt32(&error1);
+ }
+ return error1;
+
+}
+
+int lynq_disable_pin(char *pin){
+ int ret = -1;
+ if(pin == NULL)
+ return ret;
+ int send_num = 0;
+ int recv_num = 0;
+ char res_data[MAX_LEN] = {0};
+ client_t.request = RIL_REQUEST_SET_FACILITY_LOCK;
+ client_t.paramLen = 4;
+ client_t.uToken = Global_uToken;
+ sprintf(client_t.param, "%s %s %s %s\n", "SC", pin, "11", "0");
+ send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
+ if(send_num < 0)
+ {
+ perror("sendto error:");
+ return ret;
+ }
+ //get data msg
+ recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
+ if(recv_num < 0 || recv_num == 0)
+ {
+ perror("recvfrom step2 fail:");
+ return -1;
+ }
+ printf("=====>resp data len<=====:%d,,,%d\n",recv_num,MAX_LEN);
+ Parcel p;
+ p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ if(p.dataAvail() > 0)
+ {
+ p.readInt32(&resp_type);
+ p.readInt32(&request);
+ p.readInt32(&slot_id);
+ p.readInt32(&error1);
+ }
+ return error1;
+}
+
+int lynq_query_pin_lock(char *pin,int buf[]){
+ int ret = -1;
+ if(pin == NULL)
+ return ret;
+ int send_num = 0;
+ int recv_num = 0;
+ int len = 0;
+ client_t.request = RIL_REQUEST_QUERY_FACILITY_LOCK;
+ client_t.paramLen = 3;
+ client_t.uToken = Global_uToken;
+ char res_data[MAX_LEN] = {0};
+ sprintf(client_t.param, "%s %s %s\n", "SC", pin, "11");
+ send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
+ if(send_num < 0)
+ {
+ perror("sendto error:");
+ return ret;
+ }
+ //get data msg
+ recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
+ if(recv_num < 0 || recv_num == 0)
+ {
+ perror("recvfrom step2 fail:");
+ return -1;
+ }
+ printf("=====>resp data len<=====:%d,,,%d\n",recv_num,MAX_LEN);
+ Parcel p;
+ p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ int num = -1;
+ if(p.dataAvail() > 0)
+ {
+ p.readInt32(&resp_type);
+ p.readInt32(&request);
+ p.readInt32(&slot_id);
+ p.readInt32(&error1);
+ p.readInt32(&num);
+ int *test = (int *)calloc(1, sizeof(int)*num);
+ for(int i =0; i <num; i++){
+ p.readInt32(&test[i]);
+ buf[i] = test[i];
+ }
+ free(test);
+ }
+ return error1;
+}
+
+int lynq_verify_pin(char *pin){
+ int ret = -1;
+ if(pin == NULL)
+ return ret;
+ int send_num = 0;
+ int recv_num = 0;
+ char res_data[MAX_LEN] = {0};
+ int len = 0;
+ client_t.request = RIL_REQUEST_ENTER_SIM_PIN;
+ client_t.paramLen = 1;
+ client_t.uToken = Global_uToken;
+ sprintf(client_t.param, "%s\n", pin);
+ send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
+ if(send_num < 0)
+ {
+ perror("sendto error:");
+ return ret;
+ }
+ //get data msg
+ recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
+ if(recv_num < 0 || recv_num == 0)
+ {
+ perror("recvfrom step2 fail:");
+ return -1;
+ }
+ printf("=====>resp data len<=====:%d,,,%d\n",recv_num,MAX_LEN);
+ Parcel p;
+ p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ if(p.dataAvail() > 0)
+ {
+ p.readInt32(&resp_type);
+ p.readInt32(&request);
+ p.readInt32(&slot_id);
+ p.readInt32(&error1);
+ }
+ return error1;
+}
+
+int lynq_change_pin(char *old_pin, char *new_pin){
+ int ret = -1;
+ if(old_pin == NULL || new_pin == NULL)
+ return ret;
+ int send_num = 0;
+ int recv_num = 0;
+ char res_data[MAX_LEN] = {0};
+ int len = 0;
+ client_t.request = RIL_REQUEST_CHANGE_SIM_PIN;
+ client_t.paramLen = 2;
+ client_t.uToken = Global_uToken;
+ sprintf(client_t.param, "%s %s\n", old_pin, new_pin);
+ send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
+ if(send_num < 0)
+ {
+ perror("sendto error:");
+ return ret;
+ }
+ //get data msg
+ recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
+ if(recv_num < 0 || recv_num == 0)
+ {
+ perror("recvfrom step2 fail:");
+ return -1;
+ }
+ printf("=====>resp data len<=====:%d,,,%d\n",recv_num,MAX_LEN);
+ Parcel p;
+ p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ if(p.dataAvail() > 0)
+ {
+ p.readInt32(&resp_type);
+ p.readInt32(&request);
+ p.readInt32(&slot_id);
+ p.readInt32(&error1);
+ }
+ return error1;
+}
+
+int lynq_unlock_pin(char *puk, char *pin){
+ int ret = -1;
+ if(puk == NULL || pin == NULL)
+ return ret;
+ int send_num = 0;
+ int recv_num = 0;
+ char res_data[MAX_LEN] = {0};
+ int len = 0;
+ client_t.request = RIL_REQUEST_ENTER_SIM_PUK;
+ client_t.paramLen = 2;
+ client_t.uToken = Global_uToken;
+ sprintf(client_t.param, "%s %s\n", puk, pin);
+ send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
+ if(send_num < 0)
+ {
+ perror("sendto error:");
+ return ret;
+ }
+ //get data msg
+ recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
+ if(recv_num < 0 || recv_num == 0)
+ {
+ perror("recvfrom step2 fail:");
+ return -1;
+ }
+ printf("=====>resp data len<=====:%d,,,%d\n",recv_num,MAX_LEN);
+ Parcel p;
+ p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ if(p.dataAvail() > 0)
+ {
+ p.readInt32(&resp_type);
+ p.readInt32(&request);
+ p.readInt32(&slot_id);
+ p.readInt32(&error1);
+ }
+ return error1;
+}
+
+static int parse_param(char *cmd, char **argv, char buf[]){
+ if(cmd == NULL || argv == NULL || buf == NULL){
+ printf("input error");
+ return 0;
+ }
+ if(strstr(cmd,"ERROR")){
+ //char *test = strchr(cmd, ':')+1;
+ int len = strlen(cmd);
+ memcpy(buf, cmd, len);
+ buf[len] = '\0';
+ return 3;
+ }
+ else{
+ int argc = 0;
+ char *token;
+ token = strtok(cmd, ",");
+ if(strstr(token, "CNUM")){
+ char *string;
+ while (token != NULL)
+ {
+ string = token;
+ argv[argc++] = string;
+ token = strtok(NULL, ",");
+ }
+ int lengh = strlen(argv[1]);
+ memcpy(buf, argv[1], lengh);
+ buf[lengh] = '\0';
+ delete_char(buf, '"');
+ }
+ else{
+ const char *warning = "9001";
+ int len = strlen(warning);
+ memcpy(buf, warning, len);
+ buf[len] = '\0';
+ }
+
+ }
+ return 0;
+}
+
+int lynq_query_phone_number(char buf[]){
+ int ret = -1;
+ if(buf == NULL)
+ return ret;
+ int send_num = 0;
+ int recv_num = 0;
+ int len = 0;
+ char res_data[MAX_LEN] = {0};
+ client_t.request = RIL_REQUEST_OEM_HOOK_RAW;
+ client_t.paramLen = 1;
+ client_t.uToken = Global_uToken;
+ sprintf(client_t.param, "%s\n", "AT+CNUM");
+ send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
+ if(send_num < 0)
+ {
+ perror("sendto error:");
+ return ret;
+ }
+ //get data msg
+ recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
+ if(recv_num < 0 || recv_num == 0)
+ {
+ perror("recvfrom step2 fail:");
+ return -1;
+ }
+ printf("=====>resp data len<=====:%d,,,%d\n",recv_num,MAX_LEN);
+ Parcel p;
+ p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ int num = -1;
+ if(p.dataAvail() > 0)
+ {
+ char test[30] = {0};
+ char *argv[5] = {0};
+ p.readInt32(&resp_type);
+ p.readInt32(&request);
+ p.readInt32(&slot_id);
+ p.readInt32(&error1);
+ p.readInt32(&num);
+ if(num == -1){
+ memcpy(buf, "-1", 2);
+ }else{
+ p.read(test, num);
+ parse_param(test, argv, buf);
+ }
+ }
+ return error1;
+}
+
+int lynq_query_operator(char buf[]){
+ int32_t token = -1;
+ if(buf == NULL)
+ return token;
+ char msg_imsi[20] = {0};
+ memset(msg_imsi,0,sizeof(msg_imsi));
+ token = lynq_get_imsi(msg_imsi);
+ if(strlen(msg_imsi) != 0){
+ FindOperator *ope_command = NULL;
+ ope_command = find_ope_command(msg_imsi, findOperator);
+ if(ope_command){
+ memcpy(buf, ope_command->buf, strlen(ope_command->buf));
+ buf[strlen(ope_command->buf)] = '\0';
+ }
+ else{
+ /*more*/
+ char mccmnc[5] = {0};
+ memcpy(buf, msg_imsi, 5);
+ buf[5] = '\0';
+ /*more*/
+ }
+ return token;
+ }
+ else{
+ //msg->base.e = err;
+ const char *test = "please insert sim card";
+ memcpy(buf, test, strlen(test));
+ return token;
+ }
+}
+
+
+
+
+