diff --git a/src/lynq/lib/liblynq-call/LICENSE b/src/lynq/lib/liblynq-call/LICENSE
index 77f59ed..605b7ea 100755
--- a/src/lynq/lib/liblynq-call/LICENSE
+++ b/src/lynq/lib/liblynq-call/LICENSE
@@ -1,31 +1,31 @@
 Copyright Statement:
 
-This software/firmware and related documentation ("MediaTek Software") are
+This software/firmware and related documentation ("MobileTek Software") are
 protected under relevant copyright laws. The information contained herein is
-confidential and proprietary to MediaTek Inc. and/or its licensors. Without
-the prior written permission of MediaTek inc. and/or its licensors, any
-reproduction, modification, use or disclosure of MediaTek Software, and
+confidential and proprietary to MobileTek Inc. and/or its licensors. Without
+the prior written permission of MobileTek inc. and/or its licensors, any
+reproduction, modification, use or disclosure of MobileTek Software, and
 information contained herein, in whole or in part, shall be strictly
 prohibited.
 
-MediaTek Inc. (C) 2015. All rights reserved.
+MobileTek Inc. (C) 2015. All rights reserved.
 
 BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
-THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
-RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
-ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
+THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MobileTek SOFTWARE")
+RECEIVED FROM MobileTek AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
+ON AN "AS-IS" BASIS ONLY. MobileTek EXPRESSLY DISCLAIMS ANY AND ALL
 WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
 WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
-NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
+NONINFRINGEMENT. NEITHER DOES MobileTek PROVIDE ANY WARRANTY WHATSOEVER WITH
 RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
-INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
+INCORPORATED IN, OR SUPPLIED WITH THE MobileTek SOFTWARE, AND RECEIVER AGREES
 TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
 RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
-OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
-SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
+OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MobileTek
+SOFTWARE. MobileTek SHALL ALSO NOT BE RESPONSIBLE FOR ANY MobileTek SOFTWARE
 RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
-STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
-ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
-RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
-MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
-CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
+STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MobileTek'S
+ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MobileTek SOFTWARE
+RELEASED HEREUNDER WILL BE, AT MobileTek'S OPTION, TO REVISE OR REPLACE THE
+MobileTek SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
+CHARGE PAID BY RECEIVER TO MobileTek FOR SUCH MobileTek SOFTWARE AT ISSUE.
diff --git a/src/lynq/lib/liblynq-call/lynq_call.cpp b/src/lynq/lib/liblynq-call/lynq_call.cpp
index 0270aa1..2d49208 100755
--- a/src/lynq/lib/liblynq-call/lynq_call.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_call.cpp
@@ -751,7 +751,7 @@
 
     g_module_Global_uToken = utoken; 
 
-    int ret = lynq_urc_socket_start();
+    int ret = lynq_start_all_urc_socket_thread();
     if(ret != RESULT_OK)
     {
         LYERRLOG("init socket urc fail!!!");
@@ -759,11 +759,11 @@
         return LYNQ_E_INNER_ERROR;
     }
 
-    ret = lynq_server_socket_start();
+    ret = lynq_start_all_rc_socket_thread();
     if(ret !=RESULT_OK)
     {
         LYERRLOG("init socket client fail!!!");
-        lynq_close_urc_thread();
+        lynq_close_all_urc_socket_thread();
         g_module_init_flag = MODULE_CLOSED;
         return LYNQ_E_INNER_ERROR;
     }
@@ -773,8 +773,8 @@
     if(ret != RESULT_OK)
     {
         LYERRLOG("lynq_start_call_list_loop fail!!!");
-        lynq_close_urc_thread();
-        lynq_close_rc_thread();
+        lynq_close_all_urc_socket_thread();
+        lynq_close_all_rc_socket_thread();
         g_module_init_flag = MODULE_CLOSED;
         return LYNQ_E_INNER_ERROR;
     }      
@@ -795,8 +795,8 @@
     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_close_all_urc_socket_thread();
+    lynq_close_all_rc_socket_thread();    
     lynq_stop_call_list_loop();
     g_module_init_flag = MODULE_CLOSED;
     return 0;
@@ -1389,16 +1389,36 @@
 }
 /*audio end*/
 
