Qualcomm平台qcril初始化及消息处理流程

  本节主要来介绍Qcril的初始化流程以及消息在Qcril中如何传递。

        Android平台不同厂商的AP侧可以相同，但是Modem侧肯定会有很大的差异，RIL层要解决一个问题就是适配不同厂商的Modem，为了达到兼容性要求，Android在AP与Modem之间搭建了RILC的框架，由不同的Modem厂商将自己的协议连接到AP侧。对于高通平台来说，他的RILC就是QCRIL。

        在Qcril中保存一个静态表单，里面保存了所有RILC中下发请求的ID以及相应的处理函数，表单内容简要如下：

[cpp] view plain copy

1. static qcril_dispatch_table_entry_type qcril_event_table[] = {  
2.     /* QCRIL_EVT_UIM_QMI_COMMAND_CALLBACK */  
3.     { QCRIL_REG_ALL_STATES( QCRIL_EVT_UIM_QMI_COMMAND_CALLBACK, qcril_uim_process_qmi_callback ) },  
4.     /* QCRIL_EVT_UIM_QMI_INDICATION */  
5.     { QCRIL_REG_ALL_STATES( QCRIL_EVT_UIM_QMI_INDICATION, qcril_uim_process_qmi_indication ) },  
6.     /* QCRIL_EVT_INTERNAL_UIM_VERIFY_PIN_COMMAND_CALLBACK */  
7.     { QCRIL_REG_ALL_STATES( QCRIL_EVT_INTERNAL_UIM_VERIFY_PIN_COMMAND_CALLBACK, qcril_uim_process_internal_command ) },  
8.     /* QCRIL_EVT_INTERNAL_MMGSDI_CARD_POWER_UP */  
9.     { QCRIL_REG_ALL_STATES( QCRIL_EVT_INTERNAL_MMGSDI_CARD_POWER_UP, qcril_uim_process_internal_command ) },  
10.     /* 0x90007 - QCRIL_EVT_HOOK_OEM_ENG_MODE   */  
11.     { QCRIL_REG_ALL_ACTIVE_STATES( QCRIL_EVT_HOOK_OEM_ENG_MODE, qcril_qmi_nas_request_eng_mode_info ) },  
12.     /* 1 - RIL_REQUEST_GET_SIM_STATUS */  
13.     { QCRIL_REG_ALL_ACTIVE_STATES( RIL_REQUEST_GET_SIM_STATUS, qcril_uim_request_get_sim_status ) },  
14.     /* 2 - RIL_REQUEST_ENTER_SIM_PIN */  
15.     { QCRIL_REG_ALL_ACTIVE_STATES( RIL_REQUEST_ENTER_SIM_PIN, qcril_uim_request_enter_pin ) },  
16.     /* 105 - RIL_REQUEST_ISIM_AUTHENTICATION */  
17.     { QCRIL_REG_ALL_ACTIVE_STATES( RIL_REQUEST_ISIM_AUTHENTICATION, qcril_uim_request_isim_authenticate ) },  
18. }  

        里面每一项都包含两个元素：事件ID和处理函数，在处理这些消息时将会根据事件的ID查找并执行相应的处理函数。

        比如，对于得到当前SIM卡状态这个请求，对应的ID为RIL_REQUEST_GET_SIM_STATUS，而其处理函数为：qcril_uim_request_get_sim_status()。

一、Qcril初始化流程

        初始化流程需要完成EventLoop消息循环的建立、各个模块的初始化等工作。先看RILD部分。

[cpp] view plain copy

1. @rild.c  
2. int main(int argc, char **argv)  
3. {  
4.     //动态加载reference-ril.so或者qcril.so  
5.     dlHandle = dlopen(rilLibPath, RTLD_NOW);  
6.     //创建Loop监听Socket事件  
7.     RIL_startEventLoop();  
8.     rilInit = (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))dlsym(dlHandle, "RIL_Init");  
9.     funcs = rilInit(&s_rilEnv, argc, rilArgv);  
10.     RIL_register(funcs);  
11. }  

        在RILD中会通过dlsym查找ril库中的RIL_Init函数地址，然后通过rilInit调用，对高通来说，该函数在qcril.c中：

[cpp] view plain copy

