在高通Fastmmi模式中增强交互方式

背景

由于之前工厂抱怨 FCT模式不好用。

之前的FCT测试是这样子的：PCBA上夹具，连接USB。

同时，使用上位机程序（ATE）发送指令，人工判断结果以后，发送结果；以及下一条测试指令的情况。

可见，测试一条指令所需的交互次数很多。

现在要求减少AT指令的交互测试，思路有2种：

1、做成自动化的，不再人工发送指令

2、通过现有的功能（例如按键）实现模拟点击确认交互方式的指令

大概是这样子的：

  1. 机器 放上 夹具，连接USB
  3. 进入 Fastmmi  模式以后 ，自动执行每一项测试项，
  4. - 如果指令能够自动返回，则继续下一项
  5. - 如果指令需要人工判断，则通过定义的按键来 显示 成功或者失败；如果 没有按键，则一直等待，否则就进入下一项
  6. - 循环，直到结束测试。

行动目标

1、即使PC不再发送AT指令，机器自己也能运行自动测试（满足某些情况下）。

2、按下指定的按键，能够直接判断测试项的结果。

行动思路

框架了解

整个MMI的框架如下：

  • MMI Core: Core manages all MMI modules and is responsible for UI control, also responses Diag request from DIAG service.

MMI core is on: /dev/socket/mmi, running as server role. Agent and Diag will connect server

socket

  • MMI Agent: Agent loads each MMI module (mmi_xxx.so) in a single process and communicates with MMI Core via socket.
  • MMI Diag: Diag handles diag command from Host PC and communicates with MMI core via socket.
  • MMI UI: UI is part of MMI core, MMI core responsible for drawing UI components.

源码树如下：

  1. The FASTMMI code is in the folder vendor/qcom/proprietary/fastmmi. Check the source file structure below.
  2. .
  3. ├── Android.mk
  4. ├── configure.ac
  5. ├── libmmi
  6. ...
  7. ├── Makefile.am
  8. ├── mmi
  9. ...
  10. ├── mmi.mk
  11. ├── module
  12. │   ├── cpu
  13. │   │   ├── Android.mk
  14. │   │   ├── cpu.cpp
  15. │   │   └── Makefile.am
  16. ...
  17. │   └── wifi
  18. │       ├── Android.mk
  19. │       ├── Makefile.am
  20. │       ├── wifi.cpp
  21. │       └── wifi_uav.cpp
  22. └── res
  23. ...
  24.     ├── layout
  25.     │   ├── ...
  26.     │   ├── layout_wifi.xml
  27.     │   ├── main_wear.xml
  28.     │   └── main.xml
  29.     ├── raw
  30.     │   ├── Android.mk
  31.     │   ├── DroidSansFallback.ttf
  32.     │   ├── LICENSE
  33.     │   ├── NOTICE
  34.     │   └── qualsound.wav
  35.     ├── values
  36.     │   ├── Android.mk
  37.     │   ├── path_config_android.xml
  38.     │   ├── path_config_le.xml
  39.     │   ├── strings.xml
  40.     │   └── strings-zh-rCN.xml
  41.     └── wifi_config
  42.         ├── Android.mk
  43.         └── wpa_supplicant_test.conf
  • libmmi： is the UI controller library, like button, window, text ...
  • mmi ：is the main application.
  • module： is the individual mmi test cases.
  • res： is the config and layout resource, and so on.

流程分析

fastmmi的资料比较少，因此，只能基于现有的代码来进行分析推断。

流程很简单，fastmmi初始化，创建了包括ate_test_thread （默认的处理串口数据线程）。at_costomer_thread（新增的FCT专用指令函数）在内的各种线程。

从发送AT指令的线程入手：

路径：vendor/qcom/proprietary/fastmmi/mmi/mmi.cpp

实现了从各路串口中接收数据到buff，根据buff内容的不同而进行处理，我们修改FASTMMI的交互方式的关键就在于：

1、判断现在的layout（图层）是否存在

通过 get_main_module找到主界面（最后需要release_cur_layout释放互斥资源）

通过lay = g_layout_map[mod->config_list[KEY_LAYOUT]];判断当前的lay是否存在（子界面）

2、找到我们需要执行的按钮（例如，pass，failed）

通过layout.find_button_by_name方法找到对应的按钮

3、通过fastmmi的流程来“模拟”点击。

获取按钮的功能：r->cb = btn->get_cb();

执行按钮的功能：r->cb(r->module);

即：

  1.     /* step one: Get layout */
  2.     module_info *mod = get_main_module();
  3.     if(mod == NULL) {
  4.         ALOGE("%s Not main screen OR Null point",__FUNCTION__);
  5.         break;
  6.     }
  7.     layout *lay = g_layout_map[mod->config_list[KEY_LAYOUT]];
  8.     if(lay == NULL || lay->m_listview == NULL) {
  9.         ALOGE("%s No Main layout",__FUNCTION__);
  10.         break;
  11.     }
  13.     /* step two: Find button */
  14.     layout *curlay = acquire_cur_layout();
  15.     button *btn = curlay->find_button_by_name("xxx");
  16. 	if(btn==NULL)
  17.     {
  18.         ALOGE("btn xxx not found");
  19.         break;
  20.     }
  22. 	/* step three: exec button click */
  23. 	runnable_t *r = new runnable_t;
  25.     r->cb = btn->get_cb();
  26. 	release_cur_layout();
  27.     if((r != NULL) && (r->cb != NULL) && (r->module != NULL)) {
  28.         module_info *rmod = (module_info *)(r->module);
  29.         r->cb(r->module);
  30.     }else {
  31.         ALOGE("btn function not found");
  32.         break;
  33.     }

