MTK task

喜欢ヅ旅行 2022-09-29 06:03 168阅读 0赞

MTK 的 基本执行单元是task，  
  
从操作系统的角度来理解，task 有些像线程而不是进程，进程之间的地址空间是相互隔离的，说白点就是进程之间的全局变量是不相互干扰的，  
  
而线程之间则是用同一个地址空间，MTK 的task 之间的地址空间也是共同的，也就是在MTK 编程里，定义了一个全局变量，那么在任何一个task里面都能引用，  
  
（这里举个例子，在实际编程过程中最好不要用全局变量，实在没有办法避开，那么全局变量也要分模块化，进行封装， 扯远了)。  
  
所以说，MTK 的task 更像线程，  
  
MTK 用的是实时操作系统 nucleus，是非抢占式操作系统，也就是当高优先级的task 在运行时，底优先级的task是得不到运行时间的，除非等高优先级的task 因为种种原因挂起。  
  
MTK 还有一个跟task 想关的概念 叫 module，它跟task 之间的关系是：一个task 可以对应多个module。task 主要表示是一个执行单元，module 主要是用于传递消息，在MTK 中，消息传递是module 为单位 src\_mod – > des\_mod，而不是以task为单位。  
  
虽然MTK手机，是feature phone(功能机)，不像symbian 6 那样可以同时运行多个应用。但是MTK还是 有许多task组成。平时MTK的后台播放MP3就是一由一个task 完成的。具体以后分析。现在来看看MTK 最主要的task，MMI task，MTK 的应用程序都是在该task里面运行，它有一整套开发MTK 应用的framework。  
  
先来看创建MMI task的函数  
kal\_bool mmi\_create(comptask\_handler\_struct \*\*handle)  
\{  
/\*----------------------------------------------------------------\*/  
/\* Local Variables \*/  
/\*----------------------------------------------------------------\*/  
  
static comptask\_handler\_struct mmi\_handler\_info =  
\{  
MMI\_task, /\* task entry function \*/  
MMI\_Init, /\* task initialization function \*/  
NULL,  
NULL, /\* task reset handler \*/  
NULL, /\* task termination handler \*/  
\};  
  
/\*----------------------------------------------------------------\*/  
/\* Code Body \*/  
/\*----------------------------------------------------------------\*/  
\*handle = &mmi\_handler\_info;  
return KAL\_TRUE;  
\}  
  
这个函数的结构，是MTK 创建task的基本结构，系统初始化时，会调用该函数。看里面的结构体  
typedef struct \{  
kal\_task\_func\_ptr comp\_entry\_func; //task 的入口函数  
task\_init\_func\_ptr comp\_init\_func; //task 的初始化函数  
task\_cfg\_func\_ptr comp\_cfg\_func; //task 的配置函数  
task\_reset\_func\_ptr comp\_reset\_func; //task 的重置函数  
task\_end\_func\_ptr comp\_end\_func; //task 的终止函数  
\} comptask\_handler\_struct;  
  
task 的入口函数是必须的，这个函数告诉系统，初始化完相应的task 控制块后，就要进入该函数来运行。  
  
task 初始化函数，是在进入 task 入口函数之前被调用，用来初始化可能需要的资源，可选。  
  
task 终止函数是，当task 结束是要调用，用来释放资源，可选。  
  
其他两个函数我也不清楚干什么，希望知道的共享下  
  
先看MMI task 的初始化函数.  
MMI\_BOOL MMI\_Init(task\_indx\_type task\_indx)  
\{  
  
//创建一个mutex(互斥体)  
mmi\_mutex\_trace = kal\_create\_mutex("mmi\_trace");  
//这个是初始化 2step 按键， 2step 按键是指 有一些按键具有半按下状态  
//比如照相功能，按下一半进行聚焦，再按下一半拍照  
mmi\_frm\_get\_2step\_keys();  
  
  
//初始化timer，具体可以看 MTK timer 小结 系列  
L4InitTimer();  
  
//初始化 UI 相关信息，里面有许多画点，图等函数  
setup\_UI\_wrappers();  
  
return MMI\_TRUE;  
\}  
  
  
  
初始化函数比较简单。  
  