1. @qcril.c  
2. const RIL_RadioFunctions *RIL_Init ( const struct RIL_Env *env, int argc, char **argv) {  
3.     //设置线程名字为rild  
4.     qmi_ril_set_thread_name( pthread_self() , QMI_RIL_QMI_RILD_THREAD_NAME);  
5.     qmi_ril_fw_android_request_flow_control_init();  
6.     //初始化unsol的eventlist pending_unsol_resp_list，为其分配内存  
7.     qmi_ril_init_android_unsol_resp_pending_list();  
8.     //初始化接收Modem消息的EventLoop  
9.     qcril_event_init();  
10.     //初始化qcril中的各个模块  
11.     qcril_init();  
12.     //开启EventLoop  
13.     qcril_event_start();  
14.     //其他初始化  
15.     qmi_ril_initiate_bootup();  
16.     //返回RILD对RILC的接口函数  
17.     return &qcril_request_api[ QCRIL_DEFAULT_INSTANCE_ID ];  
18. }  

        下面我们分别来分析上面的过程。

1.1、初始化EventLoop过程

        在Qcril中搭建了EventLoop循环用于检测Modem上报的消息，而EventLoop机制的初始化工作是在qcril_event_init()中完成的。

[cpp] view plain copy

1. @qcril_event.c  
2. void qcril_event_init( void ) {  
3.     pthread_attr_t attr;  
4.     int ret;  
5.     qcril_event.started = 0;  
6. MI_RIL_UTF  
7.     pthread_attr_init (&attr);  
8.     ret = utf_pthread_create_handler(&qcril_event.tid, &attr, qcril_event_main, NULL);  
9.     pthread_attr_destroy( &attr );  
10.   
11.     pthread_attr_init (&attr);  
12.     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);  
13.     //创建EventLoop线程，线程入口是qcril_event_main  
14.     ret = pthread_create(&qcril_event.tid, &attr, qcril_event_main, NULL);  
15.     pthread_attr_destroy( &attr );  
16.   
17.     //设置线程名字为"event"  
18.     qmi_ril_set_thread_name(qcril_event.tid, QMI_RIL_EVENT_THREAD_NAME);  
19.     pthread_mutexattr_init( &qcril_event.activity_lock_mutex_atr );  
20.     pthread_mutex_init( &qcril_event.activity_lock_mutex, &qcril_event.activity_lock_mutex_atr );  
21.     while (qcril_event.started == 0)  
22.     {  
23.         pthread_cond_wait(&qcril_event_startupCond, &qcril_event.startup_mutex);  
24.     }  
25. }  

        在初始化过程中，通过pthread_create()函数创建了EventLoop线程，并且指出该线程的入口函数为qcril_event_main()，我们从线程的入口开始分析：

[cpp] view plain copy