操作记录

使用什么软件，做了什么操作，改动了什么代码

根据上面的思路，发现FCT自动进入了GPS。不知道怎么回事（恢复了默认版本也一样），后面我使用r54分支进行调试。没有这个问题。

好像是因为我的判断逻辑有错误导致的

实现按键交互

路径：vendor/qcom/proprietary/fastmmi/mmi/input.cpp

确保按键能够向下传递

我们最终的目的是为了能够在key_callback中添加我们需要的特殊处理。首先，需要关心按键事件能否向下传递。

下列的2个函数实现了 按键事件处理以及是否向下传递分发（类似QT的事件发放）：

  1. int input_callback(int fd, uint32_t revents, void *data) {
  2.     struct input_event ev;
  3.     int retval;
  5.     retval = ev_get_input(fd, revents, &ev);
  6.     if(retval < 0) {
  7.         MMI_ALOGE("input event get fail\n");
  8.         return -1;
  9.     }
  11.     /**Adjust the value to match LCD resolution*/
  12.     adjust_ev(&ev);
  14.    /**Convert virtual key to KEY code*/
  15.     hook_vkey(&ev, &g_key_map);
  17.     /**Call listener, if return False mean stop here,
  18.   * if return true mean continue process event.
  19.   */
  20.     if(!invoke_listener(ev)) // 如果 invoke_listener 处理了，则不再向下传递
  21.         return 0;
  23.     if(ev.type == EV_KEY) {
  24.         key_callback(ev.type, ev.code, ev.value);
  25.     } else if(ev.type == EV_SW) {
  26.         sw_callback(ev.type, ev.code, ev.value);
  27.     } else if(ev.type == EV_ABS || ev.type == EV_SYN) {
  28.         touch_callback(&ev);
  29.     }
  31.     return 0;
  32. }
  34. static bool invoke_listener(input_event ev) {
  35.     bool ret = true;
  37.     pthread_mutex_lock(&g_listener_mutex);
  38.     if(g_input_listener != NULL)
  39.         ret = g_input_listener->dispatch_event(ev);
  40.     pthread_mutex_unlock(&g_listener_mutex);
  42.     return ret;
  43. }

由于invoke_listener调用了dispatch_event，我们继续看dispatch_event是如何对某些按键进行特殊处理的。

路径：vendor/qcom/proprietary/fastmmi/mmi/input_listener_key.cpp 

  1. bool input_listener_key::dispatch_event(input_event ev) {
  3.     layout *lay = this->get_lay();
  4.     char btn_name[64] = { 0 };
  6.     __u16 type = ev.type;
  7.     __u16 code = ev.code;
  8.     __u32 value = ev.value;
  9.     mod_ev_t modev;
  11.     modev.mod = this->get_module();
  13.     int down = ! !value;
  15.     if(type == EV_KEY) {
  16.         switch (code) {
  17.         case KEY_BACK: // 在 fastmmi中， KEY_BACK 对应的按键应该是 fail
  18.             strlcpy(btn_name, KEY_FAIL, sizeof(btn_name));
  19.             break;
  21.         case KEY_HOMEPAGE:
  22.             ev.code = KEY_HOME; //change the code to KEY_HOMEPAGE
  24. 		// ...
  25.         default:
  26.             break;
  27.         }
  28.     }
  29.     // ...
  31.     button *btn = lay->find_button_by_name(btn_name);
  33.     if(btn != NULL) {
  34.         if(down) {
  35.             MMI_ALOGI("button(%s) press down, code=%d", btn->get_name(), code);
  36.             btn->set_color(255, 0, 0, 125);
  37.             cb_t cb = this->get_cb();
  39.             modev.ev = &ev;
  40.             if(cb != NULL)
  41.                 cb(&modev);
  42.         } else {
  43.             MMI_ALOGI("button(%s) release, code=%d", btn->get_name(), code);
  44.             btn->set_color(255, 0, 0, 255);
  45.         }
  46.         MMI_ALOGW("Button Pushed");
  48.         invalidate();
  49.     } else {
  50.         MMI_ALOGW("Not find button(%s) in layout(%s)", btn_name, lay->get_layout_path());
  51.     }
  53. #if 0 // 解除对 back 键的屏蔽。
  54.     // 关闭这2行，以使得返回值为真，则最后能够将事件传递下去
  55.     if(code == KEY_BACK)
  56.         return false;
  57. #endif
  59.     return true;
  60. }

处理按键

现在，按下的按键能够调用key_callback了。我们只需要在这里进行我们要的特殊处理即可。

路径：vendor/qcom/proprietary/fastmmi/mmi/input.cpp

省略了针对 有关值的定义以及函数声明。

  1. static int key_callback(int type, int code, int value) {
  2.     int down = ! !value;
  4.     if(type != EV_KEY) {
  5.         return 0;
  6.     }
  8.     if(!down) {
  9.         return 0;
  10.     }
  12.     MMI_ALOGI("key:%d release", code);
  14.     switch (code)
  15.     {
  17. #if 1
  18.     // 用于确认结果
  19.     case KEY_BACK :
  20.         mark_this_test_module_result(module_failed); // 新增的函数
  21.     break; case KEY_ENTER:
  22.         mark_this_test_module_result(module_success);
  23.     break; default:
  24.             return 0;
  25.         break;
  26.     }
  27. #endif
  29.     return 0;
  30. }

