diff --git a/src/lynq/lib/liblynq-data/lynq_data.cpp b/src/lynq/lib/liblynq-data/lynq_data.cpp
index 5473fb2..c04a373 100755
--- a/src/lynq/lib/liblynq-data/lynq_data.cpp
+++ b/src/lynq/lib/liblynq-data/lynq_data.cpp
@@ -15,8 +15,10 @@
 #include <sys/time.h>
 #include <include/lynq_uci.h>
 #include <errno.h>
+#include <vector>
+#include "lynq_data_urc.h"
+
 #define LYNQ_SERVICE_PORT 8088
-#define LYNQ_URC_SERVICE_PORT 8086
 #define LYNQ_REC_BUF 8192
 #define LYNQ_REQUEST_PARAM_BUF 8192
 #define LYQN_SEDN_BUF 1024*8+sizeof(int)*3
@@ -24,9 +26,6 @@
 
 #define LYNQ_DATA_UCI_BUF 258
 
-
-
-
 using ::android::Parcel;
 typedef struct{
     int uToken;
@@ -56,16 +55,19 @@
 
 int lynq_client_sockfd = 0;
 int Global_uToken = 0;
-bool data_urc_recive_status = 1;
+
 int lynq_data_call_change_id = -1;
 pthread_t lynq_data_tid =-1;
 static pthread_mutex_t s_data_call_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t s_data_call_state_change_cond = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t s_pdn_change_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t s_pdn_change_cond = PTHREAD_COND_INITIALIZER;
+
 static pthread_mutex_t s_lynq_apn_change_mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t s_lynq_apn_change_cond = PTHREAD_COND_INITIALIZER;
 
+pthread_t data_list_urc_vector_tid = -1;
+int data_urc_vector_status = 0;
+static pthread_mutex_t s_lynq_urc_vector_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_lynq_urc_vector_cond = PTHREAD_COND_INITIALIZER;
 /**g_lynq_data_sendto_mutex
 * @brief mark data send request mutex
 */
@@ -82,6 +84,8 @@
 */
 char g_lynq_apn_result[1024] = {};
 
+static std::vector<int> s_data_urc_wait_list;
+
 typedef struct
 {
     char apn[LYNQ_APN_MAX_LEN];
@@ -93,16 +97,7 @@
 lynq_apn_t lynq_apn_table[LYNQ_APN_CHANNEL_MAX] = {};
 lynq_data_call_response_v11_t lynq_data_call_lists[LYNQ_APN_CHANNEL_MAX] = {};
 int lynq_data_call = 0;
-int millli_sleep_with_restart(int millisecond)
-{
-    int left = millisecond*1000;
-    while (left > 0) 
-    { 
-        left = usleep(left);
-    }
 
-    return 0;
-}
 int getLynqApnID(char apnType[])
 {
     int ret = 0;
@@ -115,6 +110,7 @@
     }
     return -1;
 }
+
 void updateApnTable(lynq_apn_t *apn_table,char apn[],char apntype[],char ifaceName[])
 {
     LYDBGLOG("[updateApnTable] apn:%s,apntype:%s,ifaceName:%s",apn,apntype,ifaceName);
@@ -130,6 +126,7 @@
     apn_table->hasUsed = 1;
     return;
 }
+
 void cleanOnceApnTable(int apnId)
 {
     LYDBGLOG("apn id:%d",apnId);
@@ -207,9 +204,9 @@
 int waitPdnChange()
 {
     int ret = 0;
-    pthread_mutex_lock(&s_pdn_change_mutex);
-    ret = pthread_cond_wait(&s_pdn_change_cond,&s_pdn_change_mutex);
-    pthread_mutex_unlock(&s_pdn_change_mutex);
+    pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+    ret = pthread_cond_wait(&s_lynq_urc_vector_cond,&s_lynq_urc_vector_mutex);
+    pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
     return ret;
 }
 int waitDataCallstateChange(int mtime)
@@ -238,9 +235,9 @@
 }
 void sendSignalPdnChange()
 {
-    pthread_mutex_lock(&s_pdn_change_mutex);
-    pthread_cond_signal(&s_pdn_change_cond);
-    pthread_mutex_unlock(&s_pdn_change_mutex);
+    pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+    pthread_cond_signal(&s_lynq_urc_vector_cond);
+    pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
     return;
 }
 
@@ -301,7 +298,6 @@
     return strndup16to8(s16, stringlen);
 }
 