1. static void *qcril_event_main ( void *param) {  
2.     int ret;  
3.     int filedes[2];  
4.     int n;  
5.     fd_set rfds;  
6.     qcril_event_type *ev;  
7.     char buff[16];  
8.     IxErrnoType err_no;  
9.     int go_on;  
10.   
11.   
12.     param = param;  
13.     pthread_mutex_init(&qcril_event.list_mutex, NULL);  
14.     //初始化qcril_event.list链表  
15.     qcril_event_init_list(&qcril_event.list);  
16.     FD_ZERO(&qcril_event.readFds); /* Needed to use select() system call */  
17.     QCRIL_MUTEX_LOCK( &qcril_event.startup_mutex, "[Event Thread] qcril_event.startup_mutex" );  
18.     qcril_event.started = 1;  
19.     //创建管道  
20.     ret = pipe(filedes);  
21.     qcril_event.fdWakeupRead = filedes[0];  
22.     qcril_event.fdWakeupWrite = filedes[1];  
23.   
24.   
25.     fcntl(qcril_event.fdWakeupRead, F_SETFL, O_NONBLOCK);  
26.     FD_SET(qcril_event.fdWakeupRead, &qcril_event.readFds);  
27.     pthread_cond_broadcast(&qcril_event_startupCond);  
28.     while (qcril_event.started < 2)  
29.     {  
30.         //阻塞等待qcril初始化  
31.         pthread_cond_wait(&qcril_event_startupCond, &qcril_event.startup_mutex);  
32.     }  
33.   
34.   
35.     for (;;)  
36.     {  
37.         /* Make a local copy of read fd_set;  Don't ask why. */  
38.         memcpy(&rfds, &qcril_event.readFds, sizeof(fd_set));  
39.         //阻塞等待接收内容  
40.         n = select(qcril_event.fdWakeupRead + 1, &rfds, NULL, NULL, NULL);  
41.         if (n < 0)  
42.         {  
43.             if (errno == EINTR) continue;  
44.             QCRIL_LOG_ERROR("QCRIL event select error (%d)", errno);  
45.             qmi_ril_clear_thread_name(pthread_self());  
46.             return NULL;  
47.         }  
48.         /* Empty the socket */  
49.         do  
50.         {  
51.             //读取内容  
52.             ret = read(qcril_event.fdWakeupRead, &buff, sizeof(buff));  
53.         } while (ret > 0 || (ret < 0 && errno == EINTR));  
54.         do  
55.         {  
56.             if ( ( NULL != ( ev = qcril_event.list.next ) && ( ev != &qcril_event.list ) ) )  
57.             {  
58.                 qcril_event_remove_from_list( ev );  
59.                 QCRIL_MUTEX_UNLOCK( &qcril_event.list_mutex, "[Event Thread] qcril_event.list_mutex" );  
60.                 //处理Modem发送的请求  
61.                 err_no = qcril_process_event( ev->instance_id, ev->modem_id, ev->event_id, ev->data, ev->datalen, ev->t );  
62.                 QCRIL_MUTEX_LOCK( &qcril_event.list_mutex, "[Event Thread] qcril_event.list_mutex" );  
63.                 if ( ev->data_must_be_freed && ev->data )  
64.                 {  
65.                     qcril_free( ev->data );  
66.                 }  
67.                 qcril_free( ev );  
68.             }  
69.             go_on = ( ( NULL != ( ev = qcril_event.list.next ) && ( ev != &qcril_event.list ) ) );  
70.         } while ( go_on );  
71.   
72.   
73.     }  
74.     qmi_ril_clear_thread_name(pthread_self());  
75.     return NULL;  
76. }  

        在以上过程中，完成qcril_event.list链表的初始化，然后通过pthread_cond_wait进入阻塞状态，当被解锁后以及进入EventLoop循环，检测到事件后，通过qcril_process_event处理。

1.2、初始化qcril各个模块

        Qcril在接到RILC的请求后，需要根据请求的类型将消息派发给不同的负责模块，而qcril_init()就是完成各个模块的初始化工作。

[cpp] view plain copy

1.         void qcril_init ( void) {  
2.             qcril_arb_init();  
3.             qcril_init_state();  
4.             qmi_ril_oem_hook_init();  
5.             qcril_db_init();  
6.             //初始化Event table  
7.             qcril_init_hash_table();  
8.             qcril_reqlist_init();  
9. #ifdef FEATURE_QCRIL_PLMN_LIST  
10.             qcril_qmi_nas2_init();  
11. #endif  
12.             qcril_request_suppress_list_init();  
13.             qmi_ril_qmi_client_pre_initialization_init();  
14.             qmi_ril_qmi_client_pre_initialization_acquire();  
15.             qcril_qmi_nas_dms_commmon_pre_init();  
16.             qcril_qmi_voice_pre_init();  
17. #ifndef QMI_RIL_UTF  
18.             qcril_am_pre_init();  
19. #else  
20.             qmi_ril_rat_enable_option = QMI_RIL_FTR_RAT_UNKNOWN;  
21.             qmi_ril_baseband_ftr_info = QMI_RIL_FTR_BASEBAND_UNKNOWN;  
22. #endif  
23.             qcril_qmi_imsa_pre_init();  
24.             qcril_qmi_sms_pre_init();  
25.             QCRIL_LOG_FUNC_RETURN();  
26.         }  

        在这里对qcril的各个模块进行初始化。其中完成了很重要的一步就是将qcril_event_table表拷贝给qcril_hash_table，用于onRequest时对各种请求进行处理，我们来看具体操作：

[cpp] view plain copy

