diff --git a/src/lynq/lib/liblynq-call/lynq_call.cpp b/src/lynq/lib/liblynq-call/lynq_call.cpp
index 0e46e6e..0270aa1 100755
--- a/src/lynq/lib/liblynq-call/lynq_call.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_call.cpp
@@ -18,23 +18,23 @@
 #include <vendor-ril/telephony/mtk_ril_sp.h>
 #include <vendor-ril/telephony/mtk_ril_ivt.h>
 #include "lynq_call.h"
+#include "lynq_module_common.h"
+#include "lynq_module_socket.h"
+#include "lynq_call_common.h"
 
-
-#define LYNQ_SERVICE_PORT 8088
-#define DSET_IP_ADDRESS  "127.0.0.1"
-#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 INVALID_ID (-1)
-#define RTP_FROM_CMD "gst-launch-1.0 -v udpsrc port=%d caps=\'application/x-rtp, media=(string)audio, clock-rate=(int)%d, channels=(int)%d\' ! rtpjitterbuffer latency=%d ! rtppcmadepay ! alawdec ! audioresample ! audioconvert ! alsasink device=\'hw:0,2\'"
-#define RTP_TO_CMD   "gst-launch-1.0 -v alsasrc device=\'hw:0,6\' ! audioconvert ! audioresample ! alawenc ! rtppcmapay ! udpsink host=%s %s auto-multicast=true port=%d"
-#define RTP_VLAN_INFO_FORMAT "multicast-iface=\"%s\""
-#define MAX_IP_LENGTH 128
-#define MAX_VLAN_INFO_LENGTH 128
+#define CALL_OFF (0)
+#define CALL_ON  (1)
 #define USER_LOG_TAG "LYNQ_CALL"
 
 using ::android::Parcel;
+
+/**
+ * @brief mark call initialization state
+ * 0: deinit state
+ * 1: init state
+ */
+int g_module_init_flag = 0;
+
  typedef enum {
      LYNQ_CALL_ACTIVE = 0,
      LYNQ_CALL_HOLDING = 1,
@@ -47,12 +47,6 @@
      /*warren add for T800 platform 2022/04/26 end*/
 }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;
@@ -71,175 +65,28 @@
     char addr[LYNQ_PHONE_NUMBER_MAX];
 }lynq_call_list_t;
 
-lynq_call_list_e_t lynq_call_lists[LYNQ_CALL_MAX]={};
+static lynq_call_list_e_t s_call_lists[LYNQ_CALL_MAX]={};
+static bool s_call_list_loop = 0;
+static pthread_t s_call_list_loop_tid = -1;
+static pthread_mutex_t s_notice_get_call_list_mutex  = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_notice_get_call_list_cond = PTHREAD_COND_INITIALIZER;
+
+static int s_module_isDial = 0;
 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 = NULL;
-static pthread_cond_t *s_urc_call_state_change_cond = NULL;
+static int s_IncomingCallId = 0;
 static pthread_mutex_t s_incoming_call_mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t s_incoming_call_cond = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t g_lynq_call_sendto_mutex;
-pthread_t lynq_call_urc_tid = -1;
-pthread_t lynq_call_list_loop_tid = -1;
 
-/*lei add*/
-/* socket文件描述符 */ 
-int len_addr_serv;
-struct sockaddr_in addr_serv;
-lynq_client_t client_t;
-int client_size = 0;
-/*lei add*/
+static int s_module_call_state =CALL_OFF;
+static int s_call_auto_answer = 0;
 
-int s_call_urc_event_complete = 0;
-
-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,
-     /*Invalid id anomaly*/
-    LYNQ_E_INVALID_ID_ANONALY=9002,
-#ifdef ECALL_SUPPORT
-    LYNQ_E_ECALL_BEING_RUNNING =9003,
-    LYNQ_E_ECALL_MSD_LENGTH_ERROR =9004,
-    LYNQ_E_ECALL_DAILING_NO_ANSWER =9005,
-#endif
-}LYNQ_E;
 typedef enum{
     LYNQ_E_VOLUMN_SET_DTMF,
     LYNQ_E_VOLUMN_SET_SPEECH
-}LYNQ_E_VOLUMN_SET;   
+}LYNQ_E_VOLUMN_SET;  
 
-int lynq_call_state =CALL_OFF;
-int lynq_call_client_sockfd = 0;
-int Global_uToken_call = 0;
-int global_call_count =0;
-int global_call_auto_answer = 0;
-bool urc_call_recive_status = 1;
-bool call_list_loop = 0;
-int isDial = 0;
-int lynqIncomingCallId = 0;
-
-/*rtp begin*/
-typedef struct
-{   
-    char ip[MAX_IP_LENGTH];
-    int port;   
-    char vlan_info[MAX_VLAN_INFO_LENGTH];
-}lynq_rtp_server_info;
-
-typedef struct
-{       
-    int port;
-    int clockrate;  
-    int latency;
-    int channels;
-}lynq_rtp_client_info;
-
-static lynq_rtp_client_info g_rtp_client_info;
-static lynq_rtp_server_info g_rtp_server_info;
-
-static pthread_t g_rtp_thread[RTP_MODE_MAX];
-static bool g_rtp_thread_valid[RTP_MODE_MAX];
-
-/*rtp end*/
-
-#ifdef ECALL_SUPPORT
-int lynq_set_common_request(int request_id, int argc, const char* format,...);
-int g_ecallId = INVALID_ID;
-typedef enum{        
-    LYNQ_ECALL_TYPE_TEST = 0,     /* Test eCall */
-    LYNQ_ECALL_TYPE_RECONFIG = 1,    /*    Reconfiguration eCall */    
-    LYNQ_ECALL_MANUAL_EMERGENCY = 2,   /*Manual Emergency eCall */
-    LYNQ_ECALL_TYPE_AUTO_EMERGENCY = 3,   /* Automatic Emergency eCall */
-}LYNQ_ECall_Type;
-
-typedef enum{   
-    LYNQ_ECALL_DAILING_STATE_NONE =0,
-    LYNQ_ECALL_DAILING_STATE_STARTED = 1,    
-    LYNQ_ECALL_DAILING_STATE_ANSWERED = 2,      
-}LYNQ_ECall_Dailing_State;
-
-LYNQ_ECall_Dailing_State is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
-char e_call_addr[LYNQ_ECALL_VAR_MAX][LYNQ_PHONE_NUMBER_MAX]={"test_ecall","emergency_ecall","reconf_ecall"};
-
-static pthread_mutex_t s_incoming_e_call_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t s_incoming_e_call_cond = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t s_ecall_variable_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-LYNQ_ECall_Indication g_lynqIncomingEcallIndication;
-int g_lynqIncomingEcallId=INVALID_ID;
-LYNQ_ECall_Variant g_lynqEcallVariant=LYNQ_ECALL_VAR_NONE;
-int g_ecall_whether_preempt=0;
-
-void sendSignalIncomingECallEvent()
-{
-    LYINFLOG("send incoming ecall event signal");
-    pthread_mutex_lock(&s_incoming_e_call_mutex);
-    pthread_cond_signal(&s_incoming_e_call_cond);
-    pthread_mutex_unlock(&s_incoming_e_call_mutex);
-}
-
-int lynq_is_msd_suc(LYNQ_ECall_Indication lynqIncomingEcallIndication)
-{
-    if(LYNQ_ECALL_LLACK_RECEIVED == lynqIncomingEcallIndication ||
-       LYNQ_ECALL_ALACK_POSITIVE_RECEIVED == lynqIncomingEcallIndication ||
-       LYNQ_ECALL_ALACK_CLEARDOWN_RECEIVED == lynqIncomingEcallIndication ||
-     //LYNQ_ECALL_T5_TIMER_OUT  == lynqIncomingEcallIndication ||
-       LYNQ_ECALL_T6_TIMER_OUT  == lynqIncomingEcallIndication ||
-       LYNQ_ECALL_T7_TIMER_OUT  == lynqIncomingEcallIndication)
-    {
-           return 1;
-    }
-
-    return 0;
-}
-
-int lynq_ecall_is_running()
-{
-    return (is_ecall_dial!=LYNQ_ECALL_DAILING_STATE_NONE) || (g_ecallId !=INVALID_ID || g_lynqEcallVariant == LYNQ_ECALL_CALLBACK);
-}
-
-void print_ecall_info()
-{
-     LYERRLOG("%s is ecall dial is %d, ecall id is %d, ecall vairant is %d, incoming ecall ind is %d, incoming ecall id is %d, whether preempt is %d",__func__,is_ecall_dial,g_ecallId,g_lynqEcallVariant,g_lynqIncomingEcallIndication,g_lynqIncomingEcallId,g_ecall_whether_preempt);
-}
-
-int lynq_ecall_is_permit_in_call(int ecall_id)
-{
-    return g_lynqEcallVariant == LYNQ_ECALL_CALLBACK && (g_ecallId ==INVALID_ID || g_ecallId ==ecall_id);
-}
-
-int lynq_ecall_is_in_voice()
-{
-    return (is_ecall_dial==LYNQ_ECALL_DAILING_STATE_NONE) && (g_ecallId !=INVALID_ID);
-}
-#endif
-
-/**
- * @brief mark call initialization state
- * 0: deinit state
- * 1: init state
- */
-int g_lynq_call_init_flag = 0;
-
+#if 0
 int JumpHeader(Parcel &p,int *resp_type,int* token,int *request,int *slot_id,int *error)
 {
     if(p.dataAvail() > 0)
@@ -286,15 +133,91 @@
     }
     return 0;
 }