下面来看MMI 的入口函数，这个函数是整个MMI 运行的核心。  
//为了简单，删除了大部分宏控制程序  
void MMI\_task(oslEntryType \*entry\_param)  
\{  
  
MYQUEUE Message;  
oslMsgqid qid;  
  
U32 my\_index;  
U32 count = 0;  
U32 queue\_node\_number = 0;  
  
// 获得task的外部消息队列id，通过这个id，获得别的task 往MMI task发送的消息  
// MMI task 有两个消息，外部消息队列和内部消息队列  
// 外部消息队列的消息不直接处理，只是简单的存放到内部消息队列，  
// 这样使内部消息队列的优先级稍微高一点  
qid = task\_info\_g\[entry\_param->task\_indx\].task\_ext\_qid;  
mmi\_ext\_qid = qid;  
// 初始化 event 处理函数，这个几个event 必须在获得消息前就进行注册  
// 不让可能使得这个event 丢弃。具体event 事件，下次介绍  
InitEventHandlersBeforePowerOn();  
  
//进入task 的while 循环  
// task 的while(1) 循环使得这个task 不会结束，只有挂起或者运行  
while (1)  
\{  
\{  
// 判断是否有 key 事件需要处理  
if (g\_keypad\_flag == MMI\_TRUE)  
\{  
mmi\_frm\_key\_handle(NULL);  
\}  
  
// 获得外部消息队列里，消息的个数  
msg\_get\_ext\_queue\_info(mmi\_ext\_qid, &queue\_node\_number);  
  
// 如果没有任何消息需要处理(内部消息和外部消息都没有，同时也没有按键需要处理)  
// OslNumOfCircularQMsgs 获得内部消息队列消息的个数  
if ((queue\_node\_number == 0) && (OslNumOfCircularQMsgs() == 0) && (g\_keypad\_flag == MMI\_FALSE))  
\{  
U8 flag = 0;  
ilm\_struct ilm\_ptr;  
  
//去外部消息队列里获得消息，这是一个阻塞函数，也就是说，如果外部消息队列里，  
//没有任何消息，那么这个task 将被阻塞，或者说挂起，也就是不在运行，  
//直到有消息到达，才会被唤醒， 看过操作系统原理的，应该不难理解这个意思和这个本质  
OslReceiveMsgExtQ(qid, &Message);  
  
//如果有消息，获得task 的index  
OslGetMyTaskIndex(&my\_index);  
// 设置该task的获得mod 为MMI mod.  
OslStackSetActiveModuleID(my\_index, MOD\_MMI);  
  
//保存该消息，用于放入到内部队列  
ilm\_ptr.src\_mod\_id = Message.src\_mod\_id;  
ilm\_ptr.dest\_mod\_id = Message.dest\_mod\_id;  
ilm\_ptr.msg\_id = Message.msg\_id;  
ilm\_ptr.sap\_id = Message.sap\_id;  
ilm\_ptr.local\_para\_ptr = Message.local\_para\_ptr;  
ilm\_ptr.peer\_buff\_ptr = Message.peer\_buff\_ptr;  
  
//放入内部队列  
// 这个内部队列是个简单的循环队列  
flag = OslWriteCircularQ(&ilm\_ptr);  
  
// 对 timer 消息进行特殊处理  
if (Message.src\_mod\_id != MOD\_TIMER)  
\{  
hold\_local\_para(ilm\_ptr.local\_para\_ptr);  
hold\_peer\_buff(ilm\_ptr.peer\_buff\_ptr);  
OslFreeInterTaskMsg(&Message);  
\}  
\}  
else  
\{  
// 把外部消息放入到内部消息  
mmi\_frm\_fetch\_msg\_from\_extQ\_to\_circularQ();  
\}  
  
//处理内部消息  
count = OslNumOfCircularQMsgs();  
while (count > 0)  
\{  
OslGetMyTaskIndex(&my\_index);  
OslStackSetActiveModuleID(my\_index, MOD\_MMI);  
  
if (OslReadCircularQ(&Message))  
\{  
CheckAndPrintMsgId((U16) (Message.msg\_id));  
//是否是 wap 的消息  
// 这里就体现了一个task 可以对应多个mod  
if (Message.dest\_mod\_id == MOD\_WAP)  
\{  
  
\}  
  
else  
\{  
switch (Message.msg\_id)  
\{  
//timer 消息 具体看 MTK timer 小结 2  
case MSG\_ID\_TIMER\_EXPIRY:  
\{  
kal\_uint16 msg\_len;  
//处理stack timer消息  
EvshedMMITimerHandler(get\_local\_para\_ptr(Message.oslDataPtr, &msg\_len));  
\}  
break;  
  
  
//开机消息  
//具体分析 见后文  
case MSG\_ID\_MMI\_EQ\_POWER\_ON\_IND:  
\{  
mmi\_eq\_power\_on\_ind\_struct \*p = (mmi\_eq\_power\_on\_ind\_struct\*) Message.oslDataPtr;  
  
/\* To initialize data/time \*/  
SetDateTime((void\*)&(p->rtc\_time));  
gdi\_init();  
  
g\_pwr\_context.PowerOnMMIStatus = MMI\_POWER\_ON\_INDICATION;  
  
switch (p->poweron\_mode)  
\{  
case POWER\_ON\_KEYPAD:  
  
OslMemoryStart(MMI\_TRUE);  
g\_charbat\_context.PowerOnCharger = 0;  
g\_pwr\_context.PowerOnMode = POWER\_ON\_KEYPAD;  
  
  
DTGetRTCTime(&StartUpTime);  
memset(&LastDuration, 0, sizeof(LastDuration));  
mmi\_bootup\_entry\_disk\_check();  
  
break;  
  
  
case POWER\_ON\_PRECHARGE:  
case POWER\_ON\_CHARGER\_IN:  
  
  
g\_pwr\_context.PowerOnMode = p->poweron\_mode;  
InitializeChargingScr();  
if (!g\_charbat\_context.isChargerConnected)  
\{  
QuitSystemOperation();  
\}  
  
  
break;  
  
case POWER\_ON\_ALARM:  
  
  
g\_pwr\_context.PowerOnMode = POWER\_ON\_ALARM;  
  
gdi\_layer\_clear(GDI\_COLOR\_BLACK);  
AlmInitRTCPwron();  
  
break;  
case POWER\_ON\_EXCEPTION:  
  
  
g\_pwr\_context.PowerOnMode = POWER\_ON\_EXCEPTION;  
  
  
gdi\_layer\_clear(GDI\_COLOR\_BLACK);  
OslMemoryStart(MMI\_TRUE);  
SetAbnormalReset();  
InitializeAll();  
OslDumpDataInFile();  
  
ClearInputEventHandler(MMI\_DEVICE\_ALL);  
ClearKeyHandler(KEY\_END, KEY\_LONG\_PRESS);  
  
  
InitNvramData();  
InitAllApplications();  
  
  
mmi\_pwron\_exception\_check\_display();  
  
break;  
default:  
break;  
\}  
\}  
break;  
// event 时间,这个也是MMI task 的一个重点  
default:  
ProtocolEventHandler(  
(U16) Message.oslMsgId,  
(void\*)Message.oslDataPtr,  
(int)Message.oslSrcId,  
(void\*)&Message);  
break;  
\}  
  
\}  
  
OslFreeInterTaskMsg(&Message);  
  
\}  
msg\_get\_ext\_queue\_info(mmi\_ext\_qid, &queue\_node\_number);  
count--;  
\}  
\}  
\}  
\}  
MMI task 的工作方式：从外部队列获取消息放入内部消息队列，内部消息队列根据消息类型注册的回调函数，进行调用(event 机制，这个又是MMI framework的主要部分之一)。  
  
