diff --git a/src/lynq/lib/liblynq-call/lynq_call.cpp b/src/lynq/lib/liblynq-call/lynq_call.cpp
index 0270aa1..d1e2293 100755
--- a/src/lynq/lib/liblynq-call/lynq_call.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_call.cpp
@@ -74,9 +74,9 @@
 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 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 int s_CallId = 0;
+static pthread_mutex_t s_call_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_call_state_change_cond = PTHREAD_COND_INITIALIZER;
 
 static int s_module_call_state =CALL_OFF;
 static int s_call_auto_answer = 0;
@@ -299,6 +299,8 @@
     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++)
@@ -329,15 +331,15 @@
     callList->direction = direction;   
     return;
 }
-int waitIncomingCall()
+
+void wait_call_state()
 {
-    LYINFLOG("wait incming call");
-    int ret = 0;
-    pthread_mutex_lock(&s_incoming_call_mutex);
-    ret = pthread_cond_wait(&s_incoming_call_cond,&s_incoming_call_mutex);
-    pthread_mutex_unlock(&s_incoming_call_mutex);
-    return ret;
+    LYINFLOG("call state changed");
+    pthread_mutex_lock(&s_call_state_change_mutex);
+    pthread_cond_wait(&s_call_state_change_cond,&s_call_state_change_mutex);
+    pthread_mutex_unlock(&s_call_state_change_mutex);
 }
+
 int checkHasCall(char addr[])
 {
     for(int i = 0;i<LYNQ_CALL_MAX;i++)
@@ -384,18 +386,25 @@
     pthread_cond_signal(&call_state_change_cond);
     pthread_mutex_unlock(&call_state_change_mutex);
 }
-void sendSignalIncomingCall()
+void send_call_state_change()
 {
-    LYINFLOG("send incoming call signal");
-    pthread_mutex_lock(&s_incoming_call_mutex);
-    pthread_cond_signal(&s_incoming_call_cond);
-    pthread_mutex_unlock(&s_incoming_call_mutex);
+    LYINFLOG("send call state change");
+    pthread_mutex_lock(&s_call_state_change_mutex);
+    pthread_cond_signal(&s_call_state_change_cond);
+    pthread_mutex_unlock(&s_call_state_change_mutex);
 }
 
 void cleanup_call_list_mutex(void *arg)
 {
     pthread_mutex_unlock(&s_notice_get_call_list_mutex);
 }
+
+void update_end_state(int lynq_call_id)
+{
+    LYINFLOG("update_end_state 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_state = (int)LYNQ_CALL_END;
+}
+
 void *triggerGetCallList(void *parg)
 {
     int ret=0;
@@ -447,8 +456,11 @@
                 }
                 if(call_end == 0)
                 {
-                    LYINFLOG("MT hungup,then clean call info local idx is %d id is %d",i, s_call_lists[i].call_id);
-                    cleanCallList(i);                   
+                    LYINFLOG("MT/MO hungup,then clean call info local idx is %d id is %d",i, s_call_lists[i].call_id);
+                    //update_end_state(i);//lei modify for:update end state for this call
+                    cleanCallList(i);
+                    send_call_state_change();//means mt/mo call is end
+                    //cleanCallList(i);
                 }
             } //fix bug API-54
             else 
@@ -494,8 +506,8 @@
                 {
                     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();
+                    s_CallId = call_list[i].call_id;
+                    send_call_state_change();
                 }
                 else if(s_call_lists[n].call_state == call_list[i].call_state)
                 {
@@ -507,15 +519,16 @@
                         **fix bug API-54
                         */
                         LYINFLOG("resend incoming call signal");
-                        sendSignalIncomingCall();
+                        send_call_state_change();
                     }
                 }
                 else 
                 {
                     LYINFLOG("state changed from %d to %d",s_call_lists[n].call_state,call_list[i].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);
-                }                               
+                    updateCallList(&s_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);//update mt call
+                    send_call_state_change();
+                }                            
             }
             else
             {     
@@ -527,17 +540,18 @@
                     {
                         if(s_call_lists[n].call_id==0)
                         {
-                             LYINFLOG("add a call id");
-                             update=1;
+                            LYINFLOG("add a call id");
+                            update=1;//for send sigal
+                            s_CallId = call_list[i].call_id;
                         }
                         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;
+                        send_call_state_change();//means mo call is success
                         break;
                     }                    
                 }