1. static void qcril_init_hash_table( void ) {  
2.     uint32 reg_index, hash_index; /*!< index into hash table */  
3.     qcril_dispatch_table_entry_type *temp_entry_ptr;  
4.     for (reg_index = 0; reg_index < QCRIL_ARR_SIZE( qcril_event_table ); reg_index++)  
5.     {  
6.         hash_index = qcril_hash( qcril_event_table[reg_index].event_id, QCRIL_HT_ENTRIES_MAX, 0 );  
7.         if(hash_index < QCRIL_HT_ENTRIES_MAX)  
8.         {  
9.             if (qcril_hash_table[hash_index] == NULL)  
10.             {  
11.                 //将qcril_event_table拷贝给qcril_hash_table  
12.                 qcril_hash_table[hash_index] = &qcril_event_table[reg_index];  
13.             }  
14.             else  
15.             {  
16.                 temp_entry_ptr = qcril_hash_table[hash_index];  
17.                 while (temp_entry_ptr->next_ptr != NULL)  
18.                 {  
19.                     temp_entry_ptr = temp_entry_ptr->next_ptr;  
20.                 }  
21.                 temp_entry_ptr->next_ptr = &qcril_event_table[reg_index];  
22.             }  
23.         }  
24.     }  
25. }  

        经过上面的拷贝，qcril_event_table中就保存了所有Request的id和处理方法。

1.3、开启EventLoop

        在1.1中介绍过，初始化EventLoop时，在完成其链表的初始化过程后，通过pthread_cond_wait()将其阻塞，而现在要做的就是取消其阻塞状态，使其进入消息检测循环。
        这是在qcril_event_start()中完成的：

[cpp] view plain copy

1. void qcril_event_start( void )  
2. {  
3.     QCRIL_MUTEX_LOCK( &qcril_event.startup_mutex, "[Main Thread] qcril_event.startup_mutex" );  
4.     //更新状态  
5.     qcril_event.started = 2;  
6.     //释放EventLoop锁  
7.     pthread_cond_broadcast(&qcril_event_startupCond);  
8.     QCRIL_MUTEX_UNLOCK( &qcril_event.startup_mutex, "[Main Thread] qcril_event.startup_mutex" );  
9.   
10.   
11. }  

        由于EventLoop被初始化后一直处于阻塞状态，所以在这里将started状态置为2后，对qcril_event_startupCond进行解锁，从而使EventLoop进入循环。

1.4、其他初始化过程

        在qmi_ril_initiate_bootup()中完成了一些其他的初始化流程。

[cpp] view plain copy

1. void qmi_ril_initiate_bootup(void)  
2. {  
3.       qcril_setup_timed_callback( QCRIL_DEFAULT_INSTANCE_ID, QCRIL_DEFAULT_MODEM_ID, qmi_ril_bootup_perform_core_or_start_polling, NULL, NULL );  
4. }  

        继续看qmi_ril_bootup_perform_core_or_start_polling()过程：

[cpp] view plain copy

1. void qmi_ril_bootup_perform_core_or_start_polling(void * params)  
2. {  
3.     RIL_Errno init_res;  
4.     int ril_version;  
5.     qcril_unsol_resp_params_type unsol_resp;  
6.     qmi_ril_main_thread_id = pthread_self();  
7.     qmi_ril_set_thread_name( qmi_ril_fw_get_main_thread_id(), QMI_RIL_QMI_MAIN_THREAD_NAME);  
8.     qmi_ril_wave_modem_status(); // this should result in "modem unavailble" report  
9.     qmi_ril_set_operational_status( QMI_RIL_GEN_OPERATIONAL_STATUS_INIT_PENDING ); // for consistency  
10.     qmi_ril_set_operational_status( QMI_RIL_GEN_OPERATIONAL_STATUS_INIT_ONGOING );  
11.     //qmi初始化  
12.     init_res = qmi_ril_core_init();  
13. }  

        上面通过qmi_ril_core_init()完成了qmi的初始化：

[cpp] view plain copy