按照之前说的“流程分析”，我是这么写的：

很简单，还是按照3步走。

  1. // vendor/qcom/proprietary/fastmmi/mmi/mmi.cpp
  3. // 用于手动标记测试结果成功或者失败
  4. void mark_this_test_module_result(bool result)
  5. {
  6.     int key_test_result = 0;
  8.     /* step one: Get layout */
  9.     module_info *mod = get_main_module();
  10.     if(mod == NULL) {
  11.         MMI_ALOGE("%s Not main screen OR Null point",__FUNCTION__);
  12.         return;
  13.     }
  15.     layout *lay = g_layout_map[mod->config_list[KEY_LAYOUT]];;
  16.     if(lay == NULL || lay->m_listview == NULL) {
  17.         MMI_ALOGE("%s No Main layout",__FUNCTION__);
  18.         return;
  19.     }
  21.     /* step two: Find button */
  22.     layout *curlay = acquire_cur_layout();
  23.     button *btn_pass = curlay->find_button_by_name("pass");
  24.     button *btn_fail = curlay->find_button_by_name("fail");
  26.     if(btn_pass == NULL && btn_fail == NULL){
  27.         MMI_ALOGE("[%s] FCT Confirm Result Button is NULL", __FUNCTION__);
  28.         release_cur_layout();
  29.         return ;
  30.     }
  32.     /* step three: exec button click */
  33.     runnable_t *r = new runnable_t;
  35.     button *btn = NULL;
  36.     r->cb = NULL;
  37.     r->module = NULL;
  39.     if(result == module_success) {
  40.         MMI_ALOGI("[%s] FCT Confirm Result Button is PASS", __FUNCTION__);
  41.         btn = btn_pass;
  42.         btn->set_disabled(true);
  43.         r->cb = btn->get_cb();
  44.     }else  if( result == module_failed) {
  45.         MMI_ALOGI("[%s] FCT Confirm Result Button is FAIL", __FUNCTION__);
  46.         btn = btn_fail;
  47.         btn->set_disabled(true);
  48.         r->cb = btn->get_cb();
  49.     }
  51.     r->module = curlay->module;
  52.     MMI_ALOGE("[%s]:[%s] Receive Terminal Signal:(E)", __FUNCTION__, curlay->module->module);
  53.     release_cur_layout();
  55.     if((r != NULL) && (r->cb != NULL) && (r->module != NULL)) {
  56.         module_info *rmod = (module_info *)(r->module);
  57.         ALOGI("[%s] Callback Activated Module:%s", __FUNCTION__, rmod->module);
  58.         r->cb(r->module);
  59.     }
  61.     if(btn != NULL && btn->get_disabled()){
  62.         ALOGI("[%s] Btn Set Enable", __FUNCTION__);
  63.         btn->set_disabled(false);
  64.         btn = NULL;
  65.     }
  67.     return;
  68. }

这样子就完成了。

新建线程用于自动交互

目的：实现在某个条件下，定期轮询获取需要执行的条目即可。

做法：

1、实现对应的功能，并实现每次调用某个函数则得到不同的结果。

2、按着fastmmi的规范实现模拟按键功能点击（参考如上）