-
 /*Warren add for T800 platform 2021/11/19 start*/
 int lynq_socket_client_start()
 {
@@ -335,144 +331,146 @@
     }
     return 0;
 }
-void *thread_urc_recv(void *parg)
+
+bool is_support_urc(int urc_id)
 {
-    int socket_fd = (int64_t)parg;
-    int len=0;
-    socklen_t addr_len=0;
-    uint8_t *dataLength = NULL;
-    char urc_data[LYNQ_REC_BUF];
+    switch(urc_id)
+    {
+        case LYNQ_URC_DATA_CALL_STATUS_IND:
+
+        case LYNQ_URC_MODIFY_APNDB:
+        case LYNQ_URC_RESET_APNDB:
+            return true;                
+        default:
+            return false;
+    }    
+}
+
+void urc_msg_process(Parcel *p)
+{
+    int len;
+    int resp_type;
+    int urcid;
+    int slot_id;
+
+    int pdnState = 0;
     char apn[LYNQ_APN_MAX_LEN];
     char apnType[LYNQ_APN_TYPE_MAX_LEN];
-    int pdnState = 0;
     char ifaceName[LYNQ_IFACE_NAME_MAX_LEN];
-    int slot_id = -1;
-    int resp_type = -1;
-    int urcid = -1;
     char *urc_msg = NULL;
-    Parcel *p = NULL;
-    struct sockaddr_in dest_addr;
-    LYINFLOG("thread_urc_recv in running....\n");
-    while(data_urc_recive_status)
+
+    int size = p->dataSize();
+    p->readInt32(&resp_type);
+    p->readInt32(&urcid);
+    p->readInt32(&slot_id);
+    LYINFLOG("data lib recv urc:resp_type=%d,urcid=%d,slot_id=%d,size=%d\n",resp_type,urcid,slot_id,size);
+    switch(urcid)
     {
-        bzero(urc_data,LYNQ_REC_BUF);
-        //get data msg
-        len = recvfrom(socket_fd,urc_data,LYNQ_REC_BUF,0,(struct sockaddr *)&dest_addr,&addr_len);
-        if(len <= 0)
-        {
-            perror("thread_urc_recv step2 fail:");
-            millli_sleep_with_restart(1);
-            break;
-        }
-        LYDBGLOG("=====>urc data len<=====:%d\n",len);
-        p = new Parcel();
-        if(p==NULL)
-        {
-            RLOGD("new parcel failure!!!");
-            break;
-        }
-        p->setData((uint8_t *)urc_data,len); // p.setData((uint8_t *) buffer, buflen);
-        p->setDataPosition(0);
-        if(p->dataAvail() > 0)
-        {
-            p->readInt32(&resp_type);
-            p->readInt32(&urcid);
-            p->readInt32(&slot_id);
-            //LYDBGLOG("*******Warren test*******:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
-            switch (urcid)
+        case LYNQ_URC_DATA_CALL_STATUS_IND:
+            p->readInt32(&pdnState);
+            bzero(apn,LYNQ_APN_MAX_LEN);
+            bzero(apnType,LYNQ_APN_TYPE_MAX_LEN);
+            bzero(ifaceName,LYNQ_IFACE_NAME_MAX_LEN);
+            if(pdnState!=4)//PDN_DISCONNECTED
             {
-                case 9003://LYNQ_URC_DATA_CALL_STATUS_IND
-                {
-                    LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
-                    p->readInt32(&pdnState);
-                    bzero(apn,LYNQ_APN_MAX_LEN);
-                    bzero(apnType,LYNQ_APN_TYPE_MAX_LEN);
-                    bzero(ifaceName,LYNQ_IFACE_NAME_MAX_LEN);
-                    if(pdnState!=4)//PDN_DISCONNECTED
-                    {
-                        urc_msg = strdupReadString_p(p);
-                        int len = strlen(urc_msg);
-                        if(len < LYNQ_APN_MAX_LEN-1)
-                        {
-                            memcpy(apn,urc_msg,len+1);
-                        }
-                        urc_msg = strdupReadString_p(p);
-                        len = strlen(urc_msg);
-                        if(len < LYNQ_APN_TYPE_MAX_LEN-1)
-                        {
-                            memcpy(apnType,urc_msg,len+1);
-                        }
-                        urc_msg = strdupReadString_p(p);
-                        len = strlen(urc_msg);
-                        if(len < LYNQ_IFACE_NAME_MAX_LEN-1)
-                        {
-                            memcpy(ifaceName,urc_msg,strlen(urc_msg)+1);
-                        }
-                        //sendSignalDataCallStateChange();
-                        int apnId = getLynqApnID(apnType);
-                        if(apnId >= 0)
-                        {
-                            if(lynq_apn_table[apnId].hasTimeout==1)
-                            {
-                                LYERRLOG("apn:%s has time out",lynq_apn_table[apnId].apn);
-                                lynq_deactive_data_call(&apnId);
-                                continue;
-                            }
-                            updateApnTable(&lynq_apn_table[apnId], apn,apnType,ifaceName);
-                        }
-                        lynq_data_call_change_id = apnId;
-                        sendSignalPdnChange();
-                        LYDBGLOG("data call state:%d",lynq_data_call);
-                        if(lynq_data_call==1)
-                        {
-                            sendSignalDataCallStateChange();
-                            lynq_data_call = 0;
-                        }
-                    }
-                    else
-                    {
-                        urc_msg = strdupReadString_p(p);
-                        len = strlen(urc_msg);
-                        if(len < LYNQ_APN_TYPE_MAX_LEN-1)
-                        {
-                            memcpy(apnType,urc_msg,len+1);
-                        }
-                        LYDBGLOG("[data thread_urc_recv] apntype:%s",apnType);
-                        int apnId = getLynqApnID(apnType);
-                        if(apnId >= 0)
-                        {
-                            lynq_data_call_change_id = apnId;
-                            bzero(lynq_apn_table[apnId].apnType,LYNQ_APN_TYPE_MAX_LEN);//async clean
-                        }
-                        sendSignalPdnChange();
-                        LYDBGLOG("data call state:%d",lynq_data_call);
-                        if(lynq_data_call==1)
-                        {
-                            sendSignalDataCallStateChange();
-                            lynq_data_call = 0;
-                        }
-                    }
-                    break;
-                }
-            case 9004:
-            {
-                LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
                 urc_msg = strdupReadString_p(p);
-                if (NULL == urc_msg)
+                int len = strlen(urc_msg);
+                if(len < LYNQ_APN_MAX_LEN-1)
                 {
-                    LYERRLOG("error apn msg");
+                    memcpy(apn,urc_msg,len+1);
                 }
+                urc_msg = strdupReadString_p(p);
+                len = strlen(urc_msg);
+                if(len < LYNQ_APN_TYPE_MAX_LEN-1)
+                {
+                    memcpy(apnType,urc_msg,len+1);
+                }
+                urc_msg = strdupReadString_p(p);
+                len = strlen(urc_msg);
+                if(len < LYNQ_IFACE_NAME_MAX_LEN-1)
+                {
+                    memcpy(ifaceName,urc_msg,strlen(urc_msg)+1);
+                }
+                //sendSignalDataCallStateChange();
+                int apnId = getLynqApnID(apnType);
+                if(apnId >= 0)
+                {
+                    if(lynq_apn_table[apnId].hasTimeout==1)
+                    {
+                        LYERRLOG("apn:%s has time out,deacive this apn",lynq_apn_table[apnId].apn);
+                        if (NULL != lynq_apn_table[apnId].apn && NULL != NULL != lynq_apn_table[apnId].apnType)
+                        {
+                            LYERRLOG("deactive this time out APN");
+                            lynq_deactive_data_call(&apnId);
+                        }
+                        else 
+                        {
+                            LYERRLOG("this table is invalid");
+                        }
+                        break;
+                    }
+                    //updateApnTable(&lynq_apn_table[apnId],apn,apnType,ifaceName);
+                }
+                /*To be completed*/
                 else
                 {
-                    bzero(g_lynq_apn_result, 1024);
-                    strcpy(g_lynq_apn_result, urc_msg);
-                    sendSignalApnChange();
+                    LYERRLOG("invalid apnId");
+                    break;
                 }
-                break;
+                pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+                s_data_urc_wait_list.push_back(apnId);
+                pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+                lynq_data_call_change_id = apnId;
+                //sendSignalPdnChange();
+                LYDBGLOG("data call state:%d",lynq_data_call);
+                if(lynq_data_call==1)
+                {
+                    sendSignalDataCallStateChange();
+                    lynq_data_call = 0;
+                }
             }
-            case 9005:
+            else
             {
-                LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d\n",resp_type,urcid,slot_id);
+                urc_msg = strdupReadString_p(p);
+                len = strlen(urc_msg);
+                if(len < LYNQ_APN_TYPE_MAX_LEN-1)
+                {
+                    memcpy(apnType,urc_msg,len+1);
+                }
+                LYDBGLOG("[data thread_urc_recv] apntype:%s",apnType);
+                int apnId = getLynqApnID(apnType);
+                if(apnId >= 0)
+                {
+                    lynq_data_call_change_id = apnId;
+                    bzero(lynq_apn_table[apnId].apnType,LYNQ_APN_TYPE_MAX_LEN);//async clean
+                }
+                pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+                s_data_urc_wait_list.push_back(apnId);
+                pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+                //sendSignalPdnChange();
+                LYDBGLOG("data call state:%d",lynq_data_call);
+                if(lynq_data_call==1)
+                {
+                    sendSignalDataCallStateChange();
+                    lynq_data_call = 0;
+                }
+            }
+            break;
+        case LYNQ_URC_MODIFY_APNDB:
+            urc_msg = strdupReadString_p(p);
+            if (NULL == urc_msg)
+            {
+                LYERRLOG("error apn msg");
+            }
+            else
+            {
+                bzero(g_lynq_apn_result, 1024);
+                strcpy(g_lynq_apn_result, urc_msg);
+                sendSignalApnChange();
+            }
+            break;
+        case LYNQ_URC_RESET_APNDB:
+            {
                 urc_msg = strdupReadString_p(p);
                 if (NULL == urc_msg)
                 {
@@ -485,56 +483,75 @@
                     sendSignalApnChange();
                 }
             }
-                default:
-                    break;
-            }
-        }
-        delete p;
-        p = NULL;
+        default:
+            break;
     }
-    close(socket_fd);
+    
 }