1.         RIL_Errno qmi_ril_core_init(void)  
2.         {  
3.             RIL_Errno res = RIL_E_GENERIC_FAILURE;  
4.             QCRIL_LOG_FUNC_ENTRY();  
5.             qcril_event_suspend(); // to ensure atomic init flow cross sub domains  
6.             do  
7.             {  
8.                 //qcril client的初始化  
9.                 res = qcril_qmi_client_init();  
10.                 if ( RIL_E_SUCCESS != res )  
11.                     break;  
12.                 qcril_other_init();  
13.                 qcril_uim_init();  
14.                 qcril_gstk_qmi_init();  
15. #ifndef QMI_RIL_UTF  
16.                 qcril_data_init();  
17. #endif  
18.                 qcril_qmi_nas_dms_commmon_post_init();  
19.                 if (qmi_ril_is_feature_supported(QMI_RIL_FEATURE_OEM_SOCKET))  
20.                 {  
21.                     QCRIL_LOG_INFO( "%s Init OEM socket thread", __FUNCTION__ );  
22.                     qcril_qmi_oem_socket_init();  
23.                 }  
24.   
25.   
26.             } while (FALSE);  
27.             qcril_event_resume();  
28.             QCRIL_LOG_FUNC_RETURN_WITH_RET(res);  
29.             return res;  
30.         }  

        在上面完成了qcril客户端的初始化过程：

[cpp] view plain copy

1. RIL_Errno qcril_qmi_client_init( void )  
2. {  
3.     qmi_client_error_type client_err = 0;  
4.     RIL_Errno res = RIL_E_GENERIC_FAILURE;  
5.     QCRIL_LOG_FUNC_ENTRY();  
6.     /* Start modem or vote for start modem */  
7.     qcril_qmi_modem_power_process_bootup();  
8.     memset(&client_info, 0, sizeof(client_info));  
9.     do  
10.     {  
11.   
12.   
13.         // QMI VOICE command callback  
14.         client_info.client_cbs[QCRIL_QMI_CLIENT_VOICE] = qcril_qmi_voice_command_cb;  
15.   
16.   
17.         // Get IDL service objects  
18.         client_info.service_objects[QCRIL_QMI_CLIENT_VOICE] = voice_get_service_object_v02();  
19.         client_info.service_objects[QCRIL_QMI_CLIENT_NAS] = nas_get_service_object_v01();  
20.         client_info.service_objects[QCRIL_QMI_CLIENT_WMS] = wms_get_service_object_v01();  
21.         client_info.service_objects[QCRIL_QMI_CLIENT_WDS] = wds_get_service_object_v01();  
22.         client_info.service_objects[QCRIL_QMI_CLIENT_DMS] = dms_get_service_object_v01();  
23.         /*client_info.service_objects[QCRIL_QMI_CLIENT_UIM] = uim_get_service_object_v01();*/  
24.         client_info.service_objects[QCRIL_QMI_CLIENT_PBM] =  pbm_get_service_object_v01();  
25.         client_info.service_objects[QCRIL_QMI_CLIENT_RF_SAR] =  sar_get_service_object_v01();  
26.         client_info.service_objects[QCRIL_QMI_CLIENT_IMS_VT] =   ims_qmi_get_service_object_v01();  
27.         client_info.service_objects[QCRIL_QMI_CLIENT_IMS_PRESENCE] = imsp_get_service_object_v01();  
28.         client_info.service_objects[QCRIL_QMI_CLIENT_IMSA] = imsa_get_service_object_v01();  
29.         client_info.service_objects[QCRIL_QMI_CLIENT_RFPE] = rfrpe_get_service_object_v01();  
30.         client_info.service_objects[QCRIL_QMI_CLIENT_IMS_SETTING] = imss_get_service_object_v01();  
31.         if ( qmi_ril_get_process_instance_id() == QCRIL_DEFAULT_INSTANCE_ID )  
32.         {  
33.             client_info.service_objects[QCRIL_QMI_CLIENT_PDC] = pdc_get_service_object_v01();  
34.         }  
35.   
36.   
37.         pthread_mutexattr_init(&client_info.cache_lock_mtx_atr);  
38.         pthread_mutex_init(&client_info.cache_lock_mutex, &client_info.cache_lock_mtx_atr);  
39.         res = qcril_qmi_init_core_client_handles();  
40.         if (RIL_E_SUCCESS != res)  
41.             break;  
42.   
43.   
44.     } while (FALSE);  
45.     return res;  
46. }  

1.5、将回调函数注册给RILC

        在Qcril的初始化完毕后，将自己的函数列表返回给RilC，也就是qcril_request_api:

[cpp] view plain copy

1. static const RIL_RadioFunctions qcril_request_api[] = {  
2.       { RIL_VERSION, onRequest_rid, currentState_rid, onSupports_rid, onCancel_rid, getVersion_rid }  
3. };  

        这样的话，在RIL中调用的接口就会进入该函数列表中进行处理。

        以上就是qcril的初始化流程。