-static char *strdupReadString(Parcel &p) {
+#endif
+static char *strdupReadString(Parcel* &p) {
     size_t stringlen;
     const char16_t *s16;
-    s16 = p.readString16Inplace(&stringlen);
+    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=NULL;    
+    int ret=lynq_send_common_request(p,8,RIL_REQUEST_GET_CURRENT_CALLS,0,"");
+    if(ret!=0)
+    {
+        return ret;    
+    }        
+
+    int call_num = 0;
+    int temp = 0;
+    char *remote_phoneNum;
+    char *remote_name;
+    char uusData[128];
+
+    p->readInt32(&call_num);
+
+    if(call_num<=0)
+    {
+        s_module_call_state = CALL_OFF;
+        LYINFLOG("lynq_call_state:%d",s_module_call_state);
+        delete p; 
+        return RESULT_OK;
+    }
+    s_module_call_state = CALL_ON;
+    LYINFLOG("lynq_call_state:%d, call num is %d ",s_module_call_state,call_num);
+    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));
+        if(remote_phoneNum !=NULL)
+        {
+            free(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);
+        if(remote_name !=NULL)
+        {
+            free(remote_name);
+        }
+        p->readInt32(&temp);
+        p->readInt32(&temp);
+        if(temp==0)
+        {
+            continue;
+        }
+        p->readInt32(&temp); /* UUS Information is present */
+        p->readInt32(&temp);
+        p->readInt32(&temp);
+        if(temp<=128)
+        {
+            p->read(uusData,temp);
+        }
+        else 
+        {
+            LYERRLOG("%s len %d is too great",__func__,temp);
+            delete p; 
+            return LYNQ_E_MALLOC_ERROR;
+        }
+    }
+
+    delete p; 
+    return RESULT_OK;   
+
+#if 0
     Parcel p;
     lynq_client_t client;
     int resp_type = -1;
@@ -360,40 +283,40 @@
             p.readInt32(&temp);
             p.readInt32(&temp);
             p.read(uusData,temp);
-            free(remote_phoneNum);
-            free(remote_name);
         }
     }
     return 0;
+#endif
 }
 
 void cleanCallList(int lynq_call_id)
 {
-    LYINFLOG("cleanCall local idx is %d, id is %d",lynq_call_id,lynq_call_lists[lynq_call_id].call_id);
-    lynq_call_lists[lynq_call_id].call_id = 0;
-    lynq_call_lists[lynq_call_id].call_state = (int)LYNQ_CALL_END;
-    lynq_call_lists[lynq_call_id].toa = 0;
-    lynq_call_lists[lynq_call_id].direction = 0;
-    lynq_call_lists[lynq_call_id].used = 0;
-    memset(lynq_call_lists[lynq_call_id].addr,0,sizeof(lynq_call_lists[lynq_call_id].addr));
+    LYINFLOG("cleanCall local idx is %d, id is %d",lynq_call_id,s_call_lists[lynq_call_id].call_id);
+    s_call_lists[lynq_call_id].call_id = 0;
+    s_call_lists[lynq_call_id].call_state = (int)LYNQ_CALL_END;
+    s_call_lists[lynq_call_id].toa = 0;
+    s_call_lists[lynq_call_id].direction = 0;
+    s_call_lists[lynq_call_id].used = 0;
+    memset(s_call_lists[lynq_call_id].addr,0,sizeof(s_call_lists[lynq_call_id].addr));
 }
 int getUnusedElement()
 {
     for(int i=0;i < LYNQ_CALL_MAX; i++)
     {
-        if(lynq_call_lists[i].used!=1)
+        if(s_call_lists[i].used!=1)
         {
             return i;
         }
     }
-    return -1;
+    return INVALID_ID;
 }
-int addAddr(char addr[])
+int addAddr(char addr[], int call_id)
 {
     int ret = 0;
     ret = getUnusedElement();
-    memcpy(lynq_call_lists[ret].addr,addr,strlen(addr)+1);
-    lynq_call_lists[ret].used = 1;
+    memcpy(s_call_lists[ret].addr,addr,strlen(addr)+1);
+    s_call_lists[ret].call_id=call_id;
+    s_call_lists[ret].used = 1;
     LYINFLOG("add local idx is %d addr is %s",ret,addr);
     return ret;
 }
@@ -406,24 +329,6 @@
     callList->direction = direction;   
     return;
 }
