MTK MMI event 小结 8

最新推荐文章于 2021-01-12 14:42:03 发布
最新推荐文章于 2021-01-12 14:42:03 发布
阅读量2k 收藏 1
点赞数
分类专栏： MTK 手机 文章标签： mtk callback table timer character delay
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanwuxufeng/article/details/5803215
版权

在 MTK MMI event 小结 7 中，说到，init 时候， 注册了触摸屏消息MSG_ID_TP_EVENT_IND 的处理函数 mmi_pen_touch_panel_event_ind，

static void mmi_pen_touch_panel_event_ind(void *param )
{
     // 这个用于控制 只有一个 MSG_ID_TP_EVENT_IND 在 消息队列里
     g_pen_is_driver_indication_in_queue = 0;
    // 判断是否启动了timer 在定时读取 pen event 缓存
    if (!g_pen_polling_timer_started)
    {
       //真正的处理函数
        mmi_pen_poll_hdlr();
    }
}

这个函数其实没有做什么真正的处理，只是简单的判断的了一下是否要处理这个消息。这里需要注意的是， 跟按键事件不同的是，这里通过timer来控制处理 pen event 消息缓存里剩余的消息， 按键事件 是在 MMI task 消息循环里，直接调用 按键事件的处理函数。从要实现的效果上没有什么太多的区别。 
static void mmi_pen_poll_hdlr(void)
{
    TouchPanelEventStruct data;
    MMI_BOOL is_stroke_move = MMI_FALSE;
    MMI_BOOL has_incoming_event = MMI_FALSE;
    MMI_BOOL delay_polling_timer = MMI_FALSE;
    MMI_BOOL pen_abort_happen = MMI_FALSE;
    U16      interval = 0;

    
    g_pen_polling_timer_started = MMI_FALSE;
    ResetBit(g_input_msg_in_queue, MMI_DEVICE_PEN);

    
    // 判断 pen event 是否开启，按键和pen 是冲突的。
    if (!g_pen_cntx.is_enabled)
    {
        return;
    }
    
    // 判断是否还有数据要处理
    // delay_polling_timer 表示是否启动了timer，来稍后处理这些pen event 事件，开始时初始化为 false
    while (!delay_polling_timer && mmi_pen_lookahead_buffer_get_event(&data))
    {       
        mmi_pen_point_struct pos;

        // 检测背光情况，是否要开启
        mmi_idle_key_event_backlight_check();
        // 重置 屏幕保护和键盘锁的时间
        mmi_idle_restart_screensaver_timer();
        mmi_idle_restart_keypad_lock_timer();

        // 获取 x，y。坐标点
        pos.x = (S16) data.x_adc;
        pos.y = (S16) data.y_adc;


	


        has_incoming_event = MMI_TRUE;

    #ifdef __MMI_TOUCH_PANEL_SHORTCUT__
        if(!mmi_pen_check_tp_shortcut(&pos, data.event))
    #endif /* __MMI_TOUCH_PANEL_SHORTCUT__ */
        {
            // 判断 是否是 stroke move 事件结束
            // is_stroke_move 表示前一个pen event 事件是否是 stroke move
            if (is_stroke_move && (data.event != STROKE_MOVE))
            {
                is_stroke_move = MMI_FALSE;
                // 这个函数眼熟吧
                if (g_pen_stroke_post_move)
                {
                    g_pen_stroke_post_move();
                }
            }
            // 保存现在状态
            g_pen_cntx.pen_current_pos = pos;
            g_pen_cntx.pen_event = data.event;
    
            switch (data.event)
            {
                    
                case PEN_DOWN:
                   
                    g_pen_cntx.is_pen_down = 1;
                    g_pen_cntx.is_in_pen_handler = 1;

                    // 计算最近两次 点击事件的 事件间隔
                    // 这里这么判断是当时间溢出 short的时候，需要特殊处理
                    if (g_pen_cntx.previous_pen_down_time > data.time_stamp)
                    {
                        interval = 0XFFFF - g_pen_cntx.previous_pen_down_time + data.time_stamp;
                    }
                    else
                    {
                        interval = data.time_stamp - g_pen_cntx.previous_pen_down_time;
                    }

                    //判断两次pen down 的时间是否足够短，间隔距离足够短，从而判断是否是 双击
                    if ((interval <= MMI_PEN_DOUBLE_CLICK_THRESHOLD) && 
                        (mmi_pen_get_distance_square(g_pen_cntx.pen_down_pos, pos) < MMI_PEN_SKIP_DOUBLE_CLICK_OFFSET_SQUARE))
                    {                        
                        if (g_pen_event_table[MMI_PEN_EVENT_DOUBLE_CLICK] && g_pen_cntx.is_enabled)
                        {
                            // 前置处理函数
                            MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_EVENT_DOUBLE_CLICK);
                            // 回调double click 注册函数
                            (g_pen_event_table[MMI_PEN_EVENT_DOUBLE_CLICK]) (pos);
                            // 后置处理函数
                            MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_EVENT_DOUBLE_CLICK);
                           
                        } 

                        g_pen_cntx.previous_pen_down_time = 0;
                    }
                    else
                    {
                        g_pen_cntx.previous_pen_down_time = data.time_stamp;
                    }

                    g_pen_cntx.pen_down_pos = pos;
                    
                    
                    if (g_pen_event_table[MMI_PEN_EVENT_DOWN] && g_pen_cntx.is_enabled)
                    {
                       // 前置处理函数
                        MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_EVENT_DOWN);
                        // 回调pen down注册函数
                        (g_pen_event_table[MMI_PEN_EVENT_DOWN]) (pos);
                        // 后置处理函数
                        MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_EVENT_DOWN);
                      
                    }
                   

                    break;
                    
                case PEN_UP:
                    
                    g_pen_cntx.is_pen_down = 0;

                   
                    if (g_pen_event_table[MMI_PEN_EVENT_UP] && g_pen_cntx.is_enabled)
                    {
                       
                        MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_EVENT_UP);
                        (g_pen_event_table[MMI_PEN_EVENT_UP]) (pos);
                        MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_EVENT_UP);
                        
                    }
                   
                   
                    // 判断是否要进行pen event reset
                    if (g_pen_cntx.reset_stroke_on_pen_up)
                    {
                        // 判读是否有 stroke event
                        if (g_pen_stroke_max_points > 0)
                        {  
                            // 结束 stroke event，注意，stroke event 会把所有的点push到一个数组里，供注册的程序使用，当然这个数组大小也是程序设定的。这里设置结束标志。
                            mmi_pen_end_strokes_of_character();
                            mmi_pen_reset();
                            mmi_pen_begin_strokes_of_character();
                        }
                        else
                        {
                            mmi_pen_reset();
                        }
                    }
    
                    // 一对 down move up 后，即时还有pen事件，通过timer 来取下一组信息
                    delay_polling_timer = MMI_TRUE;
    
                    
                    g_pen_cntx.is_in_pen_handler = 0;
                    g_pen_cntx.pen_event = TP_UNKNOWN_EVENT;
                    break;
                    
                case PEN_MOVE:
                    
                    if (g_pen_event_table[MMI_PEN_EVENT_MOVE] && g_pen_cntx.is_enabled)
                    {
                       
                        MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_EVENT_MOVE);
                        (g_pen_event_table[MMI_PEN_EVENT_MOVE]) (pos);
                        MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_EVENT_MOVE);
                        
                    }

                 
                    
                    break;
                    
                case PEN_LONGTAP:
                   
                    if (g_pen_event_table[MMI_PEN_EVENT_LONG_TAP] && g_pen_cntx.is_enabled)
                    {
                      
                        MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_EVENT_LONG_TAP);
                        (g_pen_event_table[MMI_PEN_EVENT_LONG_TAP]) (pos);
                        MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_EVENT_LONG_TAP);
                       
                    }

                  
                    
                    break;
                    
                case PEN_REPEAT:
                   
                    if (g_pen_event_table[MMI_PEN_EVENT_REPEAT])
                    {
                       
                        MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_EVENT_REPEAT);
                        (g_pen_event_table[MMI_PEN_EVENT_REPEAT]) (pos);
                        MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_EVENT_REPEAT);
                       
                    }
                    
                   
                    
                    break;
                    
                case PEN_ABORT:
                   
					pen_abort_happen = MMI_TRUE;
			        g_pen_drvq_full_abort = MMI_TRUE;
                    mmi_pen_reset();
                    break;
                    
                case TP_UNKNOWN_EVENT:
                    MMI_ASSERT(0);
                    break;
                    
                case STROKE_MOVE:
                   
                   
                    // 这个主要是用于当只有一个手写区域时使用
                    if (g_pen_cntx.is_pending_stroke_event)
                    {
                        // 判断是第一stroke move点是否符合标准（最小距离）
                        if (mmi_pen_get_distance_square(g_pen_cntx.pen_down_pos, pos) > g_pen_stroke_min_offset_square)
                        {
                            g_pen_cntx.is_pending_stroke_event = 0;
                            g_pen_stroke_min_offset_square = 0; 
                            g_pen_cntx.reset_stroke_on_pen_up = 0;
                            g_pen_cntx.pen_event = PEN_ABORT;
    
                            // 先产生 pen_abort 事件，告诉应用普通的pen 事件被中断，也就是光有pen down 没有pen up事件了
                            if (g_pen_event_table[MMI_PEN_EVENT_ABORT]&& g_pen_cntx.is_enabled)
                            {
                                
                                MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_EVENT_ABORT);
                                (g_pen_event_table[MMI_PEN_EVENT_ABORT]) (g_pen_cntx.pen_down_pos);
                                MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_EVENT_ABORT);
                               
                            }
    
                            g_pen_cntx.pen_event = STROKE_DOWN;

                            // 把 stroke down 时间事件 保存到数组里
                            mmi_pen_push_stroke_point(g_pen_cntx.pen_down_pos.x, g_pen_cntx.pen_down_pos.y);
                            // 发送 stroke down 事件
                            if (g_pen_stroke_table[MMI_PEN_STROKE_DOWN] && g_pen_cntx.is_enabled)
                            {
                                
                                MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_STROKE_DOWN);
                                (g_pen_stroke_table[MMI_PEN_STROKE_DOWN]) (g_pen_cntx.pen_down_pos);
                                MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_STROKE_DOWN);
                               
                            }
                           
                            g_pen_cntx.pen_event = STROKE_MOVE;
                            
                            // 预处理
                            is_stroke_move = MMI_TRUE;
                            if (g_pen_stroke_pre_move)
                            {
                                g_pen_stroke_pre_move();
                            }
                            
                            // 发送 stroke move
                            mmi_pen_push_stroke_point(pos.x, pos.y);
                            if (g_pen_stroke_table[MMI_PEN_STROKE_MOVE] && g_pen_cntx.is_enabled)
                            {
                               
                                MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_STROKE_MOVE);
                                (g_pen_stroke_table[MMI_PEN_STROKE_MOVE]) (pos);
                                MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_STROKE_MOVE);
                                
                            }
                        }
                    }
                    else
                    {
                        // 判断在哪个区域里面
                        if (g_pen_num_stroke_area > 1)
                        {
                            mmi_pen_fix_multi_block_pen_position(&pos);
                        }
                        
                        // 预处理
                        if (!is_stroke_move)
                        {
                            is_stroke_move = MMI_TRUE;
                            if (g_pen_stroke_pre_move)
                            {
                                g_pen_stroke_pre_move();
                            }
                        }
                        // 保存 stroke move 并发送
                        mmi_pen_push_stroke_point(pos.x, pos.y);
                        if (g_pen_stroke_table[MMI_PEN_STROKE_MOVE] && g_pen_cntx.is_enabled)
                        {
                           
                            MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_STROKE_MOVE);
                            (g_pen_stroke_table[MMI_PEN_STROKE_MOVE]) (pos);
                            MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_STROKE_MOVE);
                           
                        }
                    }
                    break;
                    
                case STROKE_DOWN:
                   
                   
                    g_pen_cntx.is_stroke_down = 1;
                    g_pen_cntx.is_pen_down = 1;
                    g_pen_cntx.pen_down_pos = pos;
    
                    g_pen_cntx.stroke_down_block_index = mmi_pen_lookup_handwriting_block(pos.x, pos.y);
                    
    
                    // 单个区域特殊处理
                    if (g_pen_stroke_min_offset_square > 0)
                    {
                        g_pen_cntx.is_pending_stroke_event = 1;
                        g_pen_cntx.pen_event = PEN_DOWN;
    
                        
                        if (g_pen_event_table[MMI_PEN_EVENT_DOWN] && g_pen_cntx.is_enabled)
                        {
                            
                            MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_EVENT_DOWN);
                            (g_pen_event_table[MMI_PEN_EVENT_DOWN]) (g_pen_cntx.pen_down_pos);
                            MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_EVENT_DOWN);
                           
                        }
                    }
                    else
                    {
                        g_pen_cntx.is_pending_stroke_event = 0;
                        g_pen_cntx.pen_event = STROKE_DOWN;
    
                        if (g_pen_stroke_table[MMI_PEN_STROKE_DOWN] && g_pen_cntx.is_enabled)
                        {
                           
                            MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_STROKE_DOWN);
                            (g_pen_stroke_table[MMI_PEN_STROKE_DOWN]) (pos);
                            MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_STROKE_DOWN);
                            
                        }
                        
                       
                        if (g_pen_cntx.is_enabled && g_pen_cntx.is_pen_down && g_pen_stroke_max_points > 0)
                        {
                            mmi_pen_push_stroke_point(pos.x, pos.y);
                        }                    
                    }
                    

                    break;
                    
                case STROKE_UP:
                   
                    MMI_DBG_ASSERT(g_pen_stroke_max_points > 0);
                    g_pen_cntx.is_stroke_down = 0;
                    g_pen_cntx.is_pen_down = 0;
    
                    

                    if (g_pen_cntx.is_pending_stroke_event)
                    {
                        g_pen_cntx.is_pending_stroke_event = 0;
    
                        
                        g_pen_cntx.reset_stroke_on_pen_up = 1;
                        g_pen_cntx.pen_event = PEN_UP;
    
                        
                        if (g_pen_event_table[MMI_PEN_EVENT_UP] && g_pen_cntx.is_enabled)
                        {
                           
                            MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_EVENT_UP);
                            (g_pen_event_table[MMI_PEN_EVENT_UP]) (g_pen_cntx.pen_down_pos);
                            MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_EVENT_UP);
                           
                        }
    
                       
                        delay_polling_timer = MMI_TRUE;
                    }
                    else
                    {
                        
                        g_pen_cntx.pen_event = STROKE_UP;
                        if (g_pen_num_stroke_area > 1)
                        {
                            mmi_pen_fix_multi_block_pen_position(&pos);
                        }
                        
                        mmi_pen_push_stroke_end();
                        if (g_pen_stroke_table[MMI_PEN_STROKE_UP] && g_pen_cntx.is_enabled)
                        {
                            
                            MMI_PEN_EXECUTE_PRE_CALLBACK_FUNC(MMI_PEN_STROKE_UP);
                            (g_pen_stroke_table[MMI_PEN_STROKE_UP]) (pos);
                            MMI_PEN_EXECUTE_POST_CALLBACK_FUNC(MMI_PEN_STROKE_UP);
                           
                        }
                    }
    
                   
                    if (g_pen_cntx.reset_stroke_on_pen_up)
                    {
                        if (g_pen_stroke_max_points > 0)
                        {
                            mmi_pen_end_strokes_of_character();
                            mmi_pen_reset();
                            mmi_pen_begin_strokes_of_character();
                        }
                        else
                        {
                            mmi_pen_reset();
                        }
                    }
                   

                    /* leave pen handler procedure */
                    g_pen_cntx.is_in_pen_handler = 0;
                    g_pen_cntx.pen_event = TP_UNKNOWN_EVENT;
    
                    break;
    
                
                
                default:
                    MMI_ASSERT(0);
            }
    
        } /* if(!mmi_pen_check_tp_shortcut(&pos, data.event)) */

        // 把外部消息放入到内部循环消息队列
        mmi_frm_fetch_msg_from_extQ_to_circularQ();
        
        OslCircularDump();
        // 如果内部消息积压大于 MMI_PENDING_MSG_THRESHOLD，就跳出循环，进行处理
        if (OslNumOfCircularQMsgs() > MMI_PENDING_MSG_THRESHOLD)
        {
           
            break; 
        }
        
    }

    if (is_stroke_move)
    {
        if (g_pen_stroke_post_move)
        {
            g_pen_stroke_post_move();
        }
    }


    if (has_incoming_event)
    {
        if (!mmi_shutdown_is_in_power_off_period())
        {
            mmi_idle_key_event_backlight_check();
        }
   
    }

    if (g_pen_cntx.is_in_pen_handler == 0)
    {
        g_pen_cntx.pen_event = TP_UNKNOWN_EVENT;
    }
   
    // 启动定时期
    if (delay_polling_timer)
    {
       
        StartTimer(PEN_POLLING_TIMER, MMI_PEN_DEBOUNCE_POLLING_DELAY, mmi_pen_poll_hdlr);
        g_pen_polling_timer_started = MMI_TRUE;
        SetBit(g_input_msg_in_queue, MMI_DEVICE_PEN);

       
    }
    else if (g_pen_cntx.is_pen_down || pen_abort_happen)
    {
        
       
        StartTimer(PEN_POLLING_TIMER, MMI_PEN_POLLING_PERIOD, mmi_pen_poll_hdlr);
        g_pen_polling_timer_started = MMI_TRUE;
        SetBit(g_input_msg_in_queue, MMI_DEVICE_PEN);
        if(pen_abort_happen)
        {
            pen_abort_happen = MMI_FALSE;
        }
    }
}

