[feature]:
1.add new feature lynq-ril-service v1.0 and bb file
2.add new feature liblynq-call and bb file
3.add these features bb in lynq packagegroup file
Change-Id: I44e039688966fe59ce6ec2603257902238b1c186
diff --git a/lib/liblynq-call/lynq_call.cpp b/lib/liblynq-call/lynq_call.cpp
new file mode 100755
index 0000000..aa26125
--- /dev/null
+++ b/lib/liblynq-call/lynq_call.cpp
@@ -0,0 +1,898 @@
+#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"
+#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 timespec start_tm;
+ clock_gettime(CLOCK_MONOTONIC, &start_tm);
+ struct timespec outTime;
+ sec = mtime/1000;
+ usec = mtime%1000;
+ outTime.tv_sec = start_tm.tv_sec + sec;
+ outTime.tv_nsec = start_tm.tv_nsec + usec*1000000;
+ pthread_mutex_lock(&call_state_change_mutex);
+ ret = pthread_cond_timedwait(&call_state_change_cond,&call_state_change_mutex,&outTime);
+ 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;
+ 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*/