-int waitCallstateChange(int mtime)
-{
-    LYINFLOG("wait Call state Change");
-    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()
 {
     LYINFLOG("wait incming call");
@@ -437,35 +342,35 @@
 {
     for(int i = 0;i<LYNQ_CALL_MAX;i++)
     {
-        if(strcmp(lynq_call_lists[i].addr,addr)==0)
+        if(strcmp(s_call_lists[i].addr,addr)==0)
         {
-            LYINFLOG("checkHasCall addr is %s idx is %d id is %d",addr,i,lynq_call_lists[i].call_id);
-            return 1;
+            LYINFLOG("checkHasCall addr is %s idx is %d id is %d",addr,i,s_call_lists[i].call_id);
+            return true;
         }
     }
     LYINFLOG("checkHasCall addr is %s , no idx is found",addr);
-    return 0;
+    return false;
 }
 int find_call_id_with_addr(char *addr)
 {
     for(int id = 0; id < LYNQ_CALL_MAX; id++)
     {
-        if(lynq_call_lists[id].used && (strcmp(lynq_call_lists[id].addr,addr) == 0))
+        if(s_call_lists[id].used && (strcmp(s_call_lists[id].addr,addr) == 0))
         {
-            LYINFLOG("find addr  %s in local list, local idx is %d id is %d",addr,id,lynq_call_lists[id].call_id);
+            LYINFLOG("find addr  %s in local list, local idx is %d id is %d",addr,id,s_call_lists[id].call_id);
             return id;
         }
     }
     LYINFLOG("find addr  %s in local list , not found",addr);
-    return -1;
+    return INVALID_ID;
 }
 int find_call_id_with_call_id(int call_id)
 {
     for(int id = 0; id < LYNQ_CALL_MAX; id++)
     {
-        if(lynq_call_lists[id].used && (lynq_call_lists[id].call_id == call_id))
+        if(s_call_lists[id].used && (s_call_lists[id].call_id == call_id))
         {
-            LYINFLOG("find id  %d in local list, local idx is %d, addr is %s",call_id,id,lynq_call_lists[id].addr);
+            LYINFLOG("find id  %d in local list, local idx is %d, addr is %s",call_id,id,s_call_lists[id].addr);
             return id;
         }
     }
@@ -487,17 +392,10 @@
     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])
+void cleanup_call_list_mutex(void *arg)
 {
-    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;
-    return;
+    pthread_mutex_unlock(&s_notice_get_call_list_mutex);
 }
-
 void *triggerGetCallList(void *parg)
 {
     int ret=0;
@@ -509,18 +407,18 @@
 #ifdef ECALL_SUPPORT
     int handupIncomingMT=0;
 #endif
-    
-    while(call_list_loop)
+    pthread_mutex_lock(&s_notice_get_call_list_mutex);
+    pthread_cleanup_push(cleanup_call_list_mutex, NULL); // thread cleanup handler
+    while(s_call_list_loop)
     {
-        update=0;
-        pthread_mutex_lock(s_urc_call_state_change_mutex);
-        pthread_cond_wait(s_urc_call_state_change_cond, s_urc_call_state_change_mutex);
+        update=0;       
+        pthread_cond_wait(&s_notice_get_call_list_cond, &s_notice_get_call_list_mutex);
         LYDBGLOG("triggerGetCallList event!!!");
         memset(call_list,0,sizeof(call_list));
         ret = lynq_get_current_call_list(call_list);
-        if(ret != 0)
+        if(ret != RESULT_OK)
         {
-            LYDBGLOG("get current call list failure!!!");
+            LYDBGLOG("get current call list failure!!!");          
             continue;
         }
         LYINFLOG("++++++++++++++triggerGetCallList++++++++++++++");
@@ -528,28 +426,28 @@
         cnt=0;
         for(i = 0;i < LYNQ_CALL_MAX;i++)
         {
-            if(lynq_call_lists[i].used ==0)
+            if(s_call_lists[i].used ==0)
             {
                 continue;
             }
             cnt++;
-            LYINFLOG("local idx is %d id is %d addr is %s state is %d direction is %d",i,lynq_call_lists[i].call_id,lynq_call_lists[i].addr,lynq_call_lists[i].call_state,lynq_call_lists[i].direction);
+            LYINFLOG("local idx is %d id is %d addr is %s state is %d direction is %d",i,s_call_lists[i].call_id,s_call_lists[i].addr,s_call_lists[i].call_state,s_call_lists[i].direction);
             
-            if(lynq_call_lists[i].call_id > 0)
+            if(s_call_lists[i].call_id > 0)
             {
                 call_end = 0;
                 for(n = 0; n < LYNQ_CALL_MAX; n++)
                 {
-                    if(call_list[n].call_id == lynq_call_lists[i].call_id)
+                    if(call_list[n].call_id == s_call_lists[i].call_id)
                     {
                         call_end = 1;
-                        LYINFLOG("find lynq call local idx %d, service idx %d  id is %d!!!",i,n,lynq_call_lists[i].call_id);
+                        LYINFLOG("find lynq call local idx %d, service idx %d  id is %d!!!",i,n,s_call_lists[i].call_id);
                         break;
                     }
                 }
                 if(call_end == 0)
                 {
-                    LYINFLOG("MT hungup,then clean call info local idx is %d id is %d",i, lynq_call_lists[i].call_id);
+                    LYINFLOG("MT hungup,then clean call info local idx is %d id is %d",i, s_call_lists[i].call_id);
                     cleanCallList(i);                   
                 }
             } //fix bug API-54
@@ -581,10 +479,7 @@
 #ifdef ECALL_SUPPORT
                 if((call_list[i].call_state ==4) || (call_list[i].call_state ==5))
                 {
-
-                    pthread_mutex_lock(&s_ecall_variable_mutex);
-                    handupIncomingMT=lynq_ecall_is_running() && (lynq_ecall_is_permit_in_call(call_list[i].call_id)==false);   
-                    pthread_mutex_unlock(&s_ecall_variable_mutex);  
+                    handupIncomingMT=Is_handup_IncomingMT(call_list[i].call_id);                        
                     LYINFLOG("handupIncomingMT is %d",handupIncomingMT);
                     if(handupIncomingMT)
                     {
@@ -597,12 +492,12 @@
                 n = find_call_id_with_addr(call_list[i].addr);
                 if(n ==INVALID_ID)
                 {
-                    n = addAddr(call_list[i].addr);
-                    updateCallList(&lynq_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
-                    lynqIncomingCallId = call_list[i].call_id;
+                    n = addAddr(call_list[i].addr,call_list[i].call_id);
+                    updateCallList(&s_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
+                    s_IncomingCallId = call_list[i].call_id;
                     sendSignalIncomingCall();
                 }
-                else if(lynq_call_lists[n].call_state == call_list[i].call_state)
+                else if(s_call_lists[n].call_state == call_list[i].call_state)
                 {
                     LYINFLOG("state not changed, state is %d ",call_list[i].call_state);
                     if(call_list[i].call_state ==4 || call_list[i].call_state ==5)
@@ -617,9 +512,9 @@
                 }
                 else 
                 {
-                    LYINFLOG("state changed from %d to %d",lynq_call_lists[n].call_state,call_list[i].call_state);
+                    LYINFLOG("state changed from %d to %d",s_call_lists[n].call_state,call_list[i].call_state);
                     
-                    updateCallList(&lynq_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
+                    updateCallList(&s_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
                 }                               
             }
             else
@@ -628,15 +523,15 @@
                 call_end = 0;
                 for(n = 0 ; n < LYNQ_CALL_MAX; n++)
                 {
-                    if(lynq_call_lists[n].used && ((strcmp(call_list[i].addr,lynq_call_lists[n].addr)==0)||(call_list[i].call_id==lynq_call_lists[n].call_id)))
+                    if(s_call_lists[n].used && ((strcmp(call_list[i].addr,s_call_lists[n].addr)==0)||(call_list[i].call_id==s_call_lists[n].call_id)))
                     {
-                        if(lynq_call_lists[n].call_id==0)
+                        if(s_call_lists[n].call_id==0)
                         {
                              LYINFLOG("add a call id");
                              update=1;
                         }
-                        LYINFLOG("local idx %d updated, original call id is %d origial addr is %s original state is %d",n,lynq_call_lists[n].call_id,lynq_call_lists[n].addr,lynq_call_lists[n].call_state);                    
-                        updateCallList(&lynq_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
+                        LYINFLOG("local idx %d updated, original call id is %d origial addr is %s original state is %d",n,s_call_lists[n].call_id,s_call_lists[n].addr,s_call_lists[n].call_state);                    
+                        updateCallList(&s_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
                         call_end = 1;
                         break;
                     }                    
@@ -646,7 +541,7 @@
                 {  
                     LYINFLOG("need to hangup id %d", call_list[i].call_id);
 #ifdef ECALL_SUPPORT
-                    if(is_ecall_dial != LYNQ_ECALL_DAILING_STATE_NONE)
+                    if(IsECallDialing())
                     {
                         LYINFLOG("ecall is dialing, for the timebeing, don't huangup");
                         continue;
@@ -658,16 +553,15 @@
             }
             LYDBGLOG("servie idx %d end",i);
         }
-        LYINFLOG("add or update local index end ");
-        s_call_urc_event_complete = 1;
-        if(isDial==1)
+        LYINFLOG("add or update local index end ");       
+        if(s_module_isDial==1)
         {
             LYINFLOG("now is dialing");
             if(update==1)
             {
                 LYINFLOG("find added call");
                 sendSignalToWaitCallStateChange();
-                isDial = 0;
+                s_module_isDial = 0;
             }    
             else
             {
@@ -677,24 +571,22 @@
         else 
         {
             LYINFLOG("now is not dialing");
-        }
-        pthread_mutex_unlock(s_urc_call_state_change_mutex);
+        }        
     }
+    pthread_cleanup_pop(0);
+    pthread_mutex_unlock(&s_notice_get_call_list_mutex);
     return NULL;
 }
 
-void lynqRespWatingEvent()
+void lynqNoticeGetModuleCallList()
 {
-    if(s_call_urc_event_complete==1)
-    {
-        pthread_mutex_lock(s_urc_call_state_change_mutex);
-        pthread_cond_signal(s_urc_call_state_change_cond);
-        s_call_urc_event_complete = 0;
-        pthread_mutex_unlock(s_urc_call_state_change_mutex);
-    }
-    return;
+    pthread_mutex_lock(&s_notice_get_call_list_mutex);
+    pthread_cond_signal(&s_notice_get_call_list_cond);
+    pthread_mutex_unlock(&s_notice_get_call_list_mutex);
+    
 }
 
+#if 0
 /*Warren add for T800 platform 2021/11/19 start*/
 int lynq_socket_client_start()
 {   
@@ -741,236 +633,7 @@
     len_addr_serv = sizeof(addr_serv);  
     return 0;
 }
-int lynq_update_call_list_loop()
-{
-    int ret = 0;
-    pthread_attr_t attr;
-    pthread_attr_init(&attr);
-    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-    ret = pthread_create(&lynq_call_list_loop_tid,&attr,triggerGetCallList,NULL);
-    if(ret < 0)
-    {
-        LYERRLOG("lynq_update_call_list_loop fail!!!");
-        return -1;
-    }
-    LYDBGLOG("lynq_update_call_list_loop success!!!");
-    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;
-#ifdef ECALL_SUPPORT
-    int ecall_ind;
-    int ecallId;
-    int unused_callid;
-    int send_signal_to_wait_call_state;
-    int handup_ecall_id;
-#endif
-
-    LYINFLOG("thread_urc_recv in running....");
-    while(urc_call_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)
-        {
-            LYERRLOG("thread_urc_recv step2 fail");
-            break;
-        }
-        LYDBGLOG("=====>urc data len<=====:%d",len);
-        p = new Parcel();
-        if(p==NULL)
-        {
-            LYERRLOG("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",resp_type,urcid,slot_id);
-            switch (urcid)
-            {
-                case 1001://RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED
-                {
-                    LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d",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",resp_type,urcid,slot_id);
-                    break;
-                }
-#ifdef ECALL_SUPPORT
-                case RIL_UNSOL_ECALL_INDICATIONS:
-                {
-                    pthread_mutex_lock(&s_ecall_variable_mutex);
-		            send_signal_to_wait_call_state = false;
-                    handup_ecall_id=false;
-                    p->readInt32(&ecall_ind);   
-                    g_lynqIncomingEcallIndication = ecall_ind;
-                    p->readInt32(&ecallId);
-                    g_lynqIncomingEcallId = ecallId;
-                    LYINFLOG("**************:RIL_UNSOL_ECALL_INDICATIONS ,Id %d, ind %d, ecall dialing is %d, normal dialing is %d, local ecall id is %d",ecallId,ecall_ind,is_ecall_dial,isDial,g_ecallId);
-                    switch (g_lynqIncomingEcallIndication) 
-                    {
-                       case LYNQ_ECALL_ACTIVE:
-                            if(is_ecall_dial)
-                            {
-                                is_ecall_dial = LYNQ_ECALL_DAILING_STATE_ANSWERED;
-                            }
-                            break;
-                       case LYNQ_ECALL_SENDING_START:
-                            if(lynq_ecall_is_in_voice())
-                            {
-                                LYINFLOG("recv msd in voice, ind is changed to %d",LYNQ_ECALL_SENDING_START_IN_VOICE);
-                                g_lynqIncomingEcallIndication = LYNQ_ECALL_SENDING_START_IN_VOICE; 
-                            }
-                            break;
-                       case LYNQ_ECALL_LLACK_RECEIVED:
-                       case LYNQ_ECALL_ALACK_POSITIVE_RECEIVED:
-                       case LYNQ_ECALL_ALACK_CLEARDOWN_RECEIVED:
-                       //case LYNQ_ECALL_T5_TIMER_OUT:  /*when Certificate CP 1.1.10.2, no msd start (ind 1), so T5 timeout is not regard as success*/
-                       case LYNQ_ECALL_T6_TIMER_OUT:
-                       case LYNQ_ECALL_T7_TIMER_OUT:                          
-                           if(is_ecall_dial)
-                           {
-                               LYINFLOG("ecall is dialing, recv suc indication");
-                               is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
-                               if(ecallId >0 && find_call_id_with_call_id(ecallId)==INVALID_ID)
-                               {
-                                     LYINFLOG("add ecall in loacl list");
-                                     g_ecallId = ecallId;
-                                     unused_callid=addAddr("ecall");
-                                     lynq_call_lists[unused_callid].call_id=g_ecallId;
-                               } 
-                               send_signal_to_wait_call_state=true;                             
-                           }        
-                           else if(ecallId >0 && (find_call_id_with_call_id(ecallId)==INVALID_ID) &&  (g_lynqEcallVariant != LYNQ_ECALL_CALLBACK))
-                           {
-                               LYERRLOG("ecall is not in dialing and first recv suc indication, hangup");
-                               handup_ecall_id=true;
-                           }   
-                           else 
-                           {
-                               LYERRLOG("ecall is not in dialing and not first recv suc indication");
-                           }
-                           break;
-                       case LYNQ_ECALL_PSAP_CALLBACK_START:                            
-                           if(lynq_ecall_is_running()==0)
-                           {
-                               if(ecallId>0)
-                               {                                
-                                   LYINFLOG("ecall is not running, recv psap call back msd start, set ecall running");
-                                   g_lynqEcallVariant = LYNQ_ECALL_CALLBACK;
-                                   g_ecallId = ecallId;
-                                   if(isDial)
-                                   {
-                                       LYINFLOG("stop normal dial");
-                                       send_signal_to_wait_call_state=true;                               
-                                   }
-                                   else 
-                                   {
-                                       LYINFLOG("no normal dial");
-                                   }  
-                               }
-                               else 
-                               {
-                                   LYERRLOG("ecallId is abnormal in psap callback");
-                               }
-                           }                           
-                           else 
-                           {
-                               LYERRLOG("ecall is running, recv psap call back msd start");
-                           }
-                           break;                       
-                       case LYNQ_ECALL_ABNORMAL_HANGUP:
-                           if(is_ecall_dial == LYNQ_ECALL_DAILING_STATE_NONE)                             
-                           {
-                               LYERRLOG("ecall is not in dialing , recv abnormal hangup");
-                               g_ecallId = INVALID_ID;
-                           }
-                           else if (is_ecall_dial == LYNQ_ECALL_DAILING_STATE_STARTED)
-                           {
-                               LYERRLOG("ecall is in dialing state, recv no answer, recv abnormal hangup, dont' redial");
-                               g_ecallId = INVALID_ID;
-                               send_signal_to_wait_call_state=true;                                                    
-                           }    
-                           else {
-                               LYINFLOG("ecall is in dialing and recv answer, recv abnormal hangup");
-                           }
-                           break;
-                       case LYNQ_ECALL_DISCONNECTED:
-                       case LYNQ_ECALL_REDIAL_TIMER_OUT:
-                       case LYNQ_ECALL_T2_TIMER_OUT :
-                       case LYNQ_ECALL_IMS_DISCONNECTED:                           
-                           g_ecallId = INVALID_ID;
-                           if(g_lynqEcallVariant == LYNQ_ECALL_CALLBACK)
-                           {
-                               g_lynqEcallVariant = LYNQ_ECALL_VAR_NONE; /*other type, needn't re-initialize*/
-                           }
-                           if(is_ecall_dial != LYNQ_ECALL_DAILING_STATE_NONE)
-                           {
-                               LYERRLOG("ecall is in dialing, recv like disconnect indication");
-                               is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;                         
-                               send_signal_to_wait_call_state=true;                               
-                           }
-                           else 
-                           {
-                               LYINFLOG("ecall is not in dialing, recv like disconnect indication");
-                           }
-                           break;
-                       default:                          
-                           LYINFLOG("not special indication");
-                    }                         
-                    pthread_mutex_unlock(&s_ecall_variable_mutex);
-                    if(send_signal_to_wait_call_state)
-                    {
-                        sendSignalToWaitCallStateChange();
-                    }                    
-                    sendSignalIncomingECallEvent();
-                    if(handup_ecall_id)
-                    {
-                        lynq_call_hungup(&ecallId);
-                    }
-                    LYINFLOG("**************:RIL_UNSOL_ECALL_INDICATIONS, local ecall id is %d", g_ecallId);
-                    break;
-                 }
-#endif
-                default:
-                    break;
-            }
-        }
-        delete p;
-        p = NULL;
-    }
-    close(socket_fd);
-}
 int lynq_socket_urc_start()
 {
     int socket_fd=0;
@@ -1012,131 +675,134 @@
     LYDBGLOG("urc loop success!!!");
     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;
-}
+#endif
 
 void lynq_call_state_change_test(int soc_id)
 {
     LYDBGLOG("call state change,sim:%d",soc_id);
 }
 
-void lynq_init_rtp()
-{   
-    memset(&g_rtp_client_info,0,sizeof(g_rtp_client_info));
-    memset(&g_rtp_server_info,0,sizeof(g_rtp_server_info));    
-  
+int lynq_start_call_list_loop()
+{
+#if 0
+    int ret = 0;
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 
-    lynq_set_rtp_param(8000,1,400);
+    s_notice_get_call_list_mutex = new pthread_mutex_t;
+    pthread_mutex_init(s_notice_get_call_list_mutex, NULL);
+    s_notice_get_call_list_cond = new pthread_cond_t;
+    LYINFLOG("liulei s_notice_get_call_list_mutex\n");
+    pthread_cond_init(s_notice_get_call_list_cond, NULL);
+    LYINFLOG("liulei s_notice_get_call_list_cond\n"); 
+#endif
 
-    for(int i=0;i<RTP_MODE_MAX;i++)
+    s_call_list_loop = 1;  
+    int ret = pthread_create(&s_call_list_loop_tid,/*&attr*/NULL,triggerGetCallList,NULL);
+    if(ret < 0)
     {
-        lynq_set_rtp_port(i,6666);
-        g_rtp_thread_valid[i] = 0;
-    }          
-    
-    LYDBGLOG("lynq init rtp success!!!");
-    return;
-}
-
-int lynq_init_call(int uToken)
-{   
-    if(g_lynq_call_init_flag == 1){
-        LYDBGLOG("lynq init call failed!!!");
+        LYERRLOG("lynq_update_call_list_loop fail!!!");
         return -1;
     }
-    g_lynq_call_init_flag = 1;
-    s_call_urc_event_complete = 1;
-    call_list_loop = 1;
-    LYINFLOG("liulei call_list_loop %d\n", call_list_loop);
-    s_urc_call_state_change_mutex = new pthread_mutex_t;
-    pthread_mutex_init(s_urc_call_state_change_mutex, NULL);
-    s_urc_call_state_change_cond = new pthread_cond_t;
-    LYINFLOG("liulei s_urc_call_state_change_mutex\n");
-    pthread_cond_init(s_urc_call_state_change_cond, NULL);
-    LYINFLOG("liulei s_urc_call_state_change_cond\n");
-    int result = 0;
-    Global_uToken_call = uToken;
-    urc_call_recive_status = 1;
-    client_size = sizeof(client_t);
-    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));
+    LYINFLOG("lynq_update_call_list_loop success!!!");
 
-    lynq_init_rtp();
-    
-    LYDBGLOG("lynq init call success!!!");
+    memset(s_call_lists,0,sizeof(s_call_lists));
     return 0;
 }
-int lynq_deinit_call()
+
+int lynq_stop_call_list_loop()
 {
     int ret;
-    if(g_lynq_call_init_flag == 0)
-    {
-        LYDBGLOG("lynq_deinit_call failed!!!");
-        return -1;
-    }
-    else
-    {
-        g_lynq_call_init_flag = 0;
-        lynq_call_hungup_all();       
-        if(lynq_call_client_sockfd>0)
-        {
-            close(lynq_call_client_sockfd);
-        }
-        urc_call_recive_status = 0;
-        call_list_loop = 0;
-        lynq_set_voice_audio_mode(AUDIO_MODE_CODEC);
-        if(lynq_call_urc_tid == -1 || lynq_call_list_loop_tid == -1)
-        {
-            return -1;
-        }
-        ret = pthread_cancel(lynq_call_urc_tid);
-        LYDBGLOG("pthread cancel ret = %d",ret);
-        ret = pthread_cancel(lynq_call_list_loop_tid);
-        LYDBGLOG("pthread cancel ret = %d",ret);
-        ret = pthread_join(lynq_call_urc_tid,NULL);
-        LYDBGLOG("pthread join ret = %d",ret);
-        ret = pthread_join(lynq_call_list_loop_tid,NULL);
-        LYDBGLOG("pthread join ret = %d",ret);
-        pthread_mutex_destroy(s_urc_call_state_change_mutex);
-        pthread_cond_destroy(s_urc_call_state_change_cond);
-        delete s_urc_call_state_change_mutex;
-        //s_urc_call_state_change_mutex = NULL;
-        delete s_urc_call_state_change_cond;
-        //s_urc_call_state_change_cond = NULL;
-
-        return 0;
-    }
+    pthread_mutex_lock(&s_notice_get_call_list_mutex);
+    s_call_list_loop = 0;
+    ret = pthread_cancel(s_call_list_loop_tid);
+    LYINFLOG("pthread cancel w_c_list ret = %d",ret);    
+    pthread_mutex_unlock(&s_notice_get_call_list_mutex);    
+    ret = pthread_join(s_call_list_loop_tid,NULL);
+    LYINFLOG("pthread join w_c_list ret = %d",ret);  
+    s_call_list_loop_tid=-1;
+#if 0
+    pthread_mutex_destroy(s_notice_get_call_list_mutex);
+    pthread_cond_destroy(s_notice_get_call_list_cond);
+    delete s_notice_get_call_list_mutex;
+    //s_notice_get_call_list_mutex = NULL;
+    delete s_notice_get_call_list_cond;
+    //s_notice_get_call_list_cond = NULL;
+#endif
+    
+    return 0;
 }
 
+int lynq_init_call(int utoken){
+    if(g_module_init_flag != MODULE_CLOSED)
+    {
+        LYERRLOG("module state is %d",g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }
+    if(utoken <0){
+        LYERRLOG("utoken  is less than 0",utoken);      
+        return LYNQ_E_PARAMETER_ANONALY;
+    }
+    g_module_init_flag = MODULE_SWITCHING;
+
+    LYLOGSET(LOG_INFO);
+    LYLOGEINIT(USER_LOG_TAG);   
+
+    g_module_Global_uToken = utoken; 
+
+    int ret = lynq_urc_socket_start();
+    if(ret != RESULT_OK)
+    {
+        LYERRLOG("init socket urc fail!!!");
+        g_module_init_flag = MODULE_CLOSED;
+        return LYNQ_E_INNER_ERROR;
+    }
+
+    ret = lynq_server_socket_start();
+    if(ret !=RESULT_OK)
+    {
+        LYERRLOG("init socket client fail!!!");
+        lynq_close_urc_thread();
+        g_module_init_flag = MODULE_CLOSED;
+        return LYNQ_E_INNER_ERROR;
+    }
+
+     
+    int result = lynq_start_call_list_loop();
+    if(ret != RESULT_OK)
+    {
+        LYERRLOG("lynq_start_call_list_loop fail!!!");
+        lynq_close_urc_thread();
+        lynq_close_rc_thread();
+        g_module_init_flag = MODULE_CLOSED;
+        return LYNQ_E_INNER_ERROR;
+    }      
+
+    lynq_init_rtp();
+
+    g_module_init_flag = MODULE_RUNNING;
+    return 0;
+}
+
+int lynq_deinit_call(void){
+
+    if (g_module_init_flag != MODULE_RUNNING)
+    {
+       LYERRLOG("module state is %d",g_module_init_flag);
+       return LYNQ_E_CONFLICT;
+    }      
+    lynq_call_hungup_all();  
+    lynq_set_voice_audio_mode(AUDIO_MODE_CODEC);
+    g_module_init_flag = MODULE_SWITCHING;
+    lynq_close_urc_thread();
+    lynq_close_rc_thread();    
+    lynq_stop_call_list_loop();
+    g_module_init_flag = MODULE_CLOSED;
+    return 0;
+}
+
+#if 0
 int lynq_set_common_request(int request_id, int argc, const char* format,...)
 {
     Parcel p;
@@ -1147,6 +813,14 @@
     int slot_id = -1;
     int error = -1;
 
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(request_id,5,p,argc,format,...);
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;
+
     client.uToken = Global_uToken_call;
     client.request = request_id;
     client.paramLen = argc;
@@ -1170,61 +844,68 @@
         LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
     }
     return error;
+
+    
 }
+#endif
 
 int lynq_get_common_request(int request_id, int* status)
 {
-    Parcel p;
-    lynq_client_t client;
-    int resp_type = -1;
-    int token;
-    int request = -1;
-    int slot_id = -1;
-    int error = -1;
     if(status==NULL)
     {
         LYERRLOG("status is null");
-        return -1;
+        return LYNQ_E_PARAMETER_ANONALY;
     }
-    client.uToken = Global_uToken_call;
-    client.request = request_id;
-    client.paramLen = 0;
-    bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
-    LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
-    if(send_request(lynq_call_client_sockfd,&client)==-1)
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,request_id,0,"");
+    if(ret==RESULT_OK)
     {
-        LYERRLOG("send request fail");
-        return -1;
+        p->readInt32(status);
+        delete p;        
     }
-    if(get_response(lynq_call_client_sockfd,p)==0)
-    {
-        JumpHeader(p,&resp_type,&token,&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;
+    return ret;   
+}
+
+int waitCallstateChange(int mtime)
+{
+    LYINFLOG("wait Call state Change");
+    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 IsNormalCallDailing()
+{
+    return s_module_isDial;
 }
 
 int lynq_call(int* handle,char addr[])
 {
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
     }
-    Parcel p;
-    lynq_client_t client;
-    int resp_type = -1;
-    int token;
-    int request = -1;
-    int slot_id = -1;
-    int error = -1;
+    
     int lynq_call_id = -1;
 
     LYINFLOG("lynq_call begin addr %s",addr);
     if(addr==NULL)
     {
         LYERRLOG("Phone num is null!!!");
-        return -1;
+        return LYNQ_E_PARAMETER_ANONALY;
     }
 
     if(find_call_id_with_addr(addr)!=INVALID_ID)
@@ -1240,209 +921,151 @@
         return LYNQ_E_ECALL_BEING_RUNNING;
     }
 #endif   
+
+    Parcel* p=NULL;
+    lynq_call_id = addAddr(addr,0);
+    int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_DIAL,2,"%s %d",addr, 0);
+    if(ret!=0)
+    {
+        cleanCallList(lynq_call_id);       
+        return ret;      
+    }
     
-    client.uToken = Global_uToken_call;
-    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");
-    lynq_call_id = addAddr(addr);
-    LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
-    pthread_mutex_lock(&g_lynq_call_sendto_mutex);
-    if(send_request(lynq_call_client_sockfd,&client)==-1)
+    delete p;        
+ 
+    s_module_isDial = 1;
+    if(waitCallstateChange(6000)==ETIMEDOUT)//6000ms
     {
-        LYERRLOG("send request fail");
-        cleanCallList(lynq_call_id);   
-        return -1;
+        //if timeout,this call need destroy.
+        s_module_isDial = 0;      
+        LYERRLOG("lynq_call timeout:wait Call state fail!!! clear local idx %d",lynq_call_id);
+        cleanCallList(lynq_call_id);            
+        return LYNQ_E_TIME_OUT;
     }
-    get_response(lynq_call_client_sockfd,p);
-    pthread_mutex_unlock(&g_lynq_call_sendto_mutex);
-    JumpHeader(p,&resp_type,&token,&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)
+    s_module_isDial = 0;
+    *handle = s_call_lists[lynq_call_id].call_id;
+    if(*handle > 0)
     {
-        isDial = 1;
-        if(waitCallstateChange(6000)==ETIMEDOUT)//6000ms
-        {
-            //if timeout,this call need destroy.
-            isDial = 0;
-            error = LYNQ_E_TIME_OUT;
-            LYERRLOG("lynq_call timeout:wait Call state fail!!! clear local idx %d",lynq_call_id);
-            cleanCallList(lynq_call_id);            
-            return error;
-        }
-         isDial = 0;
-        *handle = lynq_call_lists[lynq_call_id].call_id;
-        if(*handle > 0)
-        {
-            LYINFLOG("lynq_call dial addr %s suc, id is %d",addr,*handle);
-            return 0;
-        }
-        else 
-        {   
-            LYERRLOG("lynq_call dial addr %s fail, invalid id",addr);
-            cleanCallList(lynq_call_id);      
-            return LYNQ_E_INVALID_ID_ANONALY;
-        }      
-        
+        LYINFLOG("lynq_call dial addr %s suc, id is %d",addr,*handle);
+        return RESULT_OK;   
     }
-    LYERRLOG("lynq_call dial addr %s fail, service error %d",addr, error);
-    cleanCallList(lynq_call_id);      
-    return error;
+    else 
+    {   
+        LYERRLOG("lynq_call dial addr %s fail, invalid id",addr);
+        cleanCallList(lynq_call_id);      
+        return LYNQ_E_INVALID_ID_ANONALY;
+    }                 
 }
 int lynq_call_answer()
 {
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
-    }
-    Parcel p;
-    lynq_client_t client;
-    int resp_type = -1;
-    int token;
-    int request = -1;    
-    int slot_id = -1;    
-    int error = -1;
-    client.uToken = Global_uToken_call;
-    client.request = 40;//RIL_REQUEST_DIAL
-    client.paramLen = 0;
-    bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
-    LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
-    pthread_mutex_lock(&g_lynq_call_sendto_mutex);
-    if(send_request(lynq_call_client_sockfd,&client)==-1)
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }   
+
+    Parcel* p=NULL;    
+    int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_ANSWER,0,"");
+    if(ret==RESULT_OK)
     {
-        LYERRLOG("send request fail");
-        return -1;
-    }
-    get_response(lynq_call_client_sockfd,p);
-    pthread_mutex_unlock(&g_lynq_call_sendto_mutex);
-    JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
-    LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
-    return error;
+        delete p;      
+    }        
+    return ret;
 }
 int lynq_call_hungup(int* handle)
 {
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
-    }
-    Parcel p;
-    lynq_client_t client;
-    int resp_type = -1;
-    int request = -1;
-    int token;
-    int slot_id = -1;
-    int error = -1;
-    int call_id = 0;
-    int lynq_call_id;
+        return LYNQ_E_CONFLICT;
+    }  
+    
     if(handle==NULL||!((*handle>=0)&&(*handle<10)))
     {
-        LYERRLOG("[%s] illegal input!!!!",__FUNCTION__);
-        return LYNQ_E_CONFLICT;
+        LYERRLOG("%s illegal input!!!!",__func__);
+        return LYNQ_E_PARAMETER_ANONALY;
     }
-    client.uToken = Global_uToken_call;
-    client.request = 12;//RIL_REQUEST_HUNGUP
-    client.paramLen = 1;
-    bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
-    call_id = *handle;
-    sprintf(client.param,"%d",call_id);
-    LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
-    pthread_mutex_lock(&g_lynq_call_sendto_mutex);
-    if(send_request(lynq_call_client_sockfd,&client)==-1)
+
+    int call_id = *handle;
+    Parcel* p=NULL;    
+    int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_HANGUP,1,"%d",call_id);
+    if(ret!=0)
     {
-        LYERRLOG("send request fail");
-        return -1;
-    }
-    get_response(lynq_call_client_sockfd,p);
-    pthread_mutex_unlock(&g_lynq_call_sendto_mutex);
-    JumpHeader(p,&resp_type,&token,&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)
+        return ret; 
+    }     
+    delete p; 
+
+    int  lynq_call_id=find_call_id_with_call_id(call_id);
+    if(lynq_call_id!=INVALID_ID)
     {
-        lynq_call_id=find_call_id_with_call_id(call_id);
-        if(lynq_call_id!=INVALID_ID)
-        {
-            cleanCallList(lynq_call_id);
-        }        
-    }
-    return error;
+        cleanCallList(lynq_call_id);
+    }        
+    
+    return RESULT_OK;     
 }
 int lynq_call_hungup_all()
 {
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
     }