3、在某个时候启动这条线程

  1. // 自动测试 功能 添加
  2. struct test_item_for_keypad_ui {
  3.     char * module_name; // 对应的界面
  4.     char * item_name;  // 测试项名称
  5.     //int need_comfirm; // 如果这一项需要人工确认，则为1，能够自动测试，则为0
  6. };
  7. #define TEST_TIEM_ARRAY_SIZE(obj) (sizeof((obj))/sizeof(struct test_item_for_keypad_ui))
  9. struct test_item_for_keypad_ui  fct_test_item_array[] =
  10. {
  11.     {"KEY",              "Key_Start",               1 }, // 需要处理对应的按键测试内容
  12.     {"LCD",              "Lcd_Start",               1 },
  13.     {"LCM_BACKLIGHT",    "Lcd_Backlight_Start",     1 },
  14.     {"LED",              "Led_Start",               1 },
  15.     {"BUTTON_BACKLIGHT", "Button_Backlight_Start",  1 },
  16.     {"BLUETOOTH",        "BT_Start",                0 },
  17.     {"WIFI",             "WIFI_Start",              0 },
  18.     {"GPS",              "GPS_Start",               0 },
  19.     {"NETSIGNAL",        "Netsignal_Start",         0 },
  20.     {"SIMCARD1",         "Sim_Start",               0 },
  21.     {"SDCARD",           "Sd_Start",                0 },
  22.     {"BATTERY",          "Battery_Start",           0 },
  23.     {"PRIMARY MIC",      "Primary_Mic_Start",       0 },
  24.     {"SPEAKER",          "Speaker_Start" ,          0 },
  25.     {"HANDSET PLAY",     "Headset_Start",           0 },
  26.     {"HEADSET MIC",      "Headset_Mic_Start" ,      0 },
  27.     {"GSENSOR",          "Gsensor_Start",           1 }, // 由于这一项会在内部提前结束，因此必须放在最后（调试这块的功能不再本文关心的范围内）
  28.     // 以下部分 算是 保留项目
  29.     //{"VERSION",          "Version_Start" },
  30. };
  32. static int item_index = 0;
  34. int get_next_test_item(char*buff)
  35. {
  36.     if(!buff) return -1;
  37.     if((item_index ) >= TEST_TIEM_ARRAY_SIZE(fct_test_item_array))
  38.     {
  39.         ALOGE("full\n");
  40.         sleep(5);
  41.         return -1;
  42.     }
  43.     ALOGE("get cmd buff from array : [%s]\n", fct_test_item_array[item_index].item_name);
  44.     ALOGE("item_index / Max : %d/%ld\n", item_index+1, TEST_TIEM_ARRAY_SIZE(fct_test_item_array));
  45.     sprintf(buff, "%s", fct_test_item_array[item_index].item_name);
  46.     item_index ++;
  48.     return 1;
  49. }
  51. void reset_test_item_index(void)
  52. {
  53.     item_index = 0;
  54. }
  56. void get_back_this_test_item(void)
  57. {
  58.     if(item_index)
  59.         item_index--;
  60. }
  62. int is_buff_in_test_array(char *buff)
  63. {
  64.     int i;
  65.     for(i = 0; i < TEST_TIEM_ARRAY_SIZE(fct_test_item_array); i++)
  66.     {
  67.         if(!strcmp(buff, fct_test_item_array[i].item_name))
  68.             return 1;
  69.     }
  70.     return 0;
  71. }
  73. int is_mod_in_test_array(char *mod_name, char*buff)
  74. {
  75.     int i;
  76.     if(!mod_name || !buff) return -1;
  77.     for(i = 0; i < TEST_TIEM_ARRAY_SIZE(fct_test_item_array); i++)
  78.     {
  79.         // 找到对应的模块
  80.         if(!strcmp(mod_name, fct_test_item_array[i].module_name))
  81.         {
  82.             // 判断此时的命令是否匹配
  83.             if(!strcmp(buff, fct_test_item_array[i].item_name))
  84.             return 1;
  85.         }
  87.     }
  88.     return 0;
  89. }
  91. /*! \enum test_thread_loop_type
  92.  *
  93.  *  判断auto_loop_for_each_cmd_thread进入了哪个if
  94.  */
  95. enum test_thread_loop_type {
  96.     loop_no_set, // 默认状态
  97.     loop_for_end, // 命令结束
  98.     loop_for_build_in_auto_test, // 内置的自动测试命令
  99.     loop_for_page_up_down, // 翻页命令
  100.     loop_for_get_result, // 获取总结果的命令
  101.     loop_for_test_single_item, // 匹配测试的每一项
  102. };
  104. static void *auto_loop_for_each_cmd_thread(void *)
  105. {
  106.     int loop_type = loop_no_set;
  107.     char buff[255];
  108.     void *ate_module = NULL;
  109.     bool ate_test = false;
  110.     button *btn = NULL;
  111.     int ret;
  113.     ALOGE("Schips create auto_loop_for_each_cmd_thread \n");
  115.     signal(SIGUSR1, signal_handler);
  117.     while(1)
  118.     {
  119.         sleep(1);
  120.         memset(buff,0,255);
  121.         // wait_for_auto_test(); 实现这个接口的阻塞等待与唤醒即可完成在某个时候自动执行
  122. loop_while:
  123.         while((get_next_test_item(buff)==1))
  124.         {
  125.             ALOGE("this cmd is [%s] \n",buff);
  127.             button *btn = NULL;
  128.             ate_test = false;
  130.             /*step one:Get the main layout */
  131.             module_info *mod = get_main_module();
  132.             if(mod == NULL) {
  133.                 ALOGE("%s Not main screen",__FUNCTION__);
  134.                 get_back_this_test_item();
  135.                 break;
  136.             }
  137.             layout *lay = g_layout_map[mod->config_list[KEY_LAYOUT]];;
  138.             if(lay == NULL || lay->m_listview == NULL) {
  139.                 ALOGE("%s No Main layout",__FUNCTION__);
  140.                 get_back_this_test_item();
  141.                 break;
  142.             } else
  143.             {
  144.                 // 检查 当前是否 有 正在运行的模块
  145.                 list < item_t * >*items = lay->m_listview->get_items();
  146.                 list < item_t * >::iterator iter;
  147.                 for(iter = items->begin(); iter != items->end(); iter++)
  148.                 {
  149.                     item_t *item = (item_t *) (*iter);
  150.                     module_info *tmod = item->mod;
  151.                     if(tmod->running_state == MODULE_RUNNING)
  152.                     {
  153.                         ALOGI("[%s] FCT module [%s] is in running,please waiting", __FUNCTION__, tmod->module);
  154.                         ate_test = true;
  155.                         get_back_this_test_item();
  156.                         sleep(1);
  157.                         goto loop_while;
  158.                     }
  159.                 }
  160.             }
  162.             runnable_t *r = new runnable_t;
  163.             r->cb = NULL;
  164.             r->module = NULL;
  165. 			if(is_buff_in_test_array(buff)) // !strcmp(buff,"Key_Start") || !strcmp(buff,"Lcd_Start") || ...
  166.             {
  167.                 ALOGI("[%s][%d] Receive ATE Test Command:%s", __FUNCTION__, __LINE__, buff);
  168.                 /*step two:check modules running state */ // 由于 这里还需要进行界面切换，因此需要先判断这一步。
  169.                 if(lay != NULL && lay->m_listview != NULL)
  170.                 {
  171.                     list < item_t * >*items = lay->m_listview->get_items();
  172.                     list < item_t * >::iterator iter;
  173.                     for(iter = items->begin(); iter != items->end(); iter++)
  174.                     {
  175.                         item_t *item = (item_t *) (*iter);
  176.                         module_info *tmod = item->mod;
  177.                         if(tmod->running_state == MODULE_RUNNING){
  178.                             ALOGI("[%s] FCT module %s is in running,please waiting", __FUNCTION__, tmod->module);
  179.                             ate_test = true;
  180.                         }
  182.                         if(!strcmp(tmod->module,"KEY") && !strcmp(buff,"Key_Start"))
  183.                         {
  184.                             clear_all_pushed_keys();
  185.                         }
  186. #if 0
  187.                         if((!strcmp(tmod->module,"KEY") && !strcmp(buff,"Key_Start")) ||
  188.                            (!strcmp(tmod->module,"LCD") && !strcmp(buff,"Lcd_Start")) ||
  189.                            // ...
  190. #else
  191.                            if(is_mod_in_test_array(tmod->module, buff))
  192. #endif
  193.                         {
  194.                             ALOGI("[%s] : [%s]-module, cmd is [%s]", __FUNCTION__, tmod->module, buff);
  195.                             ate_module = tmod;
  196.                             r->module = ate_module;
  197.                             r->cb = lay->m_listview->get_cb();
  198.                             //set_mmi_response(resp_buf_ok);
  199.                             loop_type = loop_for_test_single_item;
  200.                         }
  201.                     }
  202.                 }
  203.             }
  205.             if(ate_test)
  206.             {
  207.                 ate_module = NULL;
  208.                 r->module = NULL;
  209.                 r->cb = NULL;
  210.                 get_back_this_test_item();
  211.                 break;
  212.             }
  214.             // 执行动作
  215.             if(loop_type == loop_no_set)
  216.             {
  217.                 ALOGE("[%s][%d] Nothing to do,Start Next Loop", __FUNCTION__, __LINE__);
  218.             }else if((r != NULL) && (r->cb != NULL) && (r->module != NULL))
  219.             {
  220.                 module_info *rmod = (module_info *)(r->module);
  221.                 ALOGI("[%s] Callback Activated Module:%s Command:%s", __FUNCTION__, rmod->module, buff);
  222.                 ALOGE("[%s][%d] cmd is [%s]", __FUNCTION__, __LINE__, buff);
  224.                 // 只关心单项测试
  225.                 if(loop_type == loop_for_test_single_item)
  226.                 {
  227.                     r->cb(r->module);
  228.                 }
  229.             }
  231.             if(btn != NULL && btn->get_disabled())
  232.             {
  233.                 ALOGI("[%s] Btn Set Enable", __FUNCTION__);
  234.                 btn->set_disabled(false);
  235.                 btn = NULL;
  236.             }
  237.             sleep(2);
  239.         }
  240.     }
  242.     return NULL;
  243. }

附录：分析r->cb(r->module);

fastmmi是如何实现r->cb(r->module);的，其实我也很好奇，因为没有找到具体的按键功能实现。

所以特意翻了一下代码，看了一下，大概知道是，如果“有添加布局的需求”，那么可以好好研究一下：

1、标记按钮对应的按键功能。

2、实现对应的方法，并绑定功能与对应的组件。（通过C++中STL的map的方式）

其中涉及到 xml 的解析就不说了，纯应用层的东西，很多途径可以实现。

mmi/config.cpp:166: } else if(!xmlStrcmp(attr->name, (const xmlChar *) "onclick")) {

  1. in vendor/qcom/proprietary/fastmmi
  2. ===============================
  3. # res/layout/layout_xxx.xml （任意一个）
  4. <layout>
  5. <!--
  6.     ....
  7. -->
  8.     <include layout="footer.xml"/>
  9. </layout>
  10. ===============================
  11. # res/layout/footer.xml
  12.   <button
  13.         name="pass"
  14.         onclick="do_pass"
  15.         text="btn_pass"
  16.         h_rel="16"
  17.         w_rel="49"
  18.         x_rel="0"
  19.         y_rel="84"
  20.         color="0x007D7Dff" />
  21. ===============================
  22. # mmi/func_map.cpp:
  23. void process_exit(void *m) {
  24.     if(m == NULL) return;
  26.     module_info *mod = (module_info *) m;
  27.     mod->running_state = MODULE_IDLE;
  28.     flush_result();
  29.     module_cleanup(mod);
  30.     ALOGI("[%s]  Test finished with result =%d ", mod->module, mod->result);
  31.     launch_main();
  32.     usleep(100);
  33.     sem_post(&g_sem_mod_complete);
  34. }
  36. void process_exit(void *m, int result) {
  38.     if(m == NULL) {
  39.         MMI_ALOGE("Invalid parameter");
  40.         return;
  41.     }
  43.     module_info *mod = (module_info *) m;
  45.     time(&mod->last_time);
  46.     mod->duration = difftime(mod->last_time, mod->start_time);
  47.     mod->result = result;
  48.     MMI_ALOGI("[%s] Test finished with result=%s, test duration=%f seconds",
  49.               mod->module, MMI_TEST_RESULT(result), mod->duration);
  50.     process_exit(m);
  51. }
  53. static void do_pass(void *m) {
  54.     process_exit(m, SUCCESS);
  55. }
  57. static void do_fail(void *m) {
  58.     sem_post(&g_sem_confirm);
  59.     process_exit(m, FAILED);
  60. }
  62. static func_map_t func_list[] = {
  63.     {"do_cancel", do_cancel},
  64.     {"do_extra_cmd", do_extra_cmd},
  65.     {"do_fail", do_fail},
  66.     {"do_ok", do_ok},
  67.     {"do_report", do_report},
  68.     {"do_page_down", do_page_down},
  69.     {"do_page_up", do_page_up},
  70.     {"do_pass", do_pass},
  71.     {"switch_module", switch_module},
  72.     {"do_reboot", do_reboot},
  73.     {"do_run_all", do_run_all},
  74.     {"do_reset", do_reset},
  75.     {"do_show_fail", do_show_fail},
  76.     {"do_show_all", do_show_all},
  77. #ifdef ANDROID
  78.     {"do_next", do_next},
  79. #endif
  80.     {"do_exit", do_exit},
  81.     {"onchange_poweroff", onchange_poweroff},
  82.     {"onchange_reboot_ffbm", onchange_reboot_ffbm},
  83.     {"onchange_reboot_android", onchange_reboot_android},
  84. };
  86. static unordered_map < string, cb_t > func_map;
  87. void create_func_map() {
  88.     uint32_t i = 0;
  90.     for(i = 0; i < sizeof(func_list) / sizeof(func_map_t); i++) {
  91.         func_map[(string) func_list[i].name] = func_list[i].cb;
  92.     }
  93. }
  95. cb_t get_cb(string func_name) {
  96.     return func_map[func_name];
  97. }
  98. ===============================
  99. # libmmi/common.h
  100. typedef void (*cb_t) (void *);
  101. class module_info {
  102.   public:
  103.     char module[64];
  104.     int socket_fd;
  105.     int result;
  106.     pid_t pid;
  107.     int mode;
  108.     int running_state;
  109.     extra_cmd_t extracmd;
  110.     time_t start_time;          //start test time
  111.     double duration;            //test duration
  112.     time_t last_time;           //last time to modify test result data
  113.     char data[SIZE_512];        //module test data
  115.       unordered_map < string, string > config_list;
  116.       module_info(char *mod) {
  117.         if(mod != NULL)
  118.             strlcpy(module, mod, sizeof(module));
  120.         memset(data, 0, sizeof(data));
  121.         result = INT_MAX;
  122.         pid = -1;
  123.         socket_fd = -1;
  124.         extracmd.is_valid = false;
  125.         running_state = MODULE_IDLE;
  126.     }
  127. };
  129. typedef struct {
  130.     char name[32];
  131.     cb_t cb;
  132. } func_map_t;
  133. ===============================
  134. # mmi/config.cpp
  135. static void parse_button(xmlNodePtr node, button * btn) {
  136.     xmlAttrPtr attr;
  137.     rect_t rect;
  139.     attr = node->properties;
  140.     while(attr != NULL) {
  141.         char *value = (char *) xmlGetProp(node, (const xmlChar *) attr->name);
  143.         if(value != NULL) {
  144.             if(!xmlStrcmp(attr->name, (const xmlChar *) "name")) {
  145.                 btn->set_name(value);
  146.             } else if(!xmlStrcmp(attr->name, (const xmlChar *) "text"))
  147.                 btn->set_text(get_string(value));
  148.             else if(!xmlStrcmp(attr->name, (const xmlChar *) "image")) {
  149.                 btn->set_image(value);
  150.             } else if(!xmlStrcmp(attr->name, (const xmlChar *) "onclick")) { // 这里对应的是值是 do_pass、do_failed 等
  151.                 btn->set_cb(get_cb(value));
  152.             } else if // ...
  153.             } else if(!xmlStrcmp(attr->name, (const xmlChar *) "visibility")) {
  154.                 if(!strcmp("invisible", value))
  155.                     btn->set_visibility(false);
  156.                 else
  157.                     btn->set_visibility(true);
  158.             }
  160.             xmlFree(value);
  161.         }
  163.         attr = attr->next;
  164.     }
  165.     btn->set_rect(&rect);
  166. }