-int lynq_socket_urc_start()
+
+void cleanup_urc_vector_mutex(void *arg)
 {
-    int socket_fd=0;
-    int rt=0;
-    int len=0;
-    int on=1;
-    struct sockaddr_in urc_local_addr;
-    pthread_attr_t attr;
-    socket_fd = socket(AF_INET,SOCK_DGRAM,0);
-    if(socket_fd < 0)
+    pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+}
+
+void *thread_urc_vector()
+{
+    pthread_cleanup_push(cleanup_urc_vector_mutex, NULL);
+    while (data_urc_vector_status)
     {
-        perror("creaet socket for udp fail");
+        while (!s_data_urc_wait_list.empty())
+        {
+            sendSignalPdnChange();
+            usleep(10);
+        }
+    }
+    pthread_cleanup_pop(0);
+}
+
+void cancel_urc_vector_signal_thread()
+{
+    int ret;
+
+    pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+    if (data_list_urc_vector_tid != -1)
+    {
+        ret = pthread_cancel(data_list_urc_vector_tid);
+        LYDBGLOG("pthread cancel ret = %d",ret);
+    }
+    pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+
+    if (data_list_urc_vector_tid != -1)
+    {
+        ret = pthread_join(data_list_urc_vector_tid,NULL);
+        LYDBGLOG("pthread join ret = %d",ret);
+        data_list_urc_vector_tid = -1;
+    }
+    pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+    s_data_urc_wait_list.clear();
+    pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+    data_urc_vector_status = 0;
+}
+
+int create_urc_vector_signal_thread()
+{
+    int ret;
+
+    data_urc_vector_status = 1;
+    pthread_mutex_init(&s_lynq_urc_vector_mutex,NULL);
+    ret = pthread_create(&data_list_urc_vector_tid,NULL,thread_urc_vector,NULL);
+    if (ret < 0)
+    {
+        LYERRLOG("urc vector signal pthread create error");
+        lynq_deinit_data_urc_thread();
+        data_urc_vector_status = 0;
         return -1;
     }
-    urc_local_addr.sin_family = AF_INET;
-    urc_local_addr.sin_port = htons(LYNQ_URC_SERVICE_PORT);
-    urc_local_addr.sin_addr.s_addr = htons(INADDR_ANY);
-    /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
-    rt = setsockopt(socket_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
-    if(rt<0)
-    {
-        perror("SO_REUSEADDR fail\n");
-        return -1;
-    }
-    rt = bind(socket_fd ,(struct sockaddr*)&urc_local_addr, sizeof(urc_local_addr));
-    if (rt == -1)
-    {
-        perror("bind failed");
-        return -1;
-    }
-    pthread_attr_init(&attr);
-    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-    rt = pthread_create(&lynq_data_tid,&attr,thread_urc_recv,(void *)socket_fd);
-    if(rt < 0)
-    {
-        LYERRLOG("urc loop failure!!!\n");
-        return -1;
-    }
-    LYDBGLOG("urc loop success!!!\n");
+    pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+    s_data_urc_wait_list.clear();
+    pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
     return 0;
 }
+
 int lynq_init_data(int uToken)
 {
     if (g_lynq_data_init_flag == 1)
@@ -545,7 +562,6 @@
     g_lynq_data_init_flag = 1;
     int result = 0;
     Global_uToken = uToken;
-    data_urc_recive_status = 1;
     LYLOGSET(LOG_INFO);
     LYLOGEINIT(USER_LOG_TAG);
     result = lynq_socket_client_start();
@@ -555,7 +571,14 @@
         LYERRLOG("init socket client fail!!!");
         return -1;
     }
-    result = lynq_socket_urc_start();
+    result = lynq_init_data_urc_thread();
+    if(result!=0)
+    {
+        LYERRLOG("init socket urc fail!!!");
+        return -1;
+    }
+
+    result = create_urc_vector_signal_thread();
     if(result!=0)
     {
         LYERRLOG("init socket urc fail!!!");
@@ -586,14 +609,12 @@
     {
         close(lynq_client_sockfd);
     }
-    data_urc_recive_status = 0;
-    if (lynq_data_tid > 0)
+    ret = lynq_deinit_data_urc_thread();
     {
-        ret = pthread_cancel(lynq_data_tid);
-        LYDBGLOG("pthread cancel ret = %d",ret);
-        ret = pthread_join(lynq_data_tid,NULL);
-        LYDBGLOG("pthread join ret = %d",ret);
+        LYERRLOG("lynq_deinit_data_urc_thread fail");
+        return ret;
     }
+    cancel_urc_vector_signal_thread();
     return 0;
 }
 int lynq_setup_data_call(int *handle)
@@ -604,7 +625,6 @@
     int request = -1;
     int slot_id = -1;
     int error = -1;
-    char iface = NULL;
     int lynq_data_call_id = 0;
     if(handle==NULL)
     {
@@ -642,6 +662,7 @@
     }
     return error;
 }