-    Parcel p;
-    lynq_client_t client;
-    int resp_type = -1;
-    int token=-1;
-    int request = -1;
-    int slot_id = -1;
-    int error = -1;
-    client.uToken = Global_uToken_call;
-    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",client.uToken,client.request,client.paramLen,client.param);
-    pthread_mutex_lock(&g_lynq_call_sendto_mutex);
-    if(send_request(lynq_call_client_sockfd,&client)==-1)
+
+    Parcel* p=NULL;    
+    int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_UDUB,0,"");
+    if(ret==RESULT_OK)
     {
-        LYERRLOG("send request fail");
-        return -1;
-    }
-    get_response(lynq_call_client_sockfd,p);
-    pthread_mutex_unlock(&g_lynq_call_sendto_mutex);
-    JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
-    LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
-    return error;
+         delete p;      
+    }        
+    return ret;   
 }
 int lynq_wait_incoming_call(int *handle)
 {
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
     }
     waitIncomingCall();
-    *handle = lynqIncomingCallId;
-    LYINFLOG("lynq incoming call id:%d",lynqIncomingCallId);
-    return 0;
+    *handle = s_IncomingCallId;
+    LYINFLOG("lynq incoming call id:%d",s_IncomingCallId);
+    return RESULT_OK;   
 }
 
 int lynq_set_auto_answercall(const int mode)
 {
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
     }