这里其实也是比较简单：

1： 取pen event 事件

2： 根据时间类型处理事件

3：是否有额外消息要处理，是 退出，否继续 1

这里有点点复杂的是手写输入法，这个事件比较乱，全局变量一堆，分析起来比较头疼。

yanwuxufeng
关注
专栏目录
MTK_MMI.rar_mtk mmi
09-14
MTK MMI，全称为MediaTek Multimedia Interface，是联发科（Mediatek）推出的一种多媒体交互接口，主要用于其芯片平台上的设备与应用之间的通信。这个技术涵盖了多种功能，旨在优化移动设备的多媒体体验，包括音频、...
利用tsne可视化结果，点击出现对应的句子
weixin_48262500的博客
06-30 261
利用tsne可视化结果，点击出现对应的句子
python绘制多个散点图_python – 从具有多个数据集的散点图获取x,y？
weixin_39912566的博客
11-23 555
我有一个散点图,它由不同的散射调用组成：import matplotlib.pyplot as pltimport numpy as npdef onpick3(event):index = event.indprint '--------------'print indexartist = event.artistprint artistfig_handle = plt.figure()x,y ...
MMI小结
dengdeng86的专栏
01-30 616
1. 熟悉并研习了部分Android的App, App Framework, lib, Runtime, kernel的架构与代码。 2. 了解并一定程度上掌握了对应于java, native C/C++, JVM, Dalvik VM协作异构开发的流程与操作处理方案。 3. Git & Subversion 4. 整套的持续集成版本控制方案和操作： jekin, Git, Ger
MTK平台学习----消息通讯机制
xiaoweiboy的专栏
09-18 4949
一、基础知识         使用消息循环机制之前，我们先来认识几个数据结构          typedef struct ilm_struct            {                     module_type
MTK MMI event 小结 5
懒人
08-06 3338
昨天说了一下key event 的基本情况，今天直接从代码开始吧 先看执行key event 函数 mmi_frm_key_handle   void mmi_frm_key_handle(void *paraBuff) { kbd_data k; U32 msg_count; mmi_eq_keypad_detect_ind_struct *p; // 判断参数是否为空 // 在 初始化时，系统就注册了 MSG_ID
MMI.rar_mtk mmi
最新发布
09-24
标题中的"MMI.rar_mtk mmi"表明这是一个关于MTK（MediaTek） MMI（Man Machine Interface，人机交互界面）技术的压缩包文件。这个压缩包可能包含了关于如何理解和使用MTK平台上的MMI的相关教程或参考资料。描述中...
mtk_MMI.rar_mtk_mtk mmi
09-22
【标题】：MTK MMI（多媒体接口）基础学习资料 【描述】：这份压缩包包含的是关于MTK MMI（MediaTek Multimedia Interface）的基础教程，专为初学者设计，旨在帮助新接触这一领域的学习者理解MMI层的工作原理和功能...
MTK.rar_mmi_mtk_mtk mmi
09-23
本压缩包“MTK.rar_mmi_mtk_mtk mmi”包含了一份关于MTK（MediaTek）平台的 MMI（Man Machine Interface）实例培训教程，主要针对想要深入理解和应用MMI技术在MTK芯片上的开发人员。MMI是人机交互界面，是设备与用户...
MTK_MMI_TRAINING.rar_mmi_mtk_mtk mmi
09-19
MTK MMI（Mediatek Multimedia Interface）是联发科（Mediatek）为开发者提供的一种图形用户界面（GUI）开发框架，主要用于设计和实现移动设备上的用户交互界面。这个"MTK MMI TRAINING.rar"压缩包包含了一份完整的...
交互性(Interactivity)
weixin_30378623的博客
03-09 1453
1 plt.figure() 2 data = np.random.rand(10) 3 plt.plot(data) 4 #创建点击事件 5 def onclick(event): 6 plt.cla() 7 plt.plot(data) 8 plt.gca().set_title('Event at pixels {},{} \nand...
matplotlib对象拾取事件处理
热门推荐
mighty13的专栏
01-12 1万+
前面讲到的众多数据光标案例其实都用到了matplotlib的pick_event事件（拾取事件），该事件表示画布中的对象被选中，该事件默认是禁用的，需要artist（数据元素，例如Line2D, Text, Patch, Polygon, AxesImage等）设置picker属性才会启用。 picker属性 picker属性有多种取值： None：默认值，表示禁用 pick_event事件。 布尔值：如果为True，则启用事件，当鼠标移动到该数据元素上方时触发事件。 数值：如果取值是数值，则可以认为将该
MTK MMI event
折翼飞翔
11-16 2278
转自：http://blog.csdn.net/yanwuxufeng/article/details/5808309 在MTK MMI里面有各种event，最常见的跟交互相关的按键event，触摸屏event。跟各种具体事件相关的比如电话event，短信event，电量event，信号量event，timer event等等。MTK都有相应的处理方式，跟交互相关的按键(KeyBrd.c)和
MTK MMI event 小结 6
懒人
08-08 3450
在 MTK MMI event 小结 5 中，提到了event 处理函数 mmi_frm_key_handle，这个函数主要作用是判断是否需要处理按键，从按键缓存里面持续的读取按键信息，然后调用 mmi_frm_convert_process_key_event 进行处理。这个函数没有什么可说的，最多是在屏幕旋转的情况下，把 导航键 转换一下，接着它调用了 ProcessKeyEvent， 这个函数主要是对于一些状态的处理，防止key down 和up 不成对，出现混乱。 void P
MTK MMI event 小结 9
懒人
08-12 1998
到这里 pen event 其实也就差不多了，说一下几个常用的函数： mmi_pen_enable /mmi_pen_disable  //打开/关闭 pen 事件 mmi_pen_set_calibration_data / mmi_pen_read_calibration_data  //设置和读取校准数据，校准数据总共四个值 x = x*x_scale + x_offset, y = y*y_scale + y_offset mmi_pen_start_calibration 
python读取excel画散点图对应多个y_从包含多个数据集的散点图中获取x，y？
weixin_39758392的博客
11-23 722
我有一个散点图，由不同的分散调用组成：import matplotlib.pyplot as pltimport numpy as npdef onpick3(event):index = event.indprint '--------------'print indexartist = event.artistprint artistfig_handle = plt.figure()x,y =...
matplotlib键盘鼠标事件（tcy）
tcy-阿春
12-03 1万+
键盘鼠标事件:2018/10/24 https://matplotlib.org/users/event_handling.html?highlight=event%20inaxes --------------------------------------------------------------------------------- 1.1.鼠标事件 # 当鼠标在子图...
MTK MMI event 小结 7
懒人
08-09 3514
到这，key event 的处理基本上就算完成了。其他几个常用的函数注册key 处理函数了。了解了按键event的处理过程之后(其实也是比较简单的)，注册函数就很好了解了，就是把相应key 和 event 的数组里放入一个回调函数的指针。比如 void SetKeyHandler(FuncPtr funcPtr, U16 keyCode, U16 keyType) 抛开其他语句，就是一句简单的实现currKeyFuncPtrs[keyCode][keyType] = funcPtr; 还有可以
MTK 内存管理简单总结
懒人
07-12 9380
<br />MTK 手机用的操作系统是 nucleus, 这是一个rtfs(实时操作系统)，这个rtfs本身是不带内存管理功能，所以MTK自己写的内存管理。<br />(nucleus在系统初始化完毕时，会调用Application_Initialize，参数就是可使用内存的起始地址)<br /> <br />大体上来分，MTK内存可以分为3种：control buffer<br />平常使用的OslMalloc就是这个内存。<br />这个内存内部实现是按块来划分的(pool)，具体的配置可以custom
MTK MMI架构解析与任务结构
"MTK MMI架构概述" MTK MMI（Mobile Multimedia Interface）架构是MediaTek公司设计的一种用于移动设备的操作系统和服务交互的框架。这个架构旨在有效地管理设备中的多个任务和组件，确保系统的稳定运行和高效的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值