注：fastmmi 的代码看着还是可圈可点的，供学习的地方也很多。这里提到的事件分发和功能组件化映射只是其中的一小部分。

附录：机器上的按键值

  1. getevent -l
  2. ===============================================
  3. add device 5: /dev/input/event3
  4.   name:     "gpio-keys"
  5.   # .
  6. /dev/input/event3: EV_KEY       KEY_F2               DOWN
  7. /dev/input/event3: EV_SYN       SYN_REPORT           00000000
  8. /dev/input/event3: EV_KEY       KEY_F2               UP
  9. /dev/input/event3: EV_SYN       SYN_REPORT           00000000
  10.  #  PTT
  11. /dev/input/event3: EV_KEY       KEY_F1               DOWN
  12. /dev/input/event3: EV_SYN       SYN_REPORT           00000000
  13. /dev/input/event3: EV_KEY       KEY_F1               UP
  14.  #  ..
  15. /dev/input/event3: EV_SYN       SYN_REPORT           00000000
  16. /dev/input/event3: EV_KEY       KEY_F3               DOWN
  17. /dev/input/event3: EV_SYN       SYN_REPORT           00000000
  18. /dev/input/event3: EV_KEY       KEY_F3               UP
  19. /dev/input/event3: EV_SYN       SYN_REPORT           00000000
  20.  # emergency
  21. /dev/input/event3: EV_KEY       KEY_F4               DOWN
  22. /dev/input/event3: EV_SYN       SYN_REPORT           00000000
  23. /dev/input/event3: EV_KEY       KEY_F4               UP
  24. /dev/input/event3: EV_SYN       SYN_REPORT           00000000
  25. ===============================================
  26. add device 3: /dev/input/event2
  27.   name:     "qpnp_pon"
  28.   # trick-power
  29.   旋钮 的 按键电源键（POWER, OK）
  30. /dev/input/event2: EV_KEY       KEY_POWER            DOWN
  31. /dev/input/event2: EV_SYN       SYN_REPORT           00000000
  32. /dev/input/event2: EV_KEY       KEY_POWER            UP
  33. /dev/input/event2: EV_SYN       SYN_REPORT           00000000
  34. ===============================================
  35. add device 4: /dev/input/event1
  36.   name:     "gpiokey-pulley"
  37.   旋钮 相关 ： 音量 上下（OK）
  38.   # anticlockwise
  39. /dev/input/event1: EV_KEY       KEY_VOLUMEUP         DOWN
  40. /dev/input/event1: EV_SYN       SYN_REPORT           00000000
  41. /dev/input/event1: EV_KEY       KEY_VOLUMEUP         UP
  42. /dev/input/event1: EV_SYN       SYN_REPORT           00000000
  43.   # clockwise
  44. /dev/input/event1: EV_KEY       KEY_VOLUMEDOWN       DOWN
  45. /dev/input/event1: EV_SYN       SYN_REPORT           00000000
  46. /dev/input/event1: EV_KEY       KEY_VOLUMEDOWN       UP
  47. /dev/input/event1: EV_SYN       SYN_REPORT           00000000
  48. ===============================================
  49. add device 6: /dev/input/event0
  50.   name:     "aw9523-keys"
  52. ..  ↑  ..
  53.    ← →
  54. 拨号键 电源键
  55. 1   2   3
  56. 4   5   6
  57. 7   8   9
  58. *   0   #
  60. 	# ..
  61. /dev/input/event0: EV_KEY       KEY_ENTER            DOWN
  62. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  63. /dev/input/event0: EV_KEY       KEY_ENTER            UP
  64. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  65.  	#  ↑
  66. /dev/input/event0: EV_KEY       KEY_UP               DOWN
  67. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  68. /dev/input/event0: EV_KEY       KEY_UP               UP
  69. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  70.      # ..
  71. /dev/input/event0: EV_KEY       KEY_BACK             DOWN
  72. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  73. /dev/input/event0: EV_KEY       KEY_BACK             UP
  74. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  75.     # ←
  76. /dev/input/event0: EV_KEY       KEY_LEFT             DOWN
  77. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  78. /dev/input/event0: EV_KEY       KEY_LEFT             UP
  79. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  80.     # →
  81. /dev/input/event0: EV_KEY       KEY_RIGHT            DOWN
  82. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  83. /dev/input/event0: EV_KEY       KEY_RIGHT            UP
  84. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  85.     # 拨号键
  86. /dev/input/event0: EV_KEY       KEY_SEND             DOWN
  87. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  88. /dev/input/event0: EV_KEY       KEY_SEND             UP
  89. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  90.     # ↓
  91. /dev/input/event0: EV_KEY       KEY_DOWN             DOWN
  92. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  93. /dev/input/event0: EV_KEY       KEY_DOWN             UP
  94. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  95.     # 电源键（挂断键）
  96. /dev/input/event0: EV_KEY       KEY_ESC              DOWN
  97. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  98. /dev/input/event0: EV_KEY       KEY_ESC              UP
  99. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  100.     # 1
  101. /dev/input/event0: EV_KEY       KEY_1                DOWN
  102. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  103. /dev/input/event0: EV_KEY       KEY_1                UP
  104. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  105.     # 2
  106. /dev/input/event0: EV_KEY       KEY_2                DOWN
  107. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  108. /dev/input/event0: EV_KEY       KEY_2                UP
  109. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  110.     # 3
  111. /dev/input/event0: EV_KEY       KEY_3                DOWN
  112. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  113. /dev/input/event0: EV_KEY       KEY_3                UP
  114. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  115.     # 4
  116. /dev/input/event0: EV_KEY       KEY_4                DOWN
  117. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  118. /dev/input/event0: EV_KEY       KEY_4                UP
  119. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  120.     # 5
  121. /dev/input/event0: EV_KEY       KEY_5                DOWN
  122. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  123. /dev/input/event0: EV_KEY       KEY_5                UP
  124. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  125.     # 6
  126. /dev/input/event0: EV_KEY       KEY_6                DOWN
  127. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  128. /dev/input/event0: EV_KEY       KEY_6                UP
  129. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  130.     # 7
  131. /dev/input/event0: EV_KEY       KEY_7                DOWN
  132. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  133. /dev/input/event0: EV_KEY       KEY_7                UP
  134. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  135.     # 8
  136. /dev/input/event0: EV_KEY       KEY_8                DOWN
  137. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  138. /dev/input/event0: EV_KEY       KEY_8                UP
  139. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  140.     # 9
  141. /dev/input/event0: EV_KEY       KEY_9                DOWN
  142. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  143. /dev/input/event0: EV_KEY       KEY_9                UP
  144. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  145.     # *
  146. /dev/input/event0: EV_KEY       KEY_NUMERIC_STAR     DOWN
  147. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  148. /dev/input/event0: EV_KEY       KEY_NUMERIC_STAR     UP
  149. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  150.     # 0
  151. /dev/input/event0: EV_KEY       KEY_0                DOWN
  152. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  153. /dev/input/event0: EV_KEY       KEY_0                UP
  154. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  155.     # #
  156. /dev/input/event0: EV_KEY       KEY_NUMERIC_POUND    DOWN
  157. /dev/input/event0: EV_SYN       SYN_REPORT           00000000
  158. /dev/input/event0: EV_KEY       KEY_NUMERIC_POUND    UP
  159. /dev/input/event0: EV_SYN       SYN_REPORT           00000000