-    global_call_auto_answer = mode;
+    s_call_auto_answer = mode;
     LYINFLOG("auto answer call mode =%d",mode);
-    return 0;
+    return RESULT_OK;   
 }
 int lynq_get_current_call_state(int *handle,    int *call_state,int *toa,int *direction,char addr[])
 {
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
     }
     int lynq_call_id = 0;
     LYINFLOG("lynq_get_current_call_state begin ");
     if(handle==NULL)
     {
         LYERRLOG("handle is NULL");
-        return LYNQ_E_NULL_ANONALY;
+        return LYNQ_E_PARAMETER_ANONALY;
     }
     lynq_call_id = find_call_id_with_call_id(*handle);
     if(lynq_call_id==INVALID_ID)
     {
         return LYNQ_E_INVALID_ID_ANONALY;
     }
-    *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;
+    *call_state = s_call_lists[lynq_call_id].call_state;
+    *toa = s_call_lists[lynq_call_id].toa;
+    *direction = s_call_lists[lynq_call_id].direction;
+    memcpy(addr,s_call_lists[lynq_call_id].addr,strlen(s_call_lists[lynq_call_id].addr)+1);
+    return RESULT_OK;   
 }
 
 int lynq_get_current_call_number()
@@ -1451,7 +1074,7 @@
     int i;
     for(i = 0;i < LYNQ_CALL_MAX;i++)
     {
-        if(lynq_call_lists[i].used !=0)
+        if(s_call_lists[i].used !=0)
         {
             cnt++;           
         }
@@ -1464,32 +1087,42 @@
 static int judge_mic(const int enable){
     switch(enable){
         case 0:
-            return 1;
+            return true;
         case 1:
-            return 1;
+            return true;
         default:
-            return 0;
+            return false;
     }
 }
 
 int lynq_set_mute_mic(const int enable)
 {   
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
-    }
-    if(!judge_mic(enable)){
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
         return LYNQ_E_CONFLICT;
     }
-    return lynq_set_common_request(53,1,"%d",enable); //RIL_REQUEST_SET_MUTE    
+    if(!judge_mic(enable)){
+        return LYNQ_E_PARAMETER_ANONALY;
+    }
+ // return lynq_set_common_request(53,1,"%d",enable); //RIL_REQUEST_SET_MUTE  
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SET_MUTE,1,"%d",enable);
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;
 }
 int lynq_get_mute_mic(int *status)
 {
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
     }