-
-                if(call_end == 0)
+                if(call_end == 0)//1.there is no space to use 2.can't find addr in buffer 3.call_id not equal   eg:when call is error return 8004/handle <= 0 will into this
                 {  
                     LYINFLOG("need to hangup id %d", call_list[i].call_id);
 #ifdef ECALL_SUPPORT
@@ -550,6 +564,7 @@
                     LYINFLOG("hang up service call id %d",call_list[i].call_id); 
                     lynq_call_hungup(&(call_list[i].call_id));
                 }
+
             }
             LYDBGLOG("servie idx %d end",i);
         }
@@ -751,7 +766,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 +774,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 +788,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 +810,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;
@@ -891,6 +906,7 @@
     return s_module_isDial;
 }
 
+
 int lynq_call(int* handle,char addr[])
 {
     if(g_module_init_flag != MODULE_RUNNING)
@@ -921,25 +937,23 @@
         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);       
+        cleanCallList(lynq_call_id);  
         return ret;      
-    }
-    
-    delete p;        
- 
+    }       
+    delete p;
     s_module_isDial = 1;
     if(waitCallstateChange(6000)==ETIMEDOUT)//6000ms
     {
         //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);            
+        cleanCallList(lynq_call_id);
+        send_call_state_change();
         return LYNQ_E_TIME_OUT;
     }
     s_module_isDial = 0;
@@ -952,10 +966,12 @@
     else 
     {   
         LYERRLOG("lynq_call dial addr %s fail, invalid id",addr);
-        cleanCallList(lynq_call_id);      
+        cleanCallList(lynq_call_id);
+        send_call_state_change();
         return LYNQ_E_INVALID_ID_ANONALY;
-    }                 
+    }        
 }
+
 int lynq_call_answer()
 {
     if(g_module_init_flag != MODULE_RUNNING)
@@ -972,6 +988,7 @@
     }        
     return ret;
 }
+
 int lynq_call_hungup(int* handle)
 {
     if(g_module_init_flag != MODULE_RUNNING)
@@ -1018,17 +1035,18 @@
     }        
     return ret;   
 }
-int lynq_wait_incoming_call(int *handle)
+
+int lynq_wait_call_state_change(int *handle)
 {
     if(g_module_init_flag != MODULE_RUNNING)
     {
         LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
         return LYNQ_E_CONFLICT;
     }
-    waitIncomingCall();
-    *handle = s_IncomingCallId;
-    LYINFLOG("lynq incoming call id:%d",s_IncomingCallId);
-    return RESULT_OK;   
+    wait_call_state();
+    *handle = s_CallId;
+    LYINFLOG("lynq mo/mt call id:%d",s_CallId);
+    return RESULT_OK;
 }
 
 int lynq_set_auto_answercall(const int mode)
@@ -1042,6 +1060,19 @@
     LYINFLOG("auto answer call mode =%d",mode);
     return RESULT_OK;   
 }
+
+int lynq_find_already_end()
+{
+    for(int i=0;i < LYNQ_CALL_MAX; i++)
+    {
+        if(s_call_lists[i].call_state == 6)
+        {
+            return 0;
+        }
+    }
+    return INVALID_ID;
+}
+
 int lynq_get_current_call_state(int *handle,    int *call_state,int *toa,int *direction,char addr[])
 {
     if(g_module_init_flag != MODULE_RUNNING)
@@ -1056,16 +1087,26 @@
         LYERRLOG("handle is NULL");
         return LYNQ_E_PARAMETER_ANONALY;
     }
+    LYINFLOG("lynq_get_current_call_state %d\n ", *handle);
     lynq_call_id = find_call_id_with_call_id(*handle);
     if(lynq_call_id==INVALID_ID)
     {
-        return LYNQ_E_INVALID_ID_ANONALY;
+        //find end state
+        if((*handle) >= 0)
+        {
+            *call_state = (int)LYNQ_CALL_END;
+            return RESULT_OK; 
+        }
+        else
+        {
+            return LYNQ_E_INVALID_ID_ANONALY;
+        }
     }
     *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;   
+    return RESULT_OK;
 }
 
 int lynq_get_current_call_number()
@@ -1389,16 +1430,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