blob: 9a24a57f9f08d8c8b49652c681b5883d00a51e37
1 | |
2 | #include "CHDMIRxCEC.h" |
3 | #include <fcntl.h> |
4 | #include <sys/ioctl.h> |
5 | #include <errno.h> |
6 | #include <CTvLog.h> |
7 | |
8 | #include "../tvconfig/tvconfig.h" |
9 | |
10 | #define CC_ENABLE_PRINT_MESSAGE (0) |
11 | |
12 | #define CS_HDMIRX_CEC_PATH "/dev/hdmirx0" |
13 | |
14 | CHDMIRxCEC::CHDMIRxCEC() |
15 | { |
16 | int i = 0; |
17 | |
18 | for (i = 0; i < CC_REQUEST_LIST_SIZE; i++) { |
19 | ClrReplyListItem(&mReplyList[i]); |
20 | memset((void *) &mMsgBuf[i], 0, sizeof(struct _cec_msg)); |
21 | } |
22 | |
23 | mModuleEnableFlag = -1; |
24 | mRequestPause = false; |
25 | mState = STATE_STOPED; |
26 | |
27 | mpObserver = NULL; |
28 | |
29 | for (i = 0; i < CC_SOURCE_DEV_REFRESH_CNT; i++) { |
30 | mSourceDevLogicAddrBuf[i] = -1; |
31 | mSourceDevRefreshBuf[i] = -1; |
32 | } |
33 | |
34 | mSourceDevLogicAddrBuf[0] = E_LA_TV; |
35 | mSourceDevLogicAddrBuf[1] = E_LA_TV; |
36 | mSourceDevLogicAddrBuf[2] = E_LA_TV; |
37 | |
38 | mSourceDevRefreshBuf[0] = E_LA_PLAYBACK1; |
39 | mSourceDevRefreshBuf[1] = E_LA_PLAYBACK2; |
40 | mSourceDevRefreshBuf[2] = E_LA_PLYBACK3; |
41 | } |
42 | |
43 | CHDMIRxCEC::~CHDMIRxCEC() |
44 | { |
45 | } |
46 | |
47 | int CHDMIRxCEC::start() |
48 | { |
49 | CMutex::Autolock _l (mLock); |
50 | |
51 | if (GetModuleEnableFlag() == 0) { |
52 | return -1; |
53 | } |
54 | |
55 | if (mState == STATE_STOPED) { |
56 | this->run(); |
57 | } |
58 | |
59 | return mState; |
60 | } |
61 | |
62 | int CHDMIRxCEC::stop() |
63 | { |
64 | CMutex::Autolock _l (mLock); |
65 | |
66 | if (GetModuleEnableFlag() == 0) { |
67 | return -1; |
68 | } |
69 | |
70 | if (mState == STATE_PAUSE) { |
71 | resume(); |
72 | } |
73 | |
74 | requestExit(); |
75 | mState = STATE_STOPED; |
76 | return mState; |
77 | } |
78 | |
79 | int CHDMIRxCEC::pause() |
80 | { |
81 | CMutex::Autolock _l (mLock); |
82 | |
83 | if (GetModuleEnableFlag() == 0) { |
84 | return -1; |
85 | } |
86 | |
87 | mRequestPause = true; |
88 | return 0; |
89 | } |
90 | |
91 | int CHDMIRxCEC::resume() |
92 | { |
93 | CMutex::Autolock _l (mLock); |
94 | |
95 | if (GetModuleEnableFlag() == 0) { |
96 | return -1; |
97 | } |
98 | |
99 | ClearRxMessageBuffer(); |
100 | |
101 | mRequestPause = false; |
102 | mPauseCondition.signal(); |
103 | |
104 | ClearRxMessageBuffer(); |
105 | return 0; |
106 | } |
107 | |
108 | int CHDMIRxCEC::isAllowOperate(int source_input) |
109 | { |
110 | if (GetModuleEnableFlag() == 0) { |
111 | return -1; |
112 | } |
113 | |
114 | int source_port = CTvin::Tvin_GetSourcePortBySourceInput((tv_source_input_t)source_input); |
115 | if (CTvin::getInstance()->VDIN_GetPortConnect(source_port) == false) { |
116 | return -1; |
117 | } |
118 | |
119 | return 0; |
120 | } |
121 | |
122 | int CHDMIRxCEC::GetModuleEnableFlag() |
123 | { |
124 | const char *config_value = NULL; |
125 | |
126 | if (mModuleEnableFlag < 0) { |
127 | config_value = config_get_str(CFG_SECTION_TV, "tvin.hdmirx.cec.enable", "null"); |
128 | if (strcasecmp(config_value, "null") == 0) { |
129 | mModuleEnableFlag = 0; |
130 | } else if (strcasecmp(config_value, "1") == 0 || strcasecmp(config_value, "true") == 0) { |
131 | mModuleEnableFlag = 1; |
132 | } else { |
133 | mModuleEnableFlag = 0; |
134 | } |
135 | } |
136 | |
137 | return mModuleEnableFlag; |
138 | } |
139 | |
140 | int CHDMIRxCEC::PrintMessage(const char *func_name, int data_type, struct _cec_msg *msg) |
141 | { |
142 | #ifdef CC_ENABLE_PRINT_MESSAGE |
143 | if (msg == NULL) { |
144 | LOGE("%s, msg is NULL\n", func_name); |
145 | return -1; |
146 | } |
147 | |
148 | LOGD("%s, msg_len = %d\n", func_name, msg->msg_len); |
149 | LOGD("%s, msg addr 0x%02X\n", func_name, msg->addr); |
150 | LOGD("%s, msg cmd 0x%02X\n", func_name, msg->cmd); |
151 | for (int i = 0; i < msg->msg_len - 2; i++) { |
152 | if (data_type == 0) { |
153 | LOGD("%s, msg data[%d] = 0x%02X\n", func_name, i, msg->msg_data[i]); |
154 | } else { |
155 | LOGD("%s, msg data[%d] = %c\n", func_name, i, msg->msg_data[i]); |
156 | } |
157 | } |
158 | #endif |
159 | return 0; |
160 | } |
161 | |
162 | int CHDMIRxCEC::ClrReplyListItem(HDMIRxRequestReplyItem *reply_item) |
163 | { |
164 | if (reply_item == NULL) { |
165 | return -1; |
166 | } |
167 | |
168 | reply_item->WaitCmd = 0; |
169 | reply_item->WaitLogicAddr = 0; |
170 | reply_item->WaitTimeOut = 0; |
171 | reply_item->WaitFlag = 0; |
172 | reply_item->DataFlag = 0; |
173 | memset((void *) & (reply_item->msg), 0, sizeof(struct _cec_msg)); |
174 | |
175 | return 0; |
176 | } |
177 | |
178 | int CHDMIRxCEC::CopyMessageData(unsigned char data_buf[], unsigned char msg_data[], int msg_len) |
179 | { |
180 | if (data_buf == NULL) { |
181 | return 0; |
182 | } |
183 | |
184 | memset((void *)data_buf, 0, CC_CEC_STREAM_SIZE); |
185 | |
186 | if (msg_len > (int)CC_CEC_STREAM_SIZE) { |
187 | return 0; |
188 | } |
189 | |
190 | if (msg_len <= 2) { |
191 | return 0; |
192 | } |
193 | |
194 | msg_len -= 2; |
195 | |
196 | memcpy(data_buf, msg_data, msg_len); |
197 | |
198 | return msg_len; |
199 | } |
200 | |
201 | int CHDMIRxCEC::GetDeviceLogicAddr(int source_input) |
202 | { |
203 | return mSourceDevLogicAddrBuf[source_input - SOURCE_HDMI1]; |
204 | } |
205 | |
206 | int CHDMIRxCEC::processRefreshSrcDevice(int source_input) |
207 | { |
208 | int i = 0, physical_addr = 0; |
209 | int source_port_1 = 0, source_port_2 = 0; |
210 | |
211 | if (source_input != SOURCE_HDMI1 && source_input != SOURCE_HDMI2 && source_input != SOURCE_HDMI3) { |
212 | return -1; |
213 | } |
214 | |
215 | mSourceDevLogicAddrBuf[0] = E_LA_TV; |
216 | mSourceDevLogicAddrBuf[1] = E_LA_TV; |
217 | mSourceDevLogicAddrBuf[2] = E_LA_TV; |
218 | |
219 | for (i = 0; i < CC_SOURCE_DEV_REFRESH_CNT; i++) { |
220 | if (mSourceDevRefreshBuf[i] < 0) { |
221 | continue; |
222 | } |
223 | |
224 | physical_addr = 0; |
225 | if (SendGivePhysicalAddressMessage(source_input, mSourceDevRefreshBuf[i], &physical_addr) > 0) { |
226 | source_port_1 = CTvin::Tvin_GetSourcePortBySourceInput((tv_source_input_t)source_input); |
227 | source_port_2 = CTvin::Tvin_GetSourcePortByCECPhysicalAddress(physical_addr); |
228 | if (source_port_1 == source_port_2) { |
229 | mSourceDevLogicAddrBuf[source_input - SOURCE_HDMI1] = mSourceDevRefreshBuf[i]; |
230 | break; |
231 | } |
232 | } |
233 | } |
234 | |
235 | if (i == CC_SOURCE_DEV_REFRESH_CNT) { |
236 | return -1; |
237 | } |
238 | |
239 | return 0; |
240 | } |
241 | |
242 | int CHDMIRxCEC::ClearRxMessageBuffer() |
243 | { |
244 | int m_cec_dev_fd = -1; |
245 | |
246 | m_cec_dev_fd = open(CS_HDMIRX_CEC_PATH, O_RDWR); |
247 | if (m_cec_dev_fd < 0) { |
248 | LOGE("%s, Open file %s error: (%s)!\n", __FUNCTION__, CS_HDMIRX_CEC_PATH, strerror ( errno )); |
249 | return -1; |
250 | } |
251 | |
252 | ioctl(m_cec_dev_fd, HDMI_IOC_CEC_CLEAR_BUFFER, NULL); |
253 | |
254 | close(m_cec_dev_fd); |
255 | m_cec_dev_fd = -1; |
256 | |
257 | return 0; |
258 | } |
259 | |
260 | int CHDMIRxCEC::GetMessage(struct _cec_msg msg_buf[]) |
261 | { |
262 | int i = 0; |
263 | int m_cec_dev_fd = -1; |
264 | int msg_cnt = 0; |
265 | |
266 | if (msg_buf == NULL) { |
267 | LOGE("%s, msg_buf is NULL\n", __FUNCTION__); |
268 | } |
269 | |
270 | m_cec_dev_fd = open(CS_HDMIRX_CEC_PATH, O_RDWR); |
271 | if (m_cec_dev_fd < 0) { |
272 | LOGE("%s, Open file %s error: (%s)!\n", __FUNCTION__, CS_HDMIRX_CEC_PATH, strerror ( errno )); |
273 | return 0; |
274 | } |
275 | |
276 | ioctl(m_cec_dev_fd, HDMI_IOC_CEC_GET_MSG_CNT, &msg_cnt); |
277 | if (msg_cnt > 0) { |
278 | LOGD("%s, msg_cnt = %d\n", __FUNCTION__, msg_cnt); |
279 | |
280 | for (i = 0; i < msg_cnt; i++) { |
281 | ioctl(m_cec_dev_fd, HDMI_IOC_CEC_GET_MSG, &msg_buf[i]); |
282 | PrintMessage(__FUNCTION__, 0, &msg_buf[i]); |
283 | } |
284 | } |
285 | |
286 | close(m_cec_dev_fd); |
287 | m_cec_dev_fd = -1; |
288 | |
289 | return msg_cnt; |
290 | } |
291 | |
292 | |
293 | int CHDMIRxCEC::SendMessage(struct _cec_msg *msg) |
294 | { |
295 | int m_cec_dev_fd = -1; |
296 | |
297 | if (msg == NULL) { |
298 | LOGE("%s, msg is NULL\n", __FUNCTION__); |
299 | } |
300 | |
301 | PrintMessage(__FUNCTION__, 0, msg); |
302 | |
303 | m_cec_dev_fd = open(CS_HDMIRX_CEC_PATH, O_RDWR); |
304 | if (m_cec_dev_fd < 0) { |
305 | LOGE("%s, Open file %s error: (%s)!\n", __FUNCTION__, CS_HDMIRX_CEC_PATH, strerror ( errno )); |
306 | return -1; |
307 | } |
308 | |
309 | ioctl(m_cec_dev_fd, HDMI_IOC_CEC_SENT_MSG, msg); |
310 | |
311 | close(m_cec_dev_fd); |
312 | m_cec_dev_fd = -1; |
313 | |
314 | return 0; |
315 | } |
316 | |
317 | int CHDMIRxCEC::sendMessageAndWaitReply(struct _cec_msg *msg, struct _cec_msg *reply_msg, int WaitCmd, int timeout) |
318 | { |
319 | int tmp_ret = 0, tmp_ind = 0; |
320 | |
321 | tmp_ret = SendMessage(msg); |
322 | if (tmp_ret < 0) { |
323 | return tmp_ret; |
324 | } |
325 | |
326 | reply_msg->msg_len = 0; |
327 | |
328 | HDMIRxRequestReplyItem reply_item; |
329 | reply_item.WaitCmd = WaitCmd; |
330 | reply_item.WaitLogicAddr = msg->addr; |
331 | reply_item.WaitTimeOut = timeout; |
332 | reply_item.WaitFlag = 1; |
333 | reply_item.DataFlag = 0; |
334 | |
335 | tmp_ind = addToRequestList(&reply_item); |
336 | |
337 | mReplyLock[tmp_ind].lock(); |
338 | mReplyList[tmp_ind].WaitReplyCondition.waitRelative(mReplyLock[tmp_ind], timeout);//wait reply |
339 | mReplyLock[tmp_ind].unlock(); |
340 | |
341 | if (mReplyList[tmp_ind].DataFlag == 1) { |
342 | PrintMessage(__FUNCTION__, 0, &mReplyList[tmp_ind].msg); |
343 | *reply_msg = mReplyList[tmp_ind].msg; |
344 | } else { |
345 | rmFromRequestList(tmp_ind); |
346 | return -1; |
347 | } |
348 | |
349 | rmFromRequestList(tmp_ind); |
350 | |
351 | return 0; |
352 | } |
353 | |
354 | int CHDMIRxCEC::SendCustomMessage(int source_input, unsigned char data_buf[]) |
355 | { |
356 | CECMsgStream msg_stream; |
357 | |
358 | if (isAllowOperate(source_input) < 0) { |
359 | return -1; |
360 | } |
361 | |
362 | memcpy((void *)msg_stream.buf, data_buf, CC_CEC_STREAM_SIZE); |
363 | if (msg_stream.msg.msg_len > CC_CEC_STREAM_SIZE) { |
364 | return -1; |
365 | } |
366 | |
367 | return SendMessage(&msg_stream.msg); |
368 | } |
369 | |
370 | int CHDMIRxCEC::SendCustomMessageAndWaitReply(int source_input, unsigned char data_buf[], unsigned char reply_buf[], int WaitCmd, int timeout) |
371 | { |
372 | CECMsgStream msg_stream; |
373 | struct _cec_msg reply_msg; |
374 | |
375 | if (isAllowOperate(source_input) < 0) { |
376 | return -1; |
377 | } |
378 | |
379 | memcpy((void *)msg_stream.buf, data_buf, CC_CEC_STREAM_SIZE); |
380 | if (msg_stream.msg.msg_len > CC_CEC_STREAM_SIZE) { |
381 | return -1; |
382 | } |
383 | |
384 | if (sendMessageAndWaitReply(&msg_stream.msg, &reply_msg, WaitCmd, timeout) < 0) { |
385 | return -1; |
386 | } |
387 | |
388 | return CopyMessageData(reply_buf, reply_msg.msg_data, reply_msg.msg_len); |
389 | } |
390 | |
391 | int CHDMIRxCEC::SendBoradcastStandbyMessage(int source_input) |
392 | { |
393 | struct _cec_msg msg; |
394 | |
395 | if (isAllowOperate(source_input) < 0) { |
396 | return -1; |
397 | } |
398 | |
399 | msg.addr = GetDeviceLogicAddr(source_input); |
400 | msg.cmd = E_MSG_STANDBY; |
401 | msg.msg_data[0] = 0; |
402 | msg.msg_len = 2; |
403 | |
404 | return SendMessage(&msg); |
405 | } |
406 | |
407 | int CHDMIRxCEC::SendGiveCECVersionMessage(int source_input, unsigned char data_buf[]) |
408 | { |
409 | struct _cec_msg msg, reply_msg; |
410 | |
411 | if (isAllowOperate(source_input) < 0) { |
412 | return -1; |
413 | } |
414 | |
415 | if (data_buf == NULL) { |
416 | return -1; |
417 | } |
418 | |
419 | msg.addr = GetDeviceLogicAddr(source_input); |
420 | msg.cmd = E_MSG_GET_CEC_VERSION; |
421 | msg.msg_data[0] = 0; |
422 | msg.msg_len = 2; |
423 | |
424 | if (sendMessageAndWaitReply(&msg, &reply_msg, E_MSG_CEC_VERSION, 2000) < 0) { |
425 | return -1; |
426 | } |
427 | |
428 | return CopyMessageData(data_buf, reply_msg.msg_data, reply_msg.msg_len); |
429 | } |
430 | |
431 | int CHDMIRxCEC::SendGiveDeviceVendorIDMessage(int source_input, unsigned char data_buf[]) |
432 | { |
433 | struct _cec_msg msg, reply_msg; |
434 | |
435 | if (isAllowOperate(source_input) < 0) { |
436 | return -1; |
437 | } |
438 | |
439 | if (data_buf == NULL) { |
440 | return -1; |
441 | } |
442 | |
443 | msg.addr = GetDeviceLogicAddr(source_input); |
444 | msg.cmd = E_MSG_GIVE_DEVICE_VENDOR_ID; |
445 | msg.msg_data[0] = 0; |
446 | msg.msg_len = 2; |
447 | |
448 | if (sendMessageAndWaitReply(&msg, &reply_msg, E_MSG_DEVICE_VENDOR_ID, 2000) < 0) { |
449 | return -1; |
450 | } |
451 | |
452 | return CopyMessageData(data_buf, reply_msg.msg_data, reply_msg.msg_len); |
453 | } |
454 | |
455 | int CHDMIRxCEC::SendGiveOSDNameMessage(int source_input, unsigned char data_buf[]) |
456 | { |
457 | struct _cec_msg msg, reply_msg; |
458 | |
459 | if (isAllowOperate(source_input) < 0) { |
460 | return -1; |
461 | } |
462 | |
463 | if (data_buf == NULL) { |
464 | return -1; |
465 | } |
466 | |
467 | msg.addr = GetDeviceLogicAddr(source_input); |
468 | msg.cmd = E_MSG_OSDNT_GIVE_OSD_NAME; |
469 | msg.msg_data[0] = 0; |
470 | msg.msg_len = 2; |
471 | |
472 | if (sendMessageAndWaitReply(&msg, &reply_msg, E_MSG_OSDNT_SET_OSD_NAME, 2000) < 0) { |
473 | return -1; |
474 | } |
475 | |
476 | return CopyMessageData(data_buf, reply_msg.msg_data, reply_msg.msg_len); |
477 | } |
478 | |
479 | int CHDMIRxCEC::SendGivePhysicalAddressMessage(int source_input, int logic_addr, int *physical_addr) |
480 | { |
481 | struct _cec_msg msg, reply_msg; |
482 | |
483 | if (isAllowOperate(source_input) < 0) { |
484 | return -1; |
485 | } |
486 | |
487 | if (physical_addr == NULL) { |
488 | return -1; |
489 | } |
490 | |
491 | msg.addr = logic_addr; |
492 | msg.cmd = E_MSG_GIVE_PHYSICAL_ADDRESS; |
493 | msg.msg_data[0] = 0; |
494 | msg.msg_len = 2; |
495 | |
496 | if (sendMessageAndWaitReply(&msg, &reply_msg, E_MSG_REPORT_PHYSICAL_ADDRESS, 2000) < 0) { |
497 | return -1; |
498 | } |
499 | |
500 | if (reply_msg.msg_len == 5) { |
501 | *physical_addr = 0; |
502 | *physical_addr |= reply_msg.msg_data[0] << 8; |
503 | *physical_addr |= reply_msg.msg_data[1]; |
504 | return reply_msg.msg_len; |
505 | } |
506 | |
507 | return -1; |
508 | } |
509 | |
510 | int CHDMIRxCEC::SendSetMenuLanguageMessage(int source_input, unsigned char data_buf[]) |
511 | { |
512 | struct _cec_msg msg; |
513 | |
514 | if (isAllowOperate(source_input) < 0) { |
515 | return -1; |
516 | } |
517 | |
518 | if (data_buf == NULL) { |
519 | return -1; |
520 | } |
521 | |
522 | msg.addr = GetDeviceLogicAddr(source_input); |
523 | msg.cmd = E_MSG_SET_MENU_LANGUAGE; |
524 | msg.msg_data[0] = data_buf[0]; |
525 | msg.msg_data[1] = data_buf[1]; |
526 | msg.msg_data[2] = data_buf[2]; |
527 | msg.msg_len = 5; |
528 | |
529 | return SendMessage(&msg); |
530 | } |
531 | |
532 | int CHDMIRxCEC::SendVendorRemoteKeyDownMessage(int source_input, unsigned char key_val) |
533 | { |
534 | struct _cec_msg msg; |
535 | |
536 | if (isAllowOperate(source_input) < 0) { |
537 | return -1; |
538 | } |
539 | |
540 | msg.addr = GetDeviceLogicAddr(source_input); |
541 | msg.cmd = E_MSG_VENDOR_RC_BUT_DOWN; |
542 | msg.msg_data[0] = key_val; |
543 | msg.msg_len = 3; |
544 | |
545 | return SendMessage(&msg); |
546 | } |
547 | |
548 | int CHDMIRxCEC::SendVendorRemoteKeyUpMessage(int source_input) |
549 | { |
550 | struct _cec_msg msg; |
551 | |
552 | if (isAllowOperate(source_input) < 0) { |
553 | return -1; |
554 | } |
555 | |
556 | msg.addr = GetDeviceLogicAddr(source_input); |
557 | msg.cmd = E_MSG_VENDOR_RC_BUT_UP; |
558 | msg.msg_data[0] = 0; |
559 | msg.msg_len = 2; |
560 | |
561 | return SendMessage(&msg); |
562 | } |
563 | |
564 | int CHDMIRxCEC::rmFromRequestList(int index) |
565 | { |
566 | mListLock.lock(); |
567 | |
568 | ClrReplyListItem(&mReplyList[index]); |
569 | |
570 | mListLock.unlock(); |
571 | |
572 | return 0; |
573 | } |
574 | |
575 | int CHDMIRxCEC::addToRequestList(HDMIRxRequestReplyItem *reply_item) |
576 | { |
577 | int i = 0; |
578 | |
579 | mListLock.lock(); |
580 | |
581 | for (i = 0; i < CC_REQUEST_LIST_SIZE; i++) { |
582 | if (mReplyList[i].WaitFlag == 0) { |
583 | mReplyList[i] = *reply_item; |
584 | mListLock.unlock(); |
585 | return i; |
586 | } |
587 | } |
588 | |
589 | mListLock.unlock(); |
590 | |
591 | return 0; |
592 | } |
593 | |
594 | int CHDMIRxCEC::processData(int msg_cnt) |
595 | { |
596 | int i = 0, j = 0; |
597 | CECMsgStream msg_stream; |
598 | |
599 | for (i = 0; i < msg_cnt; i++) { |
600 | for (j = 0; j < CC_REQUEST_LIST_SIZE; j++) { |
601 | if (mReplyList[j].WaitFlag) { |
602 | if (mMsgBuf[i].cmd == mReplyList[j].WaitCmd && ((mMsgBuf[i].addr & 0xF0) >> 4) == mReplyList[j].WaitLogicAddr) { |
603 | mReplyList[j].DataFlag = 1; |
604 | mReplyList[j].msg = mMsgBuf[i]; |
605 | PrintMessage(__FUNCTION__, 0, &mReplyList[j].msg); |
606 | mReplyList[j].WaitReplyCondition.signal(); |
607 | |
608 | return 0; |
609 | } |
610 | } |
611 | } |
612 | |
613 | msg_stream.msg = mMsgBuf[i]; |
614 | if (mpObserver != NULL) { |
615 | mpObserver->onHDMIRxCECMessage(msg_stream.msg.msg_len, msg_stream.buf); |
616 | } |
617 | } |
618 | |
619 | return 0; |
620 | } |
621 | |
622 | bool CHDMIRxCEC::threadLoop() |
623 | { |
624 | int msg_cnt = 0; |
625 | int sleeptime = 200; //ms |
626 | |
627 | mState = STATE_RUNNING; |
628 | |
629 | while (!exitPending()) { //requietexit() or requietexitWait() not call |
630 | while (mRequestPause) { |
631 | mLock.lock(); |
632 | mState = STATE_PAUSE; |
633 | mPauseCondition.wait(mLock); //first unlock,when return,lock again,so need,call unlock |
634 | mState = STATE_RUNNING; |
635 | mLock.unlock(); |
636 | } |
637 | |
638 | msg_cnt = GetMessage(mMsgBuf); |
639 | |
640 | processData(msg_cnt); |
641 | |
642 | if (!mRequestPause) { |
643 | usleep(sleeptime * 1000); |
644 | } |
645 | } |
646 | |
647 | mState = STATE_STOPED; |
648 | //exit |
649 | //return true, run again, return false,not run. |
650 | return false; |
651 | } |
652 |