-    return lynq_get_common_request(54,status);//RIL_REQUEST_GET_MUTE    
+    return lynq_get_common_request(RIL_REQUEST_GET_MUTE,status);//54
 }
 
 /**
@@ -1502,25 +1135,36 @@
 {
     if(callnum == '#')
     {
-        return 1;
+        return true;
     }
     if(callnum == '*')
     {
-        return 1;
+        return true;
     }
     if(callnum >= '0'&& callnum <= '9')
     {
-        return 1;
+        return true;
     }
-    return 0;
+    return false;
 }
 
 int lynq_switch_waiting_or_holding_and_active(void)
 {
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
     }
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE,0,"");
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;
+
+#if 0
     Parcel p;
     lynq_client_t client;
     int resp_type = -1;
@@ -1544,14 +1188,25 @@
     JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
     LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
     return error;
+#endif
 }
 
 int lynq_hangup_waiting_or_background(void)
 {
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
     }
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND,0,"");
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;
+#if 0
     Parcel p;
     lynq_client_t client;
     int resp_type = -1;
@@ -1575,14 +1230,25 @@
     JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
     LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
     return error;
+#endif
 }
 
 int lynq_hangup_foreground_resume_background(void)
 {
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
     }
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND,0,"");
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;
+#if 0    
     Parcel p;
     lynq_client_t client;
     int resp_type = -1;
@@ -1606,24 +1272,35 @@
     JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
     LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
     return error;
+#endif
 }
 
 int lynq_set_DTMF(const char callnum)
 {
-    if(g_lynq_call_init_flag == 0)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return -1;
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
     }
     if(!judge_dtmf(callnum))
     {
         return LYNQ_E_CONFLICT;
     }
-    if(!lynq_call_state)
+    if(s_module_call_state!=CALL_ON)
     {
         LYERRLOG("LYNQ_E_CONFLICT");
         return LYNQ_E_CONFLICT;
     }
-    return lynq_set_common_request(24,1,"%c",callnum); //RIL_REQUEST_DTMF  
+    
+//  return lynq_set_common_request(24,1,"%c",callnum); //RIL_REQUEST_DTMF  
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_DTMF,1,"%c",callnum);
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;
 }
 static int judge_volume(LYNQ_E_VOLUMN_SET set,const int volume){
     if(set==LYNQ_E_VOLUMN_SET_DTMF){
@@ -1641,716 +1318,119 @@
 }
 int lynq_set_DTMF_volume(const int volume)
 {   
-    if(!judge_volume(LYNQ_E_VOLUMN_SET_DTMF,volume)){
+    if(g_module_init_flag != MODULE_RUNNING)
+    {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
         return LYNQ_E_CONFLICT;
     }
-    return lynq_set_common_request(8003,1,"%d",volume);//LYNQ_REQUEST_SET_DTMF_VOLUME
+    if(!judge_volume(LYNQ_E_VOLUMN_SET_DTMF,volume)){
+        return LYNQ_E_PARAMETER_ANONALY;
+    }
+//  return lynq_set_common_request(8003,1,"%d",volume);//LYNQ_REQUEST_SET_DTMF_VOLUME
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_SET_DTMF_VOLUME,1,"%d",volume);
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;
 }
 int lynq_set_speech_volume(const int volume)//mixer_set_volume
 {
-    if(!judge_volume(LYNQ_E_VOLUMN_SET_SPEECH,volume))
+    if(g_module_init_flag != MODULE_RUNNING)
     {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
         return LYNQ_E_CONFLICT;
     }
-    return lynq_set_common_request(8009,1,"%d",volume); //LYNQ_REQUEST_SET_SPEECH_VOLUME
+    if(!judge_volume(LYNQ_E_VOLUMN_SET_SPEECH,volume))
+    {
+        return LYNQ_E_PARAMETER_ANONALY;
+    }
+//  return lynq_set_common_request(8009,1,"%d",volume); //LYNQ_REQUEST_SET_SPEECH_VOLUME
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_SET_SPEECH_VOLUME,1,"%d",volume);
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;
 }
 int lynq_get_speech_volume(int* volumn)//mixer_get_volume
 {
-    return lynq_get_common_request(8010,volumn);//LYNQ_REQUEST_GET_SPEECH_VOLUME
+    return lynq_get_common_request(LYNQ_REQUEST_GET_SPEECH_VOLUME,volumn);//8010  
 } 
 int lynq_incall_record_start(const char* file_path)
 {
-    return lynq_set_common_request(8011,2,"%s %s","1",file_path); //LYNQ_REQUEST_RECORD
+//    return lynq_set_common_request(8011,2,"%s %s","1",file_path); //LYNQ_REQUEST_RECORD
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_RECORD,2,"%s %s","1",file_path);
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;    
 }
 int lynq_incall_record_stop()
 {
+    if(g_module_init_flag != MODULE_RUNNING)
+    {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }
     const char* unused_file="just_ocuupy_paramter_postion";
-    return lynq_set_common_request(8011,2,"%s %s","0",unused_file); //LYNQ_REQUEST_RECORD
+//    return lynq_set_common_request(8011,2,"%s %s","0",unused_file); //LYNQ_REQUEST_RECORD
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_RECORD,2,"%s %s","0",unused_file);
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;        
 }
 /*audio end*/
 