+
 int lynq_deactive_data_call(int *handle)
 {
     Parcel p;
@@ -700,7 +721,6 @@
     int request = -1;
     int slot_id = -1;
     int error = -1;
-    char iface = NULL;
     int lynq_data_call_id = -1;
     char *argv[10] = {};
     if(handle==NULL||apn==NULL||apnType==NULL)
@@ -769,7 +789,7 @@
     lynq_data_call = 1;
     if(error==0)
     {
-        if(waitDataCallstateChange(20000)==ETIMEDOUT)//20s
+        if(waitDataCallstateChange(60000)==ETIMEDOUT)//60s
         {
             error = LYNQ_E_TIME_OUT;
             LYERRLOG("timeout:wait data Call state fail!!!");
@@ -823,7 +843,6 @@
     int error = -1;
     int version =0;
     int num = 0;
-    int temp_int =0;
     char *temp_char = NULL;
     if(dataCallList==NULL)
     {
@@ -924,8 +943,16 @@
 }
 int lynq_wait_data_call_state_change(int *handle)
 {
+    
+    std::vector<int>::iterator iter;
     waitPdnChange();
-    *handle = lynq_data_call_change_id;
+
+    pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+    iter = s_data_urc_wait_list.begin();
+    handle = (*iter);
+    s_data_urc_wait_list.erase(iter);
+    pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+    
     LYINFLOG("lynq data call id:%d",lynq_data_call_change_id);
     return 0;
 }
@@ -1214,7 +1241,6 @@
     }
     lynq_client_t client;
     char argc[512];
-    char recvline[LYNQ_REC_BUF];
     int res = 0;
     Parcel p;
     if (cmd == 0) // insert apn db