在高通Fastmmi模式中增强交互方式的更多相关文章

  1. Android上HDMI介绍（基于高通平台）

    本文重点针对HDMI在android上的应用,而比较相关的就是overlay机制.overlay在这里只是简单的介绍,后续会有文章再专门详述. 我没记错的话,高通从7X30开始,平台就可以支持HDMI ...

  2. 高通平台msm8909 LK 实现LCD 兼容

    前段时间小米出现红米note2 换屏门,现在我们公司也要上演了:有两个供应商提供不同IC 的LCD panel. 软件区分的办法是读取LCD IC 的ID 寄存器,下面解析高通平台LK中LCD兼容的过 ...

  3. 在高通平台Android环境下编译内核模块【转】

    本文转载自:http://blog.xeonxu.info/blog/2012/12/04/zai-gao-tong-ping-tai-androidhuan-jing-xia-bian-yi-nei ...

  4. 高通cDSP简单编程例子（实现查询高通cDSP使用率、签名），RK3588 npu使用率查询

    PS:要转载请注明出处,本人版权所有. PS: 这个只是基于<我自己>的理解, 如果和你的原则及想法相冲突,请谅解,勿喷. 前置说明   本文作为本人csdn blog的主站的备份.(Bl ...

  5. 高通平台FastMMI（FFBM模式）简介与进入方法

    参考: http://blog.csdn.net/tfslovexizi/article/details/51499979 http://www.voidcn.com/blog/jimbo_lee/a ...

  6. 高通方案的Android设备几种开机模式的进入与退出

    高通方案的Android设备主要有以下几种开机模式,Android.EDL.Fastboot.Recovery和FFBM,其进入及退出的方式如下表. 开机模式 屏幕显示 冷启动 热启动 按键退出 命令 ...

  7. 高通电池管理基于qpnp-vm-bms电压模式

    CV:Constant Voltage恒压 SMMB charger:Switch-ModeBattery Charger and Boost peripheral开关模式电池充电器和升压外围设备 O ...

  8. 高通ASOC中的machine驱动

    ASoC被分为Machine.Platform和Codec三大部分,其中的Machine驱动负责Platform和Codec之间的耦合以及部分和设备或板子特定的代码,再次引用上一节的内容:Machin ...

  9. 高通ASOC中的codec驱动

    ASOC的出现是为了让codec独立于CPU,减少和CPU之间的耦合,这样同一个codec驱动就无需修改就可以匹配任何一款平台. 在Machine中已经知道,snd_soc_dai_link结构就指明 ...

  10. 高通Audio中ASOC的machine驱动（一）

    ASoC被分为Machine.Platform和Codec三大部分,其中的Machine驱动负责Platform和Codec之间的耦合以及部分和设备或板子特定的代码,再次引用上一节的内容:Machin ...

随机推荐

  1. C++编程英语词汇

    abstract抽象的 abstraction抽象性.抽象件 access访问 access level访问级别 access function访问函数 adapter适配器 address地址 ad ...

  2. 【爬虫+情感判定+饼图+Top10高频词+词云图】"王心凌"热门弹幕python舆情分析

    目录 一.背景介绍 二.代码讲解-爬虫部分 2.1 分析弹幕接口 2.2 讲解爬虫代码 三.代码讲解-情感分析部分 3.1 整体思路 3.2 情感分析打标 3.3 统计top10高频词 3.4 绘制词 ...

  3. 火山引擎A/B测试平台的实验管理重构与DDD实践

    本次分享的主题是火山引擎数智平台VeDI旗下的A/B测试平台 DataTester 实验管理架构升级与DDD实践.这里说明的一点是,代码的第一目标肯定是满足产品需求,能够满足产品需求的代码都是好代码. ...

  4. 获取list集合中最大值、最小值及索引值

    一.获取最大最小值的同时,获取到最大/小值在list中的索引值 public static void main(String[] args) { List<Integer> numList ...

  5. 热更学习笔记--toLau中lua脚本对C#中枚举和数组的访问

    [8]Lua脚本调用C#中的枚举学习 --调用枚举类型 print("----------------------toLua中调用C#中枚举类型----------------------- ...

  6. java学习之旅（day.05）

    switch多选择结构 多选择结构还有一个实现方式就是switch case switch case 语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支 switch(expression ...

  7. Kubernetes:kubelet 源码分析之探针

    0. 前言 kubernetes 提供三种探针,配置探针(Liveness),就绪探针(Readiness)和启动(Startup)探针判断容器健康状态.其中,存活探针确定什么时候重启容器,就绪探针确 ...

  8. Android 13 - Media框架（2）- Demo App与MediaPlayer Api了解

    关注公众号免费阅读全文,进入音视频开发技术分享群! 尝试用MediaPlayer写了一个播放demo,实现了网络流和本地流的播放.由于本人对app开发一窍不通,所以demo中很多内容是边查资料边写的, ...

  9. 使用 Microsoft Edge WebDriver 自动执行和测试 WebView2 应用 Selenium

    https://learn.microsoft.com/zh-cn/microsoft-edge/webview2/how-to/webdriver

  10. .NET周刊【5月第4期 2024-05-26】

    国内文章 开源低代码框架 ReZero API 正式版本发布 ,界面操作直接生成API https://www.cnblogs.com/sunkaixuan/p/18201175 ReZero是一款. ...