+void urc_msg_process(Parcel *p)
+{ 
+    int resp_type;
+    int urcid;
+    int slot_id;
+    
+    p->readInt32(&resp_type);
+    p->readInt32(&urcid);
+    p->readInt32(&slot_id);
+    LYINFLOG("urc id = %d, slot_id = %d",urcid,slot_id);
+    switch (urcid)
+    {
+        case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED://1001
+        {
+            LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d",resp_type,urcid,slot_id);
+            lynqNoticeGetModuleCallList();
+            break;
+        }
+        case RIL_UNSOL_CALL_RING: //1018
+        {
+            if(s_call_auto_answer==1)
+            {
+                lynq_call_answer();
+            }
+            break;
+        }
+        case RIL_UNSOL_RINGBACK_TONE: //1029
+        case RIL_UNSOL_CALL_INFO_INDICATION://3049
+        {
+            LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d",resp_type,urcid,slot_id);
+            break;
+        }
 #ifdef ECALL_SUPPORT
-LYNQ_ECall_Variant lynq_get_lynq_ecall_variant_from_lynq_type(LYNQ_ECall_Type type)
-{
-    switch(type)
-    {
-        case LYNQ_ECALL_TYPE_TEST:
-            return LYNQ_ECALL_TEST;
-        case LYNQ_ECALL_TYPE_RECONFIG:
-            return LYNQ_ECALL_RECONFIG;
-        default:
-            return LYNQ_ECALL_EMERGENCY;
-    }
-}
-
-RIL_ECall_Variant lynq_get_ril_ecall_variant_from_lynq_variant(LYNQ_ECall_Variant type)
-{
-    switch(type)
-    {
-        case LYNQ_ECALL_TEST:
-            return ECALL_TEST;
-        case LYNQ_ECALL_RECONFIG:
-            return ECALL_RECONFIG;
-        default:
-            return ECALL_EMERGENCY;
-    }
-}
-
-RIL_ECall_Category lynq_get_ril_ecall_cat_from_lynq_cat(LYNQ_ECall_Category cat)
-{
-    switch(cat)
-    {
-        case LYNQ_EMER_CAT_MANUAL_ECALL:
-            return EMER_CAT_MANUAL_ECALL;        
-        default:
-            return EMER_CAT_AUTO_ECALL;
-    }
-}
-
-
-int lynq_set_test_num(LYNQ_ECall_Set_Type type, const char *test_num, int test_num_length)
-{
-    int error; 
-
-    if(test_num==NULL || test_num_length > LYNQ_PHONE_NUMBER_MAX )
-    {
-       LYERRLOG("test_num is null or test_num_length %d s greater than %d ",test_num_length,LYNQ_PHONE_NUMBER_MAX);
-       return -1;
-    }       
-    
-    error=lynq_set_common_request(RIL_REQUEST_ECALL_SET_TEST_NUM,2,"%d %s",type,test_num);
-
-    if(error==0)
-    {
-        snprintf(e_call_addr[LYNQ_ECALL_TEST],LYNQ_PHONE_NUMBER_MAX,"%s",test_num);
-    }
-
-    return error;
-}
-
-int lynq_ecall_can_be_preempted(LYNQ_ECall_Variant old_variant,LYNQ_ECall_Variant new_variant)
-{
-    int ret;
-
-    if(old_variant == LYNQ_ECALL_EMERGENCY)
-    {
-        return false;
-    }
-    else if(new_variant == LYNQ_ECALL_EMERGENCY)
-    {
-        return true;
-    }
-    else if(old_variant==LYNQ_ECALL_DAILING_STATE_NONE)
-    {
-        return true;
-    }        
-    else 
-    {
-        ret = (g_ecall_whether_preempt & 0x01);
-    }
-    LYINFLOG("ecall clear conflict call, lynq_ecall_can_be_preempted is true");
-    return ret;
-}
-
-int lynq_clear_current_call()
-{
-    int cnt;
-    if(lynq_call_hungup_all()!=0)
-    {
-        LYERRLOG("ecall clear conflict call,  hangup all failure");
-        return -1;
-    }       
-    cnt=0;
-    while(lynq_get_current_call_number()!=0 && cnt<80)
-    {
-        lynqRespWatingEvent();  
-        usleep(200 * 1000);//200ms
-        cnt++;                
-    }
-    if(lynq_get_current_call_number()!=0)
-    {
-        LYERRLOG("ecall clear conflict call, current call list can't cleared after 15s");
-        return -2;
-    } 
-
-    LYINFLOG("ecall clear conflict call, after %d 0.2s, call list  is cleared", cnt);         
-    return 0;
-}
-
-int lynq_clear_current_conflict_call(LYNQ_ECall_Variant old_variant,LYNQ_ECall_Variant new_variant)
-{
-    int cnt;
-    int ret;
-
-    if(lynq_ecall_is_running()==false)
-    {
-        if(lynq_get_current_call_number()==0)
+        case RIL_UNSOL_ECALL_INDICATIONS://9502
         {
-            LYINFLOG("ecall clear conflict call, no conflict ecall and normal call");
+            urc_ecall_msg_process(p);
         }
-        else if(g_ecall_whether_preempt & 0x02)
-        {
-            ret=lynq_clear_current_call();
-            LYERRLOG("ecall clear conflict call, relase current normal call ret is %d",ret);                         
-        }
-        return 0;          
-    }
-
-    LYINFLOG("ecall clear conflict call, two ecall occure at the same time, new is %d, old is %d, g_preempt is %d",new_variant,old_variant,g_ecall_whether_preempt);
-
-    if(lynq_ecall_can_be_preempted(old_variant,new_variant)==false)
-    {
-        LYERRLOG("ecall clear conflict call, new ecall %d can't preempt old ecall %d",new_variant,old_variant);
-        return -1;
-    }    
-
-    ret=lynq_clear_current_call();
-    LYINFLOG("ecall clear conflict call, relase current call(including ecall) ret is %d",ret);    
-
-    if(is_ecall_dial != LYNQ_ECALL_DAILING_STATE_NONE)
-    {
-        sendSignalToWaitCallStateChange();  
-        LYINFLOG("ecall clear conflict call, stop ecall in dailing status");
-    }             
-    
-    cnt=0;
-    while(lynq_ecall_is_running() && cnt<80)
-    {
-        usleep(200 * 1000);//200ms
-        cnt++;
-    }
-  
-    if(lynq_ecall_is_running())
-    {
-        LYERRLOG("ecall clear conflict call, after 16s, lynq ecall is still running");        
-    }
-    else
-    {
-        LYINFLOG("ecall clear conflict call, after %d 0.2s, ecall info is cleared", cnt);           
-    }
-
-    sleep(3);// for ecall disconnect
-    print_ecall_info();        
-    return 0;
-}
-
-int lynq_fast_ecall(int* handle, LYNQ_ECall_Category lynq_ecall_cat, LYNQ_ECall_Variant lynq_ecall_variant,  const char *addr, int addr_length, const unsigned char *msd_data,int msd_length)
-{
-    int error;
-    RIL_ECall_Variant ril_ecall_variant = lynq_get_ril_ecall_variant_from_lynq_variant (lynq_ecall_variant);
-    RIL_ECall_Category ril_ecall_cat = lynq_get_ril_ecall_cat_from_lynq_cat(lynq_ecall_cat);
-    char lynq_msd_data[MSD_MAX_LENGTH*2+1]={0};
-    unsigned int i;          
-   
-    if(msd_length > MSD_MAX_LENGTH || msd_length <=0 || lynq_ecall_variant >=LYNQ_ECALL_MO_MAX)
-    {
-        LYERRLOG("lynq_fast_ecall msd_length %d or ecall variant %d parameter error",msd_length,lynq_ecall_variant);
-        return LYNQ_E_ECALL_MSD_LENGTH_ERROR;
-    }     
-
-    if(lynq_clear_current_conflict_call(g_lynqEcallVariant,lynq_ecall_variant)!=0)
-    {
-         LYERRLOG("%s call lynq_clear_current_conflict_call false, old is %d, new is %d",__func__,g_lynqEcallVariant,lynq_ecall_variant);
-         return LYNQ_E_ECALL_BEING_RUNNING;
-    }  
-
-    pthread_mutex_lock(&s_ecall_variable_mutex);
-    is_ecall_dial = LYNQ_ECALL_DAILING_STATE_STARTED;
-    g_lynqEcallVariant = lynq_ecall_variant;
-    g_ecallId = INVALID_ID;
-    pthread_mutex_unlock(&s_ecall_variable_mutex);
-
-    for(i =0; i<msd_length;i++)
-    {
-        sprintf(&(lynq_msd_data[i<<1]),"%02x",msd_data[i]);
-    }    
-
-
-    LYINFLOG("lynq_fast_ecall addr is %s",e_call_addr[lynq_ecall_variant]);
-
-    error=lynq_set_common_request(RIL_REQUEST_ECALL_FAST_MAKE_ECALL,4,"%d %d %s %s",ril_ecall_cat, ril_ecall_variant, "null", lynq_msd_data);
-   
-    if(error==0)
-    {   
-        if(waitCallstateChange(270000)==ETIMEDOUT)//4.5 min, dailing 1 min, alerting 1 min, sending msd 30s, redial 2min
-        {
-            pthread_mutex_lock(&s_ecall_variable_mutex);
-            LYERRLOG("lynq_fast_ecall timeout:wait Call state time out!!!");                   
-            is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;            
-            lynqRespWatingEvent();  
-            pthread_mutex_unlock(&s_ecall_variable_mutex);
-            return LYNQ_E_TIME_OUT;
-        }
-        pthread_mutex_lock(&s_ecall_variable_mutex);
-        if(is_ecall_dial == LYNQ_ECALL_DAILING_STATE_STARTED)
-        {
-            /*just dail, no recv answer*/
-            LYERRLOG("lynq_fast_ecall, no answer!");   
-            is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
-            lynqRespWatingEvent();   
-            pthread_mutex_unlock(&s_ecall_variable_mutex);
-            return LYNQ_E_ECALL_DAILING_NO_ANSWER;            
-        }
-        
-        is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
-        lynqRespWatingEvent();        
-        
-        if(g_ecallId != INVALID_ID)
-        {
-            *handle=g_ecallId;         
-            LYINFLOG("lynq_fast_ecall id is %d",g_ecallId);
-            pthread_mutex_unlock(&s_ecall_variable_mutex);
-            return 0;
-        }
-
-        LYERRLOG("lynq_fast_ecall service return fail");
-        pthread_mutex_unlock(&s_ecall_variable_mutex);      
-        return LYNQ_E_INVALID_ID_ANONALY;                       
-    }
-
-    pthread_mutex_lock(&s_ecall_variable_mutex);
-    is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
-    g_lynqEcallVariant = LYNQ_ECALL_VAR_NONE;
-    g_ecallId = INVALID_ID;
-    pthread_mutex_unlock(&s_ecall_variable_mutex);
-
-    return error;
-}
-
-int lynq_set_psap(int enable)
-{
-    return lynq_set_common_request(RIL_REQUEST_ECALL_SET_PSAP,1,"%d",enable);    
-}
-
-int lynq_psap_pull_msd()
-{
-    return lynq_set_common_request(RIL_REQUEST_ECALL_PSAP_PULL_MSD,0,"");  
-}
-
-int lynq_make_ecall(int* handle, LYNQ_ECall_Type type)
-{
-    LYNQ_ECall_Variant lynq_ecall_variant;
-    int error = -1;
-    int lynq_call_id = -1;
-
-    if(handle==NULL)
-    {
-        LYERRLOG("handle is NULL, parameter error  ");
-           return -1;
-    }
-    
-    error=lynq_set_common_request(RIL_REQUEST_ECALL_MAKE_ECALL,1,"%d",type);   
-    
-    if(error==0)
-    {
-        lynq_ecall_variant=lynq_get_lynq_ecall_variant_from_lynq_type(type);
-      
-        lynq_call_id = addAddr(e_call_addr[lynq_ecall_variant]);
-        isDial = 1;
-        if(waitCallstateChange(10000)==ETIMEDOUT)//10000ms
-        {
-            error = LYNQ_E_TIME_OUT;
-            LYERRLOG("timeout:wait Call state fail!!!");
-            return error;
-        }
- 
-        *handle = lynq_call_id;
-    }
-
-    return error;
-}
-
-
-int lynq_set_msd(int* handle, const unsigned char *msd_data, int msd_length)
-{
-    char lynq_msd_data[MSD_MAX_LENGTH*2+1]={0};
-    unsigned int i;
-
-    if(handle==NULL || ((*handle) >= LYNQ_CALL_MAX) || msd_length > MSD_MAX_LENGTH || msd_length <= 0 || msd_data ==NULL)
-    {
-        LYERRLOG("lynq_set_msd handle is NULL or *handle %d is greater or equeal to %d or msd_length %d is greater than %d or msd_data %s is NULL, parameter error",*handle,LYNQ_CALL_MAX,msd_length,MSD_MAX_LENGTH, msd_data);
-        return -1;
-    }    
-
-    for(i=0; i<msd_length;i++)
-    {
-        sprintf(&(lynq_msd_data[i<<1]),"%02x",msd_data[i]);
-    }   
-
-    LYINFLOG("lynq_set_msd ");
-
-    return lynq_set_common_request(RIL_REQUEST_ECALL_SET_MSD,2,"%d %s",*handle,lynq_msd_data);
-}
-
-int lynq_set_ivs(int enable)
-{
-#ifdef ECALL_SUPPORT
-    if(enable<0)
-    {
-       if(enable >-100)
-       {
-           lynq_set_common_request(RIL_REQUEST_ECALL_SET_IVS,1,"%d",enable);
-       }
-       else  if(enable== -1000)
-       {
-           print_ecall_info();
-       } 
-       else
-       {
-           g_ecall_whether_preempt= ((-100-enable) & 0x11);           
-       }
-       return 0;
-    }
 #endif
-
-    return lynq_set_common_request(RIL_REQUEST_ECALL_SET_IVS,1,"%d",enable);    
-}
-
-int lynq_reset_ivs()
-{
-     return lynq_set_common_request(RIL_REQUEST_ECALL_RESET_IVS,0,"");
-}
-
-int lynq_ivs_push_msd()
-{
-    return lynq_set_common_request(RIL_REQUEST_ECALL_IVS_PUSH_MSD,0,"");    
-}
-
-int wait_ecall_event()
-{
-    int ret = 0;
-    pthread_mutex_lock(&s_incoming_e_call_mutex);
-    ret = pthread_cond_wait(&s_incoming_e_call_cond,&s_incoming_e_call_mutex);
-    pthread_mutex_unlock(&s_incoming_e_call_mutex); 
-    return ret;
-}
-
-int lynq_wait_ecall_indication(int* handle, LYNQ_ECall_Indication *eCall_Indication)
-{
-    wait_ecall_event();
-    *handle = g_lynqIncomingEcallId;
-    *eCall_Indication = g_lynqIncomingEcallIndication;  
-    LYINFLOG("lynq_wait_ecall_indication handle %d, Ind id: %d", *handle, *eCall_Indication);
-    return 0;
-}
-
-#endif
-
-/*Audio Path setting begin*/
-/*sub function*/
-void lynq_set_rtp_mixer_ctrl(int enable_rtp)
-{
-    char cmd[256];
-    LYINFLOG("set_rtp_mixer_ctrl %d", enable_rtp);
-    if(enable_rtp)
-    {
-        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on\" %d", 0);
-        system(cmd);
-        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"M2M_Speech_on\" %d", 1);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH1 DL2_CH1\" %d", 1);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH2 DL2_CH2\" %d", 1);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH1 PCM_2_CAP_CH1\" %d", 1);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH2 PCM_2_CAP_CH1\" %d", 1);
-        system(cmd);    
-    }
-    else 
-    {
-        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on\" %d", 1);
-        system(cmd);
-        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"M2M_Speech_on\" %d", 0);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH1 DL2_CH1\" %d", 0);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH2 DL2_CH2\" %d", 0);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH1 PCM_2_CAP_CH1\" %d", 0);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH2 PCM_2_CAP_CH1\" %d", 0);
-        system(cmd);    
-    }    
-}
-
-void* lynq_start_rtp_cmd(void *arg)
-{
-    if(g_lynq_call_init_flag == 0)
-    {
-        return -1;
-    }
-    int* rtp_mode= (int*) arg;
-    char cmd[384];
-	char vlan_para_string[sizeof(RTP_VLAN_INFO_FORMAT)+MAX_VLAN_INFO_LENGTH-2/*sizeof "%s"*/]={0};
-    LYINFLOG("lynq_start_rtp_cmd: rtp_mode is %d",(*rtp_mode));    
-    if ((*rtp_mode) == RTP_CLIENT)
-    {
-        sprintf(cmd,RTP_FROM_CMD, \
-            g_rtp_client_info.port,g_rtp_client_info.clockrate,g_rtp_client_info.channels, \
-            g_rtp_client_info.latency);            
-    //  LYINFLOG("start from rtp play: cmd is %s",cmd);    
-        system(cmd);
-    }
-    else if ((*rtp_mode) == RTP_SERVER)
-    {
-        if(strlen(g_rtp_server_info.vlan_info)>0)
-        {
-           sprintf(vlan_para_string,RTP_VLAN_INFO_FORMAT,g_rtp_server_info.vlan_info);
-        }
-        sprintf(cmd,RTP_TO_CMD,   \
-        g_rtp_server_info.ip,vlan_para_string,g_rtp_server_info.port); 
-    //  LYINFLOG("start to rtp play: cmd is %s",cmd);
-        system(cmd);    
-    }
-    return NULL;
-}
-
-int lynq_start_rtp_thread(int rtp_mode)
-{
-    int ret;
-    pthread_attr_t attr;
-    static int start_mode[RTP_MODE_MAX]={0,1};  
-
-    pthread_attr_init(&attr);
-    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-    ret = pthread_create(&(g_rtp_thread[rtp_mode]),&attr,lynq_start_rtp_cmd,&(start_mode[rtp_mode]));
-    if(ret != 0)
-    {
-        g_rtp_thread_valid[rtp_mode]=0;
-        LYERRLOG("rtp create %d pthread error, ret is %d",rtp_mode, ret);
-        return ret;
-    }
-    g_rtp_thread_valid[rtp_mode]=1;
-    return 0;
-}
-
-/*set*/
-int lynq_set_voice_audio_mode(const LYNQ_Audio_Mode audio_mode)
-{
-    if(g_lynq_call_init_flag == 0)
-    {
-        return -1;
-    }
-    int ret;
-    int i;
-    
-    if(audio_mode==AUDIO_MODE_RTP)
-    {
-        lynq_set_rtp_mixer_ctrl(1);
-        for(i=0;i<RTP_MODE_MAX;i++)
-        {
-            if(!g_rtp_thread_valid[i])
-            {
-                if(lynq_start_rtp_thread(i)!= 0)
-                {
-                    LYERRLOG("start rtp %d fail",i);
-                    break;
-                }
-                else 
-                {
-                    LYINFLOG("start rtp %d suc",i);        
-                }
-            }
-            else 
-            {
-                LYERRLOG("rtp %d needn't start",i); 
-            }
-        }
-        if(i!= RTP_MODE_MAX)            
-        {
-            LYERRLOG("start rtp whole fail");
-            lynq_set_voice_audio_mode(AUDIO_MODE_CODEC);
-            return 1;
-        }
-        LYINFLOG("start rtp whole suc");          
-        return 0;
-    }
-    else if(audio_mode==AUDIO_MODE_CODEC)
-    {
-         for(i=0;i<RTP_MODE_MAX;i++)
-        {
-            if(g_rtp_thread_valid[i]) 
-            {
-                 ret = pthread_cancel(g_rtp_thread[i]);
-                 LYINFLOG("pthread cancel rtp %d ret = %d",i,ret);
-                 ret = pthread_join(g_rtp_thread[i],NULL);
-                 LYINFLOG("pthread join rtp %d ret = %d",i,ret);
-                 g_rtp_thread_valid[i] = 0;
-            }
-            else 
-            {
-                LYINFLOG("rtp %d needn't stop",i);
-            }
-        }
-        lynq_set_rtp_mixer_ctrl(0);     
-        LYINFLOG("stop rtp suc");
-    }
-    return 0;     
-}
-int lynq_set_remote_rtp_ip(const char* ip, const int ip_length)
-{
-    if (NULL == ip)
-    {
-        LYERRLOG("ip is NULL!!!");
-        return -1;
-    }
-    if ((ip_length < strlen(ip)+1) || (ip_length > MAX_IP_LENGTH))
-    {
-        LYERRLOG("incoming ip length error %d", ip_length);
-        return -1;
-    }
-
-    bzero(g_rtp_server_info.ip,MAX_IP_LENGTH);
-    strcpy(g_rtp_server_info.ip,ip);
-
-    LYINFLOG("lynq_set_remote_rtp_ip suc: ip is %s, length is %d", ip,ip_length);
-    
-    return 0;
-}
-int lynq_set_vlan_info(const char* vlan_info, const int vlan_info_length)
-{
-    if (NULL == vlan_info)
-    {
-        LYERRLOG("vlan_info is NULL!!!");
-        return -1;
-    }
-    
-    if ((vlan_info_length < strlen(vlan_info)+1) || (vlan_info_length > MAX_VLAN_INFO_LENGTH))
-    {
-        LYERRLOG("incoming vlan_info error, vlan info length %d", vlan_info_length);
-        return -1;
-    }    
-
-    
-    bzero(g_rtp_server_info.vlan_info,MAX_VLAN_INFO_LENGTH);
-    strcpy(g_rtp_server_info.vlan_info,vlan_info);
-   
-    LYINFLOG("lynq_set_vlan_info suc: vlan is %s, length is %d", vlan_info,vlan_info_length);
-    
-    return 0;  
-}
-int lynq_set_rtp_port(const LYNQ_Rtp_Mode rtp_mode, const int port)
-{  
-    if (port < 0)
-    {
-        LYERRLOG("invalid port number %d", port);
-        return -1;
-    }
-    if (rtp_mode == 0)
-    {
-        g_rtp_client_info.port = port;
-    }
-    else if (rtp_mode == 1)
-    {
-        g_rtp_server_info.port = port;
-    }
-    LYINFLOG("lynq_set_rtp_port suc: LYNQ_Rtp_Mode is %d, port is %d", rtp_mode, port);
-    return 0;
-}
-int lynq_set_rtp_param(const int clock_rate,const int channels,const int latency) //only for client mode
-{
-    g_rtp_client_info.clockrate = clock_rate;
-    g_rtp_client_info.channels = channels;
-    g_rtp_client_info.latency = latency;
-    LYINFLOG("lynq_set_rtp_param suc: clockrate is %d, channels is %d, latency is %d", clock_rate, channels, latency);
-    return 0;
-}
-/*get*/
-LYNQ_Audio_Mode lynq_get_voice_audio_mode()
-{
-    if(g_lynq_call_init_flag == 0)
-    {
-        return -1;
-    }
-    if(g_rtp_thread_valid[0])
-    {
-        return AUDIO_MODE_RTP;
-    }
-    else 
-    {
-        return AUDIO_MODE_CODEC;
+        default:
+            break;
     }
 }