二、QCRIL对请求的处理过程

        当ril有请求过来时，就会调用ril库的onRequest()方法，此时就会根据当前Qcril注册的函数列表进入到qcril_request_api的onRequest_rid()函数中：

[cpp] view plain copy

1. @qcril.c  
2. static void onRequest_rid ( int request, void *data, size_t datalen, RIL_Token t)  
3. {  
4.     onRequest( qmi_ril_process_instance_id, request, data, datalen, t );  
5. }  

        然后进入onRequest()中继续处理：

[cpp] view plain copy

1. static void onRequest ( qcril_instance_id_e_type  instance_id, int request, void *data, size_t datalen, RIL_Token t) {  
2.     udit_result = qmi_ril_fw_android_request_render_execution( param.t,  
3.             param.event_id,  
4.             param.data,  
5.             param.datalen,  
6.             param.instance_id,  
7.             &log_dispatch_dedicated_thrd );  
8. }  

        继续：

[cpp] view plain copy

1. RIL_Errno qmi_ril_fw_android_request_render_execution( RIL_Token token, int android_request_id, void * android_request_data, int android_request_data_len, qcril_instance_id_e_type  instance_id, int * is_dedicated_thread ) {  
2.     do  
3.     {  
4.         entry_ptr = NULL;  
5.         //从hash表中查找当前的Event  
6.         if ( qcril_hash_table_lookup( (uint32) param.event_id, &entry_ptr ) != E_SUCCESS || NULL == entry_ptr )  
7.         {  
8.             audit_result = RIL_E_REQUEST_NOT_SUPPORTED;  
9.             break;  
10.         }  
11.         if ( dedicated_thrd_req_lookup_val == param.event_id )  
12.         { // deferred thread exec  
13.         }  
14.         else  
15.         {  
16.             //派发该Event  
17.             if ( qcril_dispatch_event( entry_ptr, ¶m ) == E_NOT_ALLOWED )  
18.             {  
19.                 audit_result = RIL_E_RADIO_NOT_AVAILABLE;  
20.                 break;  
21.             }  
22.         }  
23.     } while (FALSE);  
24.     return audit_result;  
25. }  

        在上面的过程中，要先通过qcril_hash_table_lookup()函数查找当前的Event，如果没有找到当前的Request，就认为非法，找到之后，进入qcril_dispatch_event()中派发该Event：

[cpp] view plain copy

1. IxErrnoType qcril_dispatch_event ( qcril_dispatch_table_entry_type *entry_ptr, qcril_request_params_type *params_ptr) {  
2.     if(params_ptr != NULL && (params_ptr->instance_id < QCRIL_MAX_INSTANCE_ID) )  
3.     {  
4.         // print the recieved date byte stream  
5.         qcril_qmi_print_hex(params_ptr->data,  params_ptr->datalen);  
6.         instance_id = params_ptr->instance_id;  
7.         s_ptr = &qcril_state->info[ instance_id ];  
8.         modem_id = params_ptr->modem_id;  
9.         if (E_SUCCESS == res)  
10.         {  
11.             //处理当前Request  
12.             (entry_ptr->handler)(params_ptr, &ret);  
13.             if ( ret.pri_gw_sim_state_changed || ret.pri_cdma_sim_state_changed ||  
14.                     ret.sec_gw_sim_state_changed || ret.sec_cdma_sim_state_changed ||  
15.                     ret.ter_gw_sim_state_changed || ret.ter_cdma_sim_state_changed  
16.                )  
17.             {  
18.                 qcril_state_transition( instance_id, modem_id, params_ptr->event_id, &ret );  
19.             }  
20.         }  
21.     }  
22.     else  
23.     {  
24.     }  
25.     return res;  
26. }  

        上面的过程通过entry_ptr->handler调用当前Event的处理函数。这里的handler对应qcril_hash_table中的某一项。从上面1.2步骤中我们将qcril_event_table表中的数据拷贝给了qcril_hash_table，所以这里的handler可以理解为qcril_event_table中的某一项。
        之后的流程就会进入到某个具体请求的处理函数中，比如对于得到当前SIM卡状态这个请求，其处理函数为：qcril_uim_request_get_sim_status()。