+
+
+bool is_support_urc(int urc_id)
+{
+    switch(urc_id)
+    {
+        case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED:
+        case RIL_UNSOL_CALL_RING:
+        case RIL_UNSOL_RINGBACK_TONE:
+        case RIL_UNSOL_CALL_INFO_INDICATION:
+#ifdef ECALL_SUPPORT
+        case RIL_UNSOL_ECALL_INDICATIONS://9502        
+#endif
+            return true;                
+        default:
+            return false;
+    }    
+}
+
 void urc_msg_process(Parcel *p)
 { 
     int resp_type;
     int urcid;
     int slot_id;
-    
+
+    int size=p->dataSize();
     p->readInt32(&resp_type);
     p->readInt32(&urcid);
     p->readInt32(&slot_id);
-    LYINFLOG("urc id = %d, slot_id = %d",urcid,slot_id);
+    LYINFLOG("%s urc id = %d, slot_id = %d, size is %d, msg is %s",__func__, urcid,slot_id,size,requestToString(urcid));
     switch (urcid)
     {
         case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED://1001
diff --git a/src/lynq/lib/liblynq-call/lynq_module_common.h b/src/lynq/lib/liblynq-call/lynq_module_common.h
index 9e70d6c..604493c 100755
--- a/src/lynq/lib/liblynq-call/lynq_module_common.h
+++ b/src/lynq/lib/liblynq-call/lynq_module_common.h
@@ -28,6 +28,8 @@
 #define LYNQ_REQUEST_RECORD  (LYNQ_REQUEST_VENDOR_BASE +11)
 #define LYNQ_REQUEST_OOS_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +12)
 #define LYNQ_REQUEST_OOS_DEEP_SLEEP_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +13)
+#define LYNQ_REQUEST_CHANGE_SCREEN_STATE (LYNQ_REQUEST_VENDOR_BASE + 14)/*jb.qi add for two sim suspend 2022/9/19*/
+#define LYNQ_REQUEST_CHANGE_RADIO (LYNQ_REQUEST_VENDOR_BASE + 15)
 /*the same with lynq_interface.h end*/
 
 typedef enum{
diff --git a/src/lynq/lib/liblynq-call/lynq_module_socket.cpp b/src/lynq/lib/liblynq-call/lynq_module_socket.cpp
index 71862a8..a6b3dac 100755
--- a/src/lynq/lib/liblynq-call/lynq_module_socket.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_module_socket.cpp
@@ -15,6 +15,7 @@
 #include "lynq_module_common.h"
 #include "lynq_module_socket.h"
 #include "liblog/lynq_deflog.h"
+#include "lynq_shm.h"
 
 #define LYNQ_SERVICE_PORT 8088
 #define LYNQ_ADDRESS "127.0.0.1"
@@ -40,6 +41,11 @@
     int error;
 }lynq_resp_t;
 
+typedef struct{
+    int resp_type;
+    int urcid;   
+}lynq_head_t;
+
 lynq_client_t client_t;
 lynq_resp_t response;
 
@@ -67,6 +73,21 @@
 const int waitResponse(int token,int time_out);
 /*hq add for set waiting time 2022/09/13 end*/
 
+/*hq add for urc process asynchronous 2022/12/26 begin*/
+static pthread_mutex_t s_ProcessUrcMsgBlockMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_WaitProcessUrcMsgCond = PTHREAD_COND_INITIALIZER;
+
+#define BLOCK_PROCESS_URC_MSG_INIT() pthread_mutex_init(&s_ProcessUrcMsgBlockMutex,NULL)
+#define BLOCK_PROCESS_URC_MSG_LOCK() pthread_mutex_lock(&s_ProcessUrcMsgBlockMutex)
+#define BLOCK_PROCESS_URC_MSG_UNLOCK() pthread_mutex_unlock(&s_ProcessUrcMsgBlockMutex)
+#define BLOCK_WAIT_PROCESS_URC_MSG() pthread_cond_wait(&s_WaitProcessUrcMsgCond, &s_ProcessUrcMsgBlockMutex)
+#define BLOCK_WAKEUP_PROCESS_URC_MSG() pthread_cond_broadcast(&s_WaitProcessUrcMsgCond)
+static std::list<Parcel*> s_recv_urc_parcel_list;
+void *thread_urc_process(void *p);
+pthread_t module_urc_process_tid = -1;
+int module_urc_process_status = 1;
+/*hq add for urc process asynchronous 2022/12/26 end*/
+
 int g_module_Global_uToken = 0;
 int g_wait_time=5;
 
@@ -118,7 +139,7 @@
     std::list<Parcel*>::iterator iter;
     int cnt=0;
     
-	gettimeofday(&now,NULL);
+    gettimeofday(&now,NULL);
     timeout.tv_sec = now.tv_sec+time_out; //timeout is 1min
     timeout.tv_nsec = now.tv_usec*1000;
 
@@ -268,6 +289,292 @@
     return ret;    
 }
 
+/*hq add for urc broadcase optimisson 2023/01/03 begin*/
+#define SHM_BUFFER_INDEX_OFFSET 1
+#define SHM_BUFFER_SIZE_OFFSET 16
+#define SHM_BUFFER_INDEX_MASK 0x0000007F
+#define SHM_BUFFER_SIZE_MASK 0x0000FFFF
+
+bool urc_data_is_in_shm_data(int responseType,int& level, int& index, int& size)
+{
+    int shm_index=((responseType>>SHM_BUFFER_INDEX_OFFSET)&SHM_BUFFER_INDEX_MASK);
+    if (shm_index>0)
+    {
+        index=shm_index-1;    
+        size=((responseType>>SHM_BUFFER_SIZE_OFFSET)&SHM_BUFFER_SIZE_MASK);
+        if(size>=sizeof(int32_t)*3 && get_shem_buffer_level(size,&level))
+        {
+            LYINFLOG("urc_data_is_in_shm_data level is %d, index is %d size is %d",level,index,size);
+            return true;                            
+        }        
+    }
+    LYINFLOG("urc_data_is_in_shm_data return false, responseType is %d",responseType);
+    return false;
+}
+/*hq add for urc broadcase optimisson 2023/01/03 end*/
+
+void *thread_urc_recv(void *p)
+{
+    Parcel *urc_p =NULL;
+    char urc_data[LYNQ_REC_BUF];    
+    int res = 0;
+    lynq_head_t* phead;
+   
+    LYINFLOG("urc recv thread is running");
+    while(module_urc_status)
+    {
+        bzero(urc_data,LYNQ_REC_BUF);
+        res = recvfrom(module_urc_sock_fd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&module_urc_addr_serv,(socklen_t*)&module_len_urc_addr_serv);
+        if(res<sizeof(int32_t)*2)
+        {
+            LYERRLOG("thread_urc_recv step2 fail: res is %d",res);
+            continue;
+        }
+
+        phead=(lynq_head_t*) urc_data;
+        if(is_support_urc(phead->urcid)==false)
+        {
+            continue;
+        }
+        urc_p = new Parcel();
+        if(urc_p == NULL)
+        {
+            LYERRLOG("new parcel failure!!!");
+            continue;
+        }
+        int level,index,size;
+        if(urc_data_is_in_shm_data(phead->resp_type,level,index,size))
+        {
+            urc_p->setData((uint8_t *)get_shem_buffer(level,index),size); // p.setData((uint8_t *) buffer, buflen);                        
+        }
+        else if(res>=sizeof(int32_t)*3)
+        {
+            urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);            
+        }
+        else 
+        {    
+               LYERRLOG("res %d error!!!", res);
+            delete urc_p;
+            urc_p = NULL;
+            continue;
+        }
+        urc_p->setDataPosition(0);
+        if(urc_p->dataAvail()>0)
+        {
+            BLOCK_PROCESS_URC_MSG_LOCK();
+            s_recv_urc_parcel_list.push_back(urc_p);            
+            BLOCK_WAKEUP_PROCESS_URC_MSG();
+            BLOCK_PROCESS_URC_MSG_UNLOCK();
+        }
+        else 
+        {
+            delete urc_p;
+            urc_p = NULL;
+        }        
+    }
+    LYINFLOG("urc recv thread ended");
+    return NULL;
+}
+
+void cleanup_urc_process_mutex(void *arg)
+{
+    BLOCK_PROCESS_URC_MSG_UNLOCK();
+}
+
+void *thread_urc_process(void *p)
+{
+    Parcel *urc_p =NULL;
+    std::list<Parcel*>::iterator iter;
+   
+    LYINFLOG("urc process thread is running");
+    pthread_cleanup_push(cleanup_urc_process_mutex, NULL); // thread cleanup handler
+    while(module_urc_process_status)
+    {
+        BLOCK_PROCESS_URC_MSG_LOCK();
+        while(s_recv_urc_parcel_list.empty())
+        {
+            BLOCK_WAIT_PROCESS_URC_MSG();
+        }  
+        iter=s_recv_urc_parcel_list.begin();
+        urc_p=(*iter);
+        s_recv_urc_parcel_list.erase(iter);
+        BLOCK_PROCESS_URC_MSG_UNLOCK();             
+        urc_p->setDataPosition(0);
+        if(urc_p->dataAvail()>0)
+        {          
+            pthread_mutex_lock(&s_urc_mutex);
+            urc_msg_process(urc_p);            
+            pthread_mutex_unlock(&s_urc_mutex);
+        }
+        delete urc_p;
+        urc_p = NULL;
+    }
+    pthread_cleanup_pop(0);
+    LYINFLOG("urc process thread ended");
+    return NULL;
+}
+
+void lynq_close_urc_rev_thread()
+{
+    int ret;
+
+    BLOCK_PROCESS_URC_MSG_LOCK();  //just cancel urc process tid when recv from
+    module_urc_status = 0;    
+    if(module_urc_tid!=-1)
+    {
+        ret = pthread_cancel(module_urc_tid);
+        LYINFLOG("pthread cancel urc rev ret = %d",ret);            
+    }
+    BLOCK_PROCESS_URC_MSG_UNLOCK();
+    if(module_urc_tid != -1)
+    {
+        ret = pthread_join(module_urc_tid,NULL);
+        LYINFLOG("pthread join urc tid ret = %d",ret);
+        module_urc_tid =-1;
+    }       
+}
+
+void lynq_close_urc_process_thread()
+{
+    int ret;
+    BLOCK_PROCESS_URC_MSG_LOCK();  //just cancel urc process tid when not process urc msg in list 
+    pthread_mutex_lock(&s_urc_mutex); //just cancel urc process tid when not process urg msg avoid mutual lock for tid may call pthread_cond_wait
+    module_urc_process_status = 0;    
+    if(module_urc_process_tid!=-1)
+    {
+        ret = pthread_cancel(module_urc_process_tid);
+        LYINFLOG("pthread cancel urc process ret = %d",ret);            
+    }
+    pthread_mutex_unlock(&s_urc_mutex);
+    BLOCK_PROCESS_URC_MSG_UNLOCK();
+    if(module_urc_process_tid != -1)
+    {
+        ret = pthread_join(module_urc_process_tid,NULL);
+        LYINFLOG("pthread join urc process tid ret = %d",ret);
+        module_urc_process_tid =-1;
+    }
+}
+
+int lynq_setup_urc_socket()
+{
+    int on = 1;
+    int ret = 0;
+    module_len_urc_addr_serv = sizeof(sockaddr_in);
+    module_urc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (module_urc_sock_fd <0){
+        LYERRLOG("urc socket error");
+        return RESULT_ERROR;  
+    }
+    module_urc_addr_serv.sin_family = AF_INET;
+    module_urc_addr_serv.sin_port = htons(LYNQ_URC_SERVICE_PORT);
+    module_urc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_URC_ADDRESS);
+    /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
+    ret = setsockopt(module_urc_sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
+    if(ret <0)
+    {
+        LYERRLOG("urc socket set error");
+        close(module_urc_sock_fd);
+        module_urc_sock_fd =-1;
+        return RESULT_ERROR;  
+    }
+    ret = bind(module_urc_sock_fd ,(struct sockaddr*)&module_urc_addr_serv, sizeof(module_urc_addr_serv));
+    if(ret <0)
+    {
+        LYERRLOG("urc socket bind error");
+        close(module_urc_sock_fd);
+        module_urc_sock_fd =-1;
+        return RESULT_ERROR;  
+    }
+    return RESULT_OK;
+}
+
+void lynq_close_urc_socket()
+{
+    if (module_urc_sock_fd >= 0)
+    {
+        close(module_urc_sock_fd);
+        module_urc_sock_fd =-1;
+    }  
+}
+
+int lynq_start_all_urc_socket_thread()
+{  
+    
+    if(ril_init_mem()!=0)
+    {
+        LYERRLOG("ril_init_mem fail");        
+        return RESULT_ERROR;
+    }
+
+    int ret= lynq_setup_urc_socket();
+    if(ret!=RESULT_OK)
+    {
+        LYERRLOG("call lynq_setup_urc_socket fail");
+        ril_deinit_mem();
+        return RESULT_ERROR;
+    }
+    
+    BLOCK_PROCESS_URC_MSG_INIT();
+    BLOCK_PROCESS_URC_MSG_LOCK();    
+    std::list<Parcel*>::iterator iter;
+    for(iter=s_recv_urc_parcel_list.begin();iter!=s_recv_urc_parcel_list.end();++iter)
+    {
+        delete (*iter);        
+    }
+    s_recv_urc_parcel_list.clear(); 
+    BLOCK_PROCESS_URC_MSG_UNLOCK(); 
+    
+    pthread_mutex_init(&s_urc_mutex, NULL);    
+    
+    module_urc_status = 1;
+  //  pthread_attr_init(&attr);
+  //  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+    ret = pthread_create(&module_urc_tid,/*&attr*/NULL,thread_urc_recv,NULL);
+    if(ret <0)
+    {
+        LYERRLOG("urc recv pthread create error");
+        module_urc_status = 0;
+        lynq_close_urc_socket();
+        ril_deinit_mem();
+        return RESULT_ERROR;  
+    }
+
+    module_urc_process_status = 1;
+    ret = pthread_create(&module_urc_process_tid,/*&attr*/NULL,thread_urc_process,NULL);
+    if(ret <0)
+    {
+        LYERRLOG("urc process pthread create error");
+        module_urc_process_status = 0;
+        lynq_close_urc_socket();
+        lynq_close_urc_rev_thread();
+        ril_deinit_mem();
+        return RESULT_ERROR;  
+    }
+    
+    LYINFLOG("urc start success");
+    
+    return RESULT_OK;  
+}
+
+void lynq_close_all_urc_socket_thread()
+{
+ 
+    lynq_close_urc_rev_thread();
+    lynq_close_urc_socket();
+    lynq_close_urc_process_thread();        
+    
+    BLOCK_PROCESS_URC_MSG_LOCK();    
+    std::list<Parcel*>::iterator iter;
+    for(iter=s_recv_urc_parcel_list.begin();iter!=s_recv_urc_parcel_list.end();++iter)
+    {
+        delete (*iter);        
+    }
+    s_recv_urc_parcel_list.clear(); 
+    BLOCK_PROCESS_URC_MSG_UNLOCK(); 
+    
+    ril_deinit_mem();    
+}
+
 /**@ a thread just for recv\buffer solicited msg's response and notice waiting thread
 * @param p [IN]: no meaning
 * @return
@@ -347,44 +654,7 @@
     return NULL;
 }
 
-void *thread_urc_recv(void *p)
-{
-    Parcel *urc_p =NULL;
-    char urc_data[LYNQ_REC_BUF];    
-    int res = 0;
-   
-    LYINFLOG("urc thread is running");
-    while(module_urc_status)
-    {
-        bzero(urc_data,LYNQ_REC_BUF);
-        res = recvfrom(module_urc_sock_fd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&module_urc_addr_serv,(socklen_t*)&module_len_urc_addr_serv);
-        if(res<=0)
-        {
-            LYERRLOG("thread_urc_recv step2 fail:");
-            break;
-        }
-        urc_p = new Parcel();
-        if(urc_p == NULL)
-        {
-            LYERRLOG("new parcel failure!!!");
-            break;
-        }
-        urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
-        urc_p->setDataPosition(0);
-        if(urc_p->dataAvail()>0)
-        {
-            pthread_mutex_lock(&s_urc_mutex);
-            urc_msg_process(urc_p);            
-            pthread_mutex_unlock(&s_urc_mutex);
-        }
-        delete urc_p;
-        urc_p = NULL;
-    }
-    LYINFLOG("urc thread ended");
-    return NULL;
-}
-
-int lynq_server_socket_start()
+int lynq_start_all_rc_socket_thread()
 {
     module_rc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
     if(module_rc_sock_fd < 0)
@@ -434,87 +704,12 @@
     return RESULT_OK;  
 }
 
-int lynq_urc_socket_start()
-{
-//    pthread_t tid;
-//    pthread_attr_t attr;
-    int on = 1;
-    int ret = 0;
-    module_len_urc_addr_serv = sizeof(sockaddr_in);
-    module_urc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
-    if (module_urc_sock_fd <0){
-        LYERRLOG("urc socket error");
-        return RESULT_ERROR;  
-    }
-    module_urc_addr_serv.sin_family = AF_INET;
-    module_urc_addr_serv.sin_port = htons(LYNQ_URC_SERVICE_PORT);
-    module_urc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_URC_ADDRESS);
-    /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
-    ret = setsockopt(module_urc_sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
-    if(ret <0)
-    {
-        LYERRLOG("urc socket set error");
-        close(module_urc_sock_fd);
-        module_urc_sock_fd =-1;
-        return RESULT_ERROR;  
-    }
-    ret = bind(module_urc_sock_fd ,(struct sockaddr*)&module_urc_addr_serv, sizeof(module_urc_addr_serv));
-    if(ret <0)
-    {
-        LYERRLOG("urc socket bind error");
-        close(module_urc_sock_fd);
-        module_urc_sock_fd =-1;
-        return RESULT_ERROR;  
-    }
-
-    module_urc_status = 1;
-  //  pthread_attr_init(&attr);
-  //  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-    ret = pthread_create(&module_urc_tid,/*&attr*/NULL,thread_urc_recv,NULL);
-    if(ret <0)
-    {
-        LYERRLOG("urc pthread create error");
-        module_urc_status = 0;
-        close(module_urc_sock_fd);
-        module_urc_sock_fd =-1;
-        return RESULT_ERROR;  
-    }
-    LYINFLOG("urc start success");
-    
-    return RESULT_OK;  
-}
-
-void lynq_close_urc_thread()
-{
-    int ret;
-
-    pthread_mutex_lock(&s_urc_mutex); //just cancel urc tid when recvfrom avoid mutual lock for tid may call pthread_cond_wait
-    module_urc_status = 0;    
-    if(module_urc_tid!=-1)
-    {
-        ret = pthread_cancel(module_urc_tid);
-        LYINFLOG("pthread cancel urc ret = %d",ret);            
-    }
-    pthread_mutex_unlock(&s_urc_mutex);
-    if(module_urc_tid != -1)
-    {
-        ret = pthread_join(module_urc_tid,NULL);
-        LYINFLOG("pthread join urc tid ret = %d",ret);
-        module_urc_tid =-1;
-    }
-    if (module_urc_sock_fd > 0)
-    {
-        close(module_urc_sock_fd);
-        module_urc_sock_fd =-1;
-    }  
-}
-
-void lynq_close_rc_thread()
+void lynq_close_all_rc_socket_thread()
 {
     int ret;
     BLOCK_RECV_MSG_LOCK(); 
-    module_rc_status = 0;
-    BLOCK_WAKEUP_RECV_MSG();    
+    module_rc_status = 0;    
+    BLOCK_WAKEUP_RECV_MSG(); 
     if(module_rc_tid != -1)
     {
         ret = pthread_cancel(module_rc_tid);
@@ -523,11 +718,11 @@
     BLOCK_RECV_MSG_UNLOCK();     
     if(module_rc_tid != -1)
     {
-        ret = pthread_join(module_rc_tid,NULL);      
+        ret = pthread_join(module_rc_tid,NULL);
         module_rc_tid =-1;
-        LYINFLOG("pthread join rc tid ret = %d",ret);       
-    }
-    
+        LYINFLOG("pthread join rc tid ret = %d",ret);
+        
+    }    
 
     if (module_rc_sock_fd > 0)
     {
@@ -545,3 +740,273 @@
     BLOCK_RECV_MSG_UNLOCK(); 
 }
 
+const char * requestToString(int request) 
+{
+    /*
+     cat libs/telephony/ril_commands.h \
+     | egrep "^ *{RIL_" \
+     | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/'
+    
+    
+     cat libs/telephony/ril_unsol_commands.h \
+     | egrep "^ *{RIL_" \
+     | sed -re 's/\{RIL_([^,]+),([^}]+).+/case RIL_\1: return "\1";/'
+    
+    */
+    switch(request) {
+        case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS";
+        case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN";
+        case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK";
+        case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2";
+        case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2";
+        case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN";
+        case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2";
+        case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION";
+        case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS";
+        case RIL_REQUEST_DIAL: return "DIAL";
+        case RIL_REQUEST_GET_IMSI: return "GET_IMSI";
+        case RIL_REQUEST_HANGUP: return "HANGUP";
+        case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND";
+        case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND";
+        case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "SWITCH_WAITING_OR_HOLDING_AND_ACTIVE";
+        case RIL_REQUEST_CONFERENCE: return "CONFERENCE";
+        case RIL_REQUEST_UDUB: return "UDUB";
+        case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE";
+        case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH";
+        case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE";
+        case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE";
+        case RIL_REQUEST_OPERATOR: return "OPERATOR";
+        case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER";
+        case RIL_REQUEST_DTMF: return "DTMF";
+        case RIL_REQUEST_SEND_SMS: return "SEND_SMS";
+        case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE";
+        case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL";
+        case RIL_REQUEST_SIM_IO: return "SIM_IO";
+        case RIL_REQUEST_SEND_USSD: return "SEND_USSD";
+        case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD";
+        case RIL_REQUEST_GET_CLIR: return "GET_CLIR";
+        case RIL_REQUEST_SET_CLIR: return "SET_CLIR";
+        case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS";
+        case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD";
+        case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING";
+        case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING";
+        case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE";
+        case RIL_REQUEST_GET_IMEI: return "GET_IMEI";
+        case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV";
+        case RIL_REQUEST_ANSWER: return "ANSWER";
+        case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL";
+        case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK";
+        case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK";
+        case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD";
+        case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE";
+        case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC";
+        case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL";
+        case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS ";
+        case RIL_REQUEST_DTMF_START: return "DTMF_START";
+        case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP";
+        case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION";
+        case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION";
+        case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "SET_PREFERRED_NETWORK_TYPE";
+        case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "GET_PREFERRED_NETWORK_TYPE";
+        case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "GET_NEIGHBORING_CELL_IDS";
+        case RIL_REQUEST_SET_MUTE: return "SET_MUTE";
+        case RIL_REQUEST_GET_MUTE: return "GET_MUTE";
+        case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP";
+        case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE";
+        case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST";
+        case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO";
+        case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW";
+        case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS";
+        case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE";
+        case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE";
+        case RIL_REQUEST_STK_GET_PROFILE: return "STK_GET_PROFILE";
+        case RIL_REQUEST_STK_SET_PROFILE: return "STK_SET_PROFILE";
+        case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "STK_SEND_ENVELOPE_COMMAND";
+        case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "STK_SEND_TERMINAL_RESPONSE";
+        case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
+        case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE";
+        case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "EXPLICIT_CALL_TRANSFER";
+        case RIL_REQUEST_SET_LOCATION_UPDATES: return "SET_LOCATION_UPDATES";
+        case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:return"CDMA_SET_SUBSCRIPTION_SOURCE";
+        case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:return"CDMA_SET_ROAMING_PREFERENCE";
+        case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:return"CDMA_QUERY_ROAMING_PREFERENCE";
+        case RIL_REQUEST_SET_TTY_MODE:return"SET_TTY_MODE";
+        case RIL_REQUEST_QUERY_TTY_MODE:return"QUERY_TTY_MODE";
+        case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE";
+        case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE";
+        case RIL_REQUEST_CDMA_FLASH:return"CDMA_FLASH";
+        case RIL_REQUEST_CDMA_BURST_DTMF:return"CDMA_BURST_DTMF";
+        case RIL_REQUEST_CDMA_SEND_SMS:return"CDMA_SEND_SMS";
+        case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE:return"CDMA_SMS_ACKNOWLEDGE";
+        case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:return"GSM_GET_BROADCAST_SMS_CONFIG";
+        case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:return"GSM_SET_BROADCAST_SMS_CONFIG";
+        case RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION:return "GSM_SMS_BROADCAST_ACTIVATION";
+        case RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG:return "CDMA_GET_BROADCAST_SMS_CONFIG";
+        case RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG:return "CDMA_SET_BROADCAST_SMS_CONFIG";
+        case RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION:return "CDMA_SMS_BROADCAST_ACTIVATION";
+        case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return"CDMA_VALIDATE_AND_WRITE_AKEY";
+        case RIL_REQUEST_CDMA_SUBSCRIPTION: return"CDMA_SUBSCRIPTION";
+        case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "CDMA_WRITE_SMS_TO_RUIM";
+        case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "CDMA_DELETE_SMS_ON_RUIM";
+        case RIL_REQUEST_DEVICE_IDENTITY: return "DEVICE_IDENTITY";
+        case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "EXIT_EMERGENCY_CALLBACK_MODE";
+        case RIL_REQUEST_GET_SMSC_ADDRESS: return "GET_SMSC_ADDRESS";
+        case RIL_REQUEST_SET_SMSC_ADDRESS: return "SET_SMSC_ADDRESS";
+        case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "REPORT_SMS_MEMORY_STATUS";
+        case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "REPORT_STK_SERVICE_IS_RUNNING";
+        case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "CDMA_GET_SUBSCRIPTION_SOURCE";
+        case RIL_REQUEST_ISIM_AUTHENTICATION: return "ISIM_AUTHENTICATION";
+        case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU";
+        case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS";
+        case RIL_REQUEST_VOICE_RADIO_TECH: return "VOICE_RADIO_TECH";
+        case RIL_REQUEST_GET_CELL_INFO_LIST: return"GET_CELL_INFO_LIST";
+        case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: return"SET_UNSOL_CELL_INFO_LIST_RATE";
+        case RIL_REQUEST_SET_INITIAL_ATTACH_APN: return "RIL_REQUEST_SET_INITIAL_ATTACH_APN";
+        case RIL_REQUEST_IMS_REGISTRATION_STATE: return "IMS_REGISTRATION_STATE";
+        case RIL_REQUEST_IMS_SEND_SMS: return "IMS_SEND_SMS";
+        case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: return "SIM_TRANSMIT_APDU_BASIC";
+        case RIL_REQUEST_SIM_OPEN_CHANNEL: return "SIM_OPEN_CHANNEL";
+        case RIL_REQUEST_SIM_CLOSE_CHANNEL: return "SIM_CLOSE_CHANNEL";
+        case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: return "SIM_TRANSMIT_APDU_CHANNEL";
+        case RIL_REQUEST_GET_RADIO_CAPABILITY: return "RIL_REQUEST_GET_RADIO_CAPABILITY";
+        case RIL_REQUEST_SET_RADIO_CAPABILITY: return "RIL_REQUEST_SET_RADIO_CAPABILITY";
+        case RIL_REQUEST_SET_UICC_SUBSCRIPTION: return "SET_UICC_SUBSCRIPTION";
+        case RIL_REQUEST_ALLOW_DATA: return "ALLOW_DATA";
+        case RIL_REQUEST_GET_HARDWARE_CONFIG: return "GET_HARDWARE_CONFIG";
+        case RIL_REQUEST_SIM_AUTHENTICATION: return "SIM_AUTHENTICATION";
+        case RIL_REQUEST_GET_DC_RT_INFO: return "GET_DC_RT_INFO";
+        case RIL_REQUEST_SET_DC_RT_INFO_RATE: return "SET_DC_RT_INFO_RATE";
+        case RIL_REQUEST_SET_DATA_PROFILE: return "SET_DATA_PROFILE";
+        case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
+        case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
+        case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
+        case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
+        case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS";
+        case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
+        case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
+        case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD";
+        case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
+        case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
+        case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
+        case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
+        case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
+        case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
+        case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
+        case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL";
+        case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
+        case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
+        case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
+        case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
+        case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS";
+        case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_NEW_BROADCAST_SMS";
+        case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL";
+        case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED";
+        case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE";
+        case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING";
+        case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS";
+        case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC";
+        case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW";
+        case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE";
+        case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE";
+        case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED";
+        case RIL_UNSOL_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED";
+        case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE";
+        case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED";
+        case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED";
+        case RIL_UNSOL_CELL_INFO_LIST: return "UNSOL_CELL_INFO_LIST";
+        case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: return "RESPONSE_IMS_NETWORK_STATE_CHANGED";
+        case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: return "UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED";
+        case RIL_UNSOL_SRVCC_STATE_NOTIFY: return "UNSOL_SRVCC_STATE_NOTIFY";
+        case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "HARDWARE_CONFIG_CHANGED";
+        case RIL_UNSOL_DC_RT_INFO_CHANGED: return "UNSOL_DC_RT_INFO_CHANGED";
+        case RIL_REQUEST_SHUTDOWN: return "SHUTDOWN";
+        case RIL_UNSOL_RADIO_CAPABILITY: return "RIL_UNSOL_RADIO_CAPABILITY";
+        case RIL_REQUEST_SET_TRM: return "RIL_REQUEST_SET_TRM";
+        case RIL_REQUEST_SET_IMS_ENABLE:return "RIL_REQUEST_SET_IMS_ENABLE";
+        case RIL_REQUEST_SET_AUDIO_PATH: return "SET_AUDIO_PATH";
+        case RIL_REQUEST_HANGUP_ALL: return "HANGUP_ALL";
+        case RIL_REQUEST_FORCE_RELEASE_CALL: return "FORCE_RELEASE_CALL";
+        case RIL_REQUEST_EMERGENCY_DIAL: return "RIL_REQUEST_EMERGENCY_DIAL";
+        case RIL_REQUEST_SET_ECC_SERVICE_CATEGORY: return "RIL_REQUEST_SET_ECC_SERVICE_CATEGORY";
+        case RIL_REQUEST_SET_ECC_LIST: return "RIL_REQUEST_SET_ECC_LIST";
+        case RIL_REQUEST_AT_COMMAND_WITH_PROXY: return "AT_COMMAND_WITH_PROXY";
+        case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION: return "RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION";
+        case RIL_REQUEST_SET_CLIP: return "RIL_REQUEST_SET_CLIP";
+        case RIL_REQUEST_GET_COLP: return "RIL_REQUEST_GET_COLP";
+        case RIL_REQUEST_SET_COLP: return "RIL_REQUEST_SET_COLP";
+        case RIL_REQUEST_GET_COLR: return "RIL_REQUEST_GET_COLR";
+        case RIL_REQUEST_ADD_IMS_CONFERENCE_CALL_MEMBER: return "ADD_IMS_CONFERENCE_CALL_MEMBER";
+        case RIL_REQUEST_REMOVE_IMS_CONFERENCE_CALL_MEMBER: return "REMOVE_IMS_CONFERENCE_CALL_MEMBER";
+        case RIL_REQUEST_CONFERENCE_DIAL: return "CONFERENCE_DIAL";
+        case RIL_REQUEST_DIAL_WITH_SIP_URI: return "DIAL_WITH_SIP_URI";
+        case RIL_REQUEST_HOLD_CALL: return "HOLD_CALL";
+        case RIL_REQUEST_RESUME_CALL: return "RESUME_CALL";
+        case RIL_UNSOL_ECONF_SRVCC_INDICATION : return "ECONF_SRVCC_INDICATION";
+        case RIL_UNSOL_ECONF_RESULT_INDICATION : return "ECONF_RESULT_INDICATION";
+        case RIL_UNSOL_MAL_AT_INFO : return "UNSOL_MAL_AT_INFO";
+        case RIL_REQUEST_MODEM_POWEROFF: return "MODEM_POWEROFF";
+        case RIL_REQUEST_MODEM_POWERON: return "MODEM_POWERON";
+        case RIL_REQUEST_WRITE_SMS_TO_SIM: return "WRITE_SMS_TO_SIM";
+        case RIL_REQUEST_QUERY_ICCID: return "RIL_REQUEST_QUERY_ICCID";
+        case RIL_UNSOL_TX_POWER: return "RIL_UNSOL_TX_POWER";
+        case RIL_UNSOL_NETWORK_INFO: return "RIL_UNSOL_NETWORK_INFO";
+        case RIL_REQUEST_DELETE_SMS_ON_SIM: return "DELETE_SMS_ON_SIM";
+        case RIL_REQUEST_SET_IMSCFG: return "RIL_REQUEST_SET_IMSCFG";
+#ifdef ECALL_SUPPORT
+        case RIL_REQUEST_ECALL_FAST_MAKE_ECALL: return "ECALL_FAST_MAKE_ECALL";
+        case RIL_REQUEST_ECALL_SET_IVS: return "RIL_REQUEST_ECALL_SET_IVS";
+        case RIL_REQUEST_ECALL_SET_PSAP: return "RIL_REQUEST_ECALL_SET_PSAP";
+        case RIL_REQUEST_ECALL_MAKE_ECALL: return "RIL_REQUEST_ECALL_MAKE_ECALL";
+        case RIL_REQUEST_ECALL_IVS_PUSH_MSD: return "RIL_REQUEST_ECALL_IVS_PUSH_MSD";
+        case RIL_REQUEST_ECALL_PSAP_PULL_MSD: return "RIL_REQUEST_ECALL_PSAP_PULL_MSD";
+        case RIL_UNSOL_ECALL_MSDHACK : return "ECALL_MSDHACK";
+        case RIL_REQUEST_ECALL_SET_MSD: return "RIL_REQUEST_ECALL_SET_MSD";
+        case RIL_REQUEST_ECALL_CTRL_SEQUENCE: return "ECALL_SET_CTRL_SEQUENCE";
+        case RIL_UNSOL_ECALL_INDICATIONS : return "ECALL_INDICATIONS";
+        case RIL_REQUEST_ECALL_RESET_IVS: return "RIL_REQUEST_ECALL_RESET_IVS";
+        case RIL_REQUEST_ECALL_SET_PRI: return "RIL_REQUEST_ECALL_SET_PRI";
+        case RIL_REQUEST_ECALL_SET_TEST_NUM: return "RIL_REQUEST_ECALL_SET_TEST_NUM";
+        case RIL_REQUEST_ECALL_SET_RECONF_NUM: return "RIL_REQUEST_ECALL_SET_RECONF_NUM";
+        case RIL_REQUEST_SYNC_DATA_SETTINGS_TO_MD: return "RIL_REQUEST_SYNC_DATA_SETTINGS_TO_MD";
+        case RIL_REQUEST_ECALL_SET_NAD_DEREGISTRATION_TIME: return "RIL_REQUEST_ECALL_SET_NAD_DEREGISTRATION_TIME";
+        case RIL_REQUEST_ECALL_SET_REGISTRATION_STATE: return "RIL_REQUEST_ECALL_SET_REGISTRATION_STATE";
+#endif /*ECALL_SUPPORT*/
+#ifdef KEEP_ALIVE
+        case RIL_REQUEST_START_KEEPALIVE_PRO: return "RIL_REQUEST_START_KEEPALIVE_PRO";
+        case RIL_REQUEST_STOP_KEEPALIVE_PRO: return "RIL_REQUEST_STOP_KEEPALIVE_PRO";
+        case RIL_UNSOL_KEEPALIVE_STATUS_PRO: return "RIL_UNSOL_KEEPALIVE_STATUS_PRO";
+#endif /*KEEP_ALIVE*/
+        case RIL_REQUEST_SEND_USSI: return "SEND_USSI";
+        case RIL_REQUEST_CANCEL_USSI: return "CANCEL_USSI";
+        case RIL_REQUEST_GET_SMS_SIM_MEM_STATUS: return "GET_SMS_SIM_MEM_STATUS";
+        case RIL_UNSOL_SIP_CALL_PROGRESS_INDICATOR: return "RIL_UNSOL_SIP_CALL_PROGRESS_INDICATOR";
+        case RIL_REQUEST_REPORT_AIRPLANE_MODE: return "RIL_REQUEST_REPORT_AIRPLANE_MODE";
+        case RIL_REQUEST_SET_ECC_NUM: return "RIL_REQUEST_SET_ECC_NUM";
+        case RIL_REQUEST_GET_ECC_NUM: return "RIL_REQUEST_GET_ECC_NUM";
+        case RIL_UNSOL_ECC_NUM: return "RIL_UNSOL_ECC_NUM";
+        case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS_WITH_ACT: return "RIL_REQUEST_QUERY_AVAILABLE_NETWORKS_WITH_ACT";
+        case RIL_REQUEST_GSM_GET_BROADCAST_LANGUAGE: return "RIL_REQUEST_GSM_GET_BROADCAST_LANGUAGE";
+        case RIL_REQUEST_GSM_SET_BROADCAST_LANGUAGE: return "RIL_REQUEST_GSM_SET_BROADCAST_LANGUAGE";
+        case RIL_UNSOL_CALL_INFO_INDICATION: return "RIL_UNSOL_CALL_INFO_INDICATION";
+        case RIL_REQUEST_MODIFY_APN: return "RIL_REQUEST_MODIFY_APN";
+        case RIL_REQUEST_RESET_APN: return "RIL_REQUEST_RESET_APN";
+        case RIL_REQUEST_QUERY_SIM_RETRY_COUNT: return "RIL_REQUEST_QUERY_SIM_RETRY_COUNT";
+        case RIL_REQUEST_QUERY_EID: return "RIL_REQUEST_QUERY_EID";
+        case LYNQ_REQUEST_SET_DTMF_VOLUME: return "RIL_REQUEST_SET_DTMF_VOLUME";
+        case LYNQ_REQUEST_SET_SPEECH_VOLUME: return "RIL_REQUEST_SET_SPEECH_VOLUME";
+        case LYNQ_REQUEST_GET_SPEECH_VOLUME: return "RIL_REQUEST_GET_SPEECH_VOLUME";
+        case LYNQ_REQUEST_RECORD: return "RIL_REQUEST_RECORD";
+        /*warren add for t800 ril service 2022/1/22 start*/
+        case LYNQ_REQUEST_WRITE_SMS_TO_MEMORY: return "LYNQ_REQUEST_WRITE_SMS_TO_MEMORY";
+        case LYNQ_REQUEST_READ_SMS_FROM_MEMORY: return "LYNQ_REQUEST_READ_SMS_FROM_MEMORY";
+        case LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY: return "LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY";
+        case LYNQ_REQUEST_LIST_SMS_FROM_MEMORY: return "LYNQ_REQUEST_LIST_SMS_FROM_MEMORY";
+        case LYNQ_REQUEST_SET_DEFAULT_SIM_ALL:return "SET_DEFAULT_SIM_ALL";
+        case LYNQ_REQUEST_CHANGE_SCREEN_STATE:return "LYNQ_REQUEST_CHANGE_SCREEN_STATE";/*jb.qi add for two sim sleep 2022/9/19*/
+        case LYNQ_REQUEST_CHANGE_RADIO:return "LYNQ_REQUEST_CHANGE_RADIO";/*lei add for factory test of sleep 2022/9/19*/
+        /*warren add for t800 ril service 2022/1/22 end*/
+        default: return "<unknown request>";
+    }
+}
+
+
diff --git a/src/lynq/lib/liblynq-call/lynq_module_socket.h b/src/lynq/lib/liblynq-call/lynq_module_socket.h
index 57466f6..41c0d1c 100755
--- a/src/lynq/lib/liblynq-call/lynq_module_socket.h
+++ b/src/lynq/lib/liblynq-call/lynq_module_socket.h
@@ -4,15 +4,18 @@
 using ::android::Parcel;
 
 int lynq_set_test_network(const int test_mode);
-int lynq_send_common_request(Parcel*& p, int time_out, int request_id, int argc, const char* format,...);
-int lynq_server_socket_start();
-int lynq_urc_socket_start();
-void lynq_close_urc_thread();
-void lynq_close_rc_thread();
 
 extern int g_module_Global_uToken;
 extern int g_wait_time;
+int lynq_send_common_request(Parcel*& p, int time_out, int request_id,  int argc, const char* format,...);
+int lynq_start_all_urc_socket_thread();
+void lynq_close_all_urc_socket_thread();
+int lynq_start_all_rc_socket_thread();
+void lynq_close_all_rc_socket_thread();
+
+const char * requestToString(int request);
 
 void urc_msg_process(Parcel *p);
+bool is_support_urc(int urc_id);
 
 #endif
diff --git a/src/lynq/lib/liblynq-call/makefile b/src/lynq/lib/liblynq-call/makefile
index 0e021c5..40415dc 100755
--- a/src/lynq/lib/liblynq-call/makefile
+++ b/src/lynq/lib/liblynq-call/makefile
@@ -23,6 +23,7 @@
   -I$(ROOT)$(includedir)/logger \
   -I$(ROOT)$(includedir)/liblog \
   -I$(ROOT)$(includedir)/vendor-ril \
+  -I$(ROOT)$(includedir)/lynq_shm \
 
 
 LOCAL_LIBS := \
@@ -35,7 +36,7 @@
     -lbinder \
     -lpthread \
     -llynq-log \
-
+    -llynq-shm \
 
 SOURCES = $(wildcard *.cpp)