-int lynq_get_remote_rtp_ip(char* ip, const int ip_length)
-{
-    if(g_lynq_call_init_flag == 0)
-    {
-        return -1;
-    }
-    if(ip==NULL)
-    {
-        LYERRLOG("ip is NULL");
-        return 1;
-    }    
-
-    if(ip_length < strlen(g_rtp_server_info.ip)+1)
-    {
-        LYERRLOG("ip lenght %d is shorter than saved ip length %d",ip_length,strlen(g_rtp_server_info.ip)+1);
-        return 1;
-    }
-    bzero(ip,ip_length);
-    strcpy(ip,g_rtp_server_info.ip);
-    return 0;
-}
-int lynq_get_vlan_info(char* vlan_info, const int vlan_info_length)
-{
-    if(vlan_info==NULL) 
-    {
-        LYERRLOG("vlan info is NULL");
-        return -1;
-    }
-
-    if(vlan_info_length < strlen(g_rtp_server_info.vlan_info)+1)
-    {
-        LYERRLOG("vlan info length %d is shorter than saved vlan info length %d",vlan_info_length,strlen(g_rtp_server_info.vlan_info)+1);
-        return -1;
-    }
-   
-    bzero(vlan_info,vlan_info_length);
-    strcpy(vlan_info,g_rtp_server_info.vlan_info);        
-   
-    return 0;  
-}
-int lynq_get_rtp_port(const LYNQ_Rtp_Mode rtp_mode, int* port)
-{
-    if(g_lynq_call_init_flag == 0)
-    {
-        return -1;
-    }
-    if(port==NULL)
-    {
-        return 1;
-    }   
-    if (rtp_mode == 0)
-    {
-        *port = g_rtp_client_info.port;
-    }
-    else if (rtp_mode == 1)
-    {
-        *port = g_rtp_server_info.port;
-    }
-    return 0;
-}
-int lynq_get_rtp_param(int* clock_rate, int* channels, int* latency)//only for client mode
-{
-    if(g_lynq_call_init_flag == 0)
-    {
-        return -1;
-    }
-    if(clock_rate == NULL || channels ==NULL || latency ==NULL)
-    {
-        LYERRLOG("input parameter is NULL");
-        return 1;
-    }
-
-    *clock_rate = g_rtp_client_info.clockrate;
-    *channels = g_rtp_client_info.channels ;
-    *latency = g_rtp_client_info.latency;
-
-    return 0;
-}
-/*Audio Path setting end*/
 
 #if 0
 int main(int argc,char **argv)