在MTK上，用户(开发人员)可以根据需要，创建task。  
  
创建一个task 分为 4 步：  
  
1 增加一个task index 到 custom\_task\_indx\_type  
  
2 增加一个mod index 到 custom\_module\_type  
  
3 把mod 关联到 相应的 task上，因为一个task 可以对应多个mod，所以需要把mod 挂载到 task上。  
  
(用挂载这个词，应该就比较好理解了，task 是MTK 执行的基本单位，所以一个mod 要能独立运行，就要挂载到某个task 上，为什么不一个mod一个task呢，我想task越多，多系统效率影响就越大。那么就可以考虑互斥的mod 挂载到一个task上，反正互斥的，不会同时需要运行，就像音乐，视频，照相机一样，不会同时运行)  
  
4 创建 task 基本信息 到 custom\_comp\_config\_tbl  
  
下面来具体看一个例子。  
  
1 添加 task index  
typedef enum \{  
INDX\_CUSTOM1 = RPS\_CUSTOM\_TASKS\_BEGIN,  
INDX\_CUSTOM2,  
\#ifdef TASK\_CREATE\_TEST  
INDX\_TASK\_TEST,  
\#endif  
RPS\_CUSTOM\_TASKS\_END  
\} custom\_task\_indx\_type;  
  
  
我们增加了一个 task index INDX\_TASK\_TEST  
  
  
2 添加一个 mod index  
  
  
typedef enum \{  
MOD\_CUSTOM1 = MOD\_CUSTOM\_BEGIN,  
MOD\_CUSTOM2,  
\#ifdef TASK\_CREATE\_TEST  
MOD\_TASK\_TEST,  
\#endif  
MOD\_CUSTOM\_END  
\} custom\_module\_type;  
  
  
  
  
我们增加了一个mod index MOD\_TASK\_TEST  
  
  
3 挂载mod 到 task上  
  
  
custom\_task\_indx\_type custom\_mod\_task\_g\[ MAX\_CUSTOM\_MODS \] =  
\{  
INDX\_CUSTOM1, /\* MOD\_CUSTOM1 \*/  
INDX\_CUSTOM2, /\* MOD\_CUSTOM2 \*/  
\#ifdef TASK\_CREATE\_TEST  
INDX\_TASK\_TEST,  
\#endif  
INDX\_NIL /\* Please end with INDX\_NIL element \*/  
\};  
  
  
  
  
这样就把 MOD\_TASK\_TEST 挂载到 INDX\_TASK\_TEST上面了，这里的映射关系是通过index 来控制的，也就是说要的到MOD\_TASK\_TEST 对应的 task index，只要这样 task index = custom\_mod\_task\_g\[MOD\_TASK\_TEST\]; ，所以创建过程中，顺序一定要对应好，不然容易出错。  
  
  
4 创建task 信息  
  
  
const comptask\_info\_struct custom\_comp\_config\_tbl\[ MAX\_CUSTOM\_TASKS \] =  
\{  
/\* INDX\_CUSTOM1 \*/  
\{"CUST1", "CUST1 Q", 210, 1024, 10, 0,  
\#ifdef CUSTOM1\_EXIST  
custom1\_create, KAL\_FALSE  
\#else  
NULL, KAL\_FALSE  
\#endif  
\},  
  
/\* INDX\_CUSTOM2 \*/  
\{"CUST2", "CUST2 Q", 211, 1024, 10, 0,  
\#ifdef CUSTOM2\_EXIST  
custom2\_create, KAL\_FALSE  
\#else  
NULL, KAL\_FALSE  
\#endif  
\},  
\#ifdef TASK\_CREATE\_TEST  
/\* INDX\_TASK\_TEST \*/  
\{"TAST\_TEST", "TASK\_TEST Q", 212, 1024, 10, 0,  
task\_test\_create, KAL\_FALSE  
\},  
\#endif  
  
\};  
  
  
  
  
这样就创建好了task 的信息，这里说task 需要的信息  
  
  
typedef struct \{  
kal\_char \*comp\_name\_ptr; //task 的name  
kal\_char \*comp\_qname\_ptr; //外部队列name  
kal\_uint32 comp\_priority; //优先级  
kal\_uint16 comp\_stack\_size; //stack 大小  
kal\_uint8 comp\_ext\_qsize; //外部队列大小  
kal\_uint8 comp\_int\_qsize; //内部队列大小  
kal\_create\_func\_ptr comp\_create\_func; //task 创建函数  
kal\_bool comp\_internal\_ram\_stack; //是否是internal\_ram\_stack  
\} comptask\_info\_struct;  
  
  
task 的优先级是数值越大，优先级越低。由于是MTK 用的是实时操作系统，高优先级的task 只要需要，就会先运行，一直运行，所以task的优先级定义时需要考虑清楚。comp\_internal\_ram\_stack 表示是否使用internal ram stack，internal ram 相对速度要快，但是数量很有限，一般自己创建的不要去使用，容易引起问题。