Android輸入輸出機制之來龍去脈之前生後世

阿新 • • 發佈：2019-02-04

先講一下基本一般的輸入處理方式的知識。一般的輸入輸出採用生產者，消費者模式，並構造佇列進行處理，如下圖

這種輸入模型在android的系統中很多地方採用，先從最底層說起：

為了由於觸屏事件頻率很高，android設計者講一個迴圈執行緒，拆分為兩級迴圈，並做了個佇列來進行緩衝。

InputDispatcherThread和InputReaderThread

InputDispatcherThread在自己的迴圈中對InputReaderThread請求同步，InputReaderThread收到同步訊號後，把事件放入InputDispatcher的佇列中。

具體程式碼如下：

InputReader.cpp中有很多InputMapper,有SwitchInputMapper，KeyBoardInputMapper，TrackballInputMapper，SingleTouchInputMapper，

MultiTouchInputMapper。當執行緒從EventHub讀取到Event後，呼叫這些InputMapper的pocess方法：

[java] view plain copy print ?

檔案InputReader.cpp中：
bool InputReaderThread::threadLoop() {
mReader->loopOnce();
returntrue;
}
void InputReader::loopOnce() {
RawEvent rawEvent;
mEventHub->getEvent(& rawEvent);
#if DEBUG_RAW_EVENTS
LOGD("Input event: device=0x%x type=0x%x scancode=%d keycode=%d value=%d",
rawEvent.deviceId, rawEvent.type, rawEvent.scanCode, rawEvent.keyCode,
rawEvent.value);
#endif
process(& rawEvent);
}

檔案InputReader.cpp中：

bool InputReaderThread::threadLoop() {
    mReader->loopOnce();
    return true;
}


void InputReader::loopOnce() {
    RawEvent rawEvent;
    mEventHub->getEvent(& rawEvent);

#if DEBUG_RAW_EVENTS
    LOGD("Input event: device=0x%x type=0x%x scancode=%d keycode=%d value=%d",
            rawEvent.deviceId, rawEvent.type, rawEvent.scanCode, rawEvent.keyCode,
            rawEvent.value);
#endif

    process(& rawEvent);
}

process如下

[java] view plain copy print ?

void InputReader::process(const RawEvent* rawEvent) {
switch (rawEvent->type) {
consumeEvent(rawEvent);
break;
}
}

void InputReader::process(const RawEvent* rawEvent) {
    switch (rawEvent->type) {
        consumeEvent(rawEvent);
        break;
    }
}

Java程式碼

consumeEvent(rawEvent);

[java] view plain copy print ?

consumeEvent(rawEvent);

consumeEvent(rawEvent);

方法是關鍵，下面繼續跟進；

Java程式碼

[java] view plain copy print ?

void InputReader::consumeEvent(const RawEvent* rawEvent) {
int32_t deviceId = rawEvent->deviceId;
{
device->process(rawEvent);
} // release device registry reader lock
}

void InputReader::consumeEvent(const RawEvent* rawEvent) {
    int32_t deviceId = rawEvent->deviceId;

    { 
        device->process(rawEvent);
    } // release device registry reader lock
}

device->process(rawEvent)行，跟進去：

Java程式碼

[java] view plain copy print ?

void InputDevice::process(const RawEvent* rawEvent) {
size_t numMappers = mMappers.size();
for (size_t i = 0; i < numMappers; i++) {
InputMapper* mapper = mMappers[i];
mapper->process(rawEvent);
}
}

void InputDevice::process(const RawEvent* rawEvent) {
    size_t numMappers = mMappers.size();
    for (size_t i = 0; i < numMappers; i++) {
        InputMapper* mapper = mMappers[i];
        mapper->process(rawEvent);
    }
}

下面進入了IputMapper，InputMapper是個純虛類，process是個純虛方法，隨便找個例子跟進去：

[cpp] view plain copy print ?

void SingleTouchInputMapper::process(const RawEvent* rawEvent) {
switch (rawEvent->type) {
case EV_KEY:
switch (rawEvent->scanCode) {
case BTN_TOUCH:
mAccumulator.fields |= Accumulator::FIELD_BTN_TOUCH;
mAccumulator.btnTouch = rawEvent->value != 0;
// Don't sync immediately. Wait until the next SYN_REPORT since we might
// not have received valid position information yet. This logic assumes that
// BTN_TOUCH is always followed by SYN_REPORT as part of a complete packet.
break;
}
break;
case EV_SYN:
switch (rawEvent->scanCode) {
case SYN_REPORT:
sync(rawEvent->when);
break;
}
break;
}
}

void SingleTouchInputMapper::process(const RawEvent* rawEvent) {
    switch (rawEvent->type) {
    case EV_KEY:
        switch (rawEvent->scanCode) {
        case BTN_TOUCH:
            mAccumulator.fields |= Accumulator::FIELD_BTN_TOUCH;
            mAccumulator.btnTouch = rawEvent->value != 0;
            // Don't sync immediately.  Wait until the next SYN_REPORT since we might
            // not have received valid position information yet.  This logic assumes that
            // BTN_TOUCH is always followed by SYN_REPORT as part of a complete packet.
            break;
        }
        break;
    case EV_SYN:
        switch (rawEvent->scanCode) {
        case SYN_REPORT:
            sync(rawEvent->when);
            break;
        }
        break;
    }
}

最關鍵的是

Cpp程式碼

sync(rawEvent->when);

[cpp] view plain copy print ?

sync(rawEvent->when);

 sync(rawEvent->when);

展開如下：

Cpp程式碼

[cpp] view plain copy print ?

void SingleTouchInputMapper::sync(nsecs_t when) {
syncTouch(when, true);
}

void SingleTouchInputMapper::sync(nsecs_t when) {

    syncTouch(when, true);

 
}

Java程式碼

[java] view plain copy print ?

void TouchInputMapper::syncTouch(nsecs_t when, bool havePointerIds) {
if (touchResult == DISPATCH_TOUCH) {
detectGestures(when);
dispatchTouches(when, policyFlags);
}
}

void TouchInputMapper::syncTouch(nsecs_t when, bool havePointerIds) {
   
    if (touchResult == DISPATCH_TOUCH) {
        detectGestures(when);
        dispatchTouches(when, policyFlags);
    }
}

這兩行，一個是虛擬鍵盤，一個是觸控式螢幕。

TouchResult touchResult = consumeOffScreenTouches(when, policyFlags);

Java程式碼

dispatchTouches
Cpp程式碼
1. void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {
2. // Dispatch pointer down events using the new pointer locations.
3. while (!downIdBits.isEmpty()) {
4. dispatchTouch(when, policyFlags, &mCurrentTouch,
5. activeIdBits, downId, pointerCount, motionEventAction);
6. }
7. }
8. }
[cpp] view plaincopyprint?
1. void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {
2. // Dispatch pointer down events using the new pointer locations.
3. while (!downIdBits.isEmpty()) {
4. dispatchTouch(when, policyFlags, &mCurrentTouch,
5. activeIdBits, downId, pointerCount, motionEventAction);
6. }
7. }
8. }
```
void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {
        // Dispatch pointer down events using the new pointer locations.
        while (!downIdBits.isEmpty()) {
            dispatchTouch(when, policyFlags, &mCurrentTouch,
                    activeIdBits, downId, pointerCount, motionEventAction);
        }
    }
}
```
Cpp程式碼
1. dispatchTouch(when, policyFlags, &mCurrentTouch,
2. activeIdBits, downId, pointerCount, motionEventAction);
[cpp] view plaincopyprint?
1. dispatchTouch(when, policyFlags, &mCurrentTouch,
2. activeIdBits, downId, pointerCount, motionEventAction);
```
dispatchTouch(when, policyFlags, &mCurrentTouch,
                    activeIdBits, downId, pointerCount, motionEventAction);
```
這個方法展開如下：
Java程式碼
1. void TouchInputMapper::dispatchTouch(nsecs_t when, uint32_t policyFlags,
2. TouchData* touch, BitSet32 idBits, uint32_t changedId, uint32_t pointerCount,
3. int32_t motionEventAction) {
4. int32_t pointerIds[MAX_POINTERS];
5. PointerCoords pointerCoords[MAX_POINTERS];
6. int32_t motionEventEdgeFlags = 0;
7. float xPrecision, yPrecision;
8. {
9. getDispatcher()->notifyMotion(when, getDeviceId(), getSources(), policyFlags,
10. motionEventAction, 0, getContext()->getGlobalMetaState(), motionEventEdgeFlags,
11. pointerCount, pointerIds, pointerCoords,
12. xPrecision, yPrecision, mDownTime);
13. }
[java] view plaincopyprint?
1. void TouchInputMapper::dispatchTouch(nsecs_t when, uint32_t policyFlags,
2. TouchData* touch, BitSet32 idBits, uint32_t changedId, uint32_t pointerCount,
3. int32_t motionEventAction) {
4. int32_t pointerIds[MAX_POINTERS];
5. PointerCoords pointerCoords[MAX_POINTERS];
6. int32_t motionEventEdgeFlags = 0;
7. float xPrecision, yPrecision;
8. {
9. getDispatcher()->notifyMotion(when, getDeviceId(), getSources(), policyFlags,
10. motionEventAction, 0, getContext()->getGlobalMetaState(), motionEventEdgeFlags,
11. pointerCount, pointerIds, pointerCoords,
12. xPrecision, yPrecision, mDownTime);
13. }
```
void TouchInputMapper::dispatchTouch(nsecs_t when, uint32_t policyFlags,
        TouchData* touch, BitSet32 idBits, uint32_t changedId, uint32_t pointerCount,
        int32_t motionEventAction) {
    int32_t pointerIds[MAX_POINTERS];
    PointerCoords pointerCoords[MAX_POINTERS];
    int32_t motionEventEdgeFlags = 0;
    float xPrecision, yPrecision;

    { 
    getDispatcher()->notifyMotion(when, getDeviceId(), getSources(), policyFlags,
            motionEventAction, 0, getContext()->getGlobalMetaState(), motionEventEdgeFlags,
            pointerCount, pointerIds, pointerCoords,
            xPrecision, yPrecision, mDownTime);
}
```
這樣就到了InputDiaptcher的notifyMotion方法，這個方法很長，都再處理MOVE事件，將無用的刪除後，留下如下關鍵程式碼：
Java程式碼
1. void InputDispatcher::notifyMotion(nsecs_t eventTime, int32_t deviceId, int32_t source,
2. uint32_t policyFlags, int32_t action, int32_t flags, int32_t metaState, int32_t edgeFlags,
3. uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords,
4. float xPrecision, float yPrecision, nsecs_t downTime) {
5. // Just enqueue a new motion event.
6. MotionEntry* newEntry = mAllocator.obtainMotionEntry(eventTime,
7. deviceId, source, policyFlags, action, flags, metaState, edgeFlags,
8. xPrecision, yPrecision, downTime,
9. pointerCount, pointerIds, pointerCoords);
10. needWake = enqueueInboundEventLocked(newEntry);
11. }
[java] view plaincopyprint?
1. void InputDispatcher::notifyMotion(nsecs_t eventTime, int32_t deviceId, int32_t source,
2. uint32_t policyFlags, int32_t action, int32_t flags, int32_t metaState, int32_t edgeFlags,
3. uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords,
4. float xPrecision, float yPrecision, nsecs_t downTime) {
5. // Just enqueue a new motion event.
6. MotionEntry* newEntry = mAllocator.obtainMotionEntry(eventTime,
7. deviceId, source, policyFlags, action, flags, metaState, edgeFlags,
8. xPrecision, yPrecision, downTime,
9. pointerCount, pointerIds, pointerCoords);
10. needWake = enqueueInboundEventLocked(newEntry);
11. }
```
 void InputDispatcher::notifyMotion(nsecs_t eventTime, int32_t deviceId, int32_t source,
        uint32_t policyFlags, int32_t action, int32_t flags, int32_t metaState, int32_t edgeFlags,
        uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords,
        float xPrecision, float yPrecision, nsecs_t downTime) {      

 // Just enqueue a new motion event.
        MotionEntry* newEntry = mAllocator.obtainMotionEntry(eventTime,
                deviceId, source, policyFlags, action, flags, metaState, edgeFlags,
                xPrecision, yPrecision, downTime,
                pointerCount, pointerIds, pointerCoords);

        needWake = enqueueInboundEventLocked(newEntry);
}
```
最後一句：
Java程式碼
1. needWake = enqueueInboundEventLocked(newEntry);
[java] view plaincopyprint?
1. needWake = enqueueInboundEventLocked(newEntry);
```
 needWake = enqueueInboundEventLocked(newEntry);
```
Cpp程式碼
1. bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) {
2. bool needWake = mInboundQueue.isEmpty();
3. mInboundQueue.enqueueAtTail(entry);
4. switch (entry->type) {
5. case EventEntry::TYPE_KEY: {
6. KeyEntry* keyEntry = static_cast<KeyEntry*>(entry);
7. if (isAppSwitchKeyEventLocked(keyEntry)) {
8. if (keyEntry->action == AKEY_EVENT_ACTION_DOWN) {
9. mAppSwitchSawKeyDown = true;
10. } elseif (keyEntry->action == AKEY_EVENT_ACTION_UP) {
11. if (mAppSwitchSawKeyDown) {
12. #if DEBUG_APP_SWITCH
13. LOGD("App switch is pending!");
14. #endif
15. mAppSwitchDueTime = keyEntry->eventTime + APP_SWITCH_TIMEOUT;
16. mAppSwitchSawKeyDown = false;
17. needWake = true;
18. }
19. }
20. }
21. break;
22. }
23. }
24. return needWake;
25. }
[cpp] view plaincopyprint?
1. bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) {
2. bool needWake = mInboundQueue.isEmpty();
3. mInboundQueue.enqueueAtTail(entry);
4. switch (entry->type) {
5. case EventEntry::TYPE_KEY: {
6. KeyEntry* keyEntry = static_cast<KeyEntry*>(entry);
7. if (isAppSwitchKeyEventLocked(keyEntry)) {
8. if (keyEntry->action == AKEY_EVENT_ACTION_DOWN) {
9. mAppSwitchSawKeyDown = true;
10. } elseif (keyEntry->action == AKEY_EVENT_ACTION_UP) {
11. if (mAppSwitchSawKeyDown) {
12. #if DEBUG_APP_SWITCH
13. LOGD("App switch is pending!");
14. #endif
15. mAppSwitchDueTime = keyEntry->eventTime + APP_SWITCH_TIMEOUT;
16. mAppSwitchSawKeyDown = false;
17. needWake = true;
18. }
19. }
20. }
21. break;
22. }
23. }
24. return needWake;
25. }
```
bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) {
    bool needWake = mInboundQueue.isEmpty();
    mInboundQueue.enqueueAtTail(entry);

    switch (entry->type) {
    case EventEntry::TYPE_KEY: {
        KeyEntry* keyEntry = static_cast<KeyEntry*>(entry);
        if (isAppSwitchKeyEventLocked(keyEntry)) {
            if (keyEntry->action == AKEY_EVENT_ACTION_DOWN) {
                mAppSwitchSawKeyDown = true;
            } else if (keyEntry->action == AKEY_EVENT_ACTION_UP) {
                if (mAppSwitchSawKeyDown) {
#if DEBUG_APP_SWITCH
                    LOGD("App switch is pending!");
#endif
                    mAppSwitchDueTime = keyEntry->eventTime + APP_SWITCH_TIMEOUT;
                    mAppSwitchSawKeyDown = false;
                    needWake = true;
                }
            }
        }
        break;
    }
    }

    return needWake;
}
```
Cpp程式碼
1. mInboundQueue正是上面所說的佇列。到此為止，從InputReader插入到佇列就完成了。
[cpp] view plaincopyprint?
1. mInboundQueue正是上面所說的佇列。到此為止，從InputReader插入到佇列就完成了。
```
mInboundQueue正是上面所說的佇列。到此為止，從InputReader插入到佇列就完成了。
```
那麼InputDispatcher又是如何從佇列中取出來的呢？累了。

InputDiapather的
Cpp程式碼
1. dispatchOnce
[cpp] view plaincopyprint?
1. dispatchOnce
```
dispatchOnce
```
方法如下：
Cpp程式碼
1. void InputDispatcher::dispatchOnce() {
2. nsecs_t keyRepeatTimeout = mPolicy->getKeyRepeatTimeout();
3. nsecs_t keyRepeatDelay = mPolicy->getKeyRepeatDelay();
4. nsecs_t nextWakeupTime = LONG_LONG_MAX;
5. { // acquire lock
6. AutoMutex _l(mLock);
7. dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime);
8. if (runCommandsLockedInterruptible()) {
9. nextWakeupTime = LONG_LONG_MIN; // force next poll to wake up immediately
10. }
11. } // release lock
12. // Wait for callback or timeout or wake. (make sure we round up, not down)
13. nsecs_t currentTime = now();
14. int32_t timeoutMillis;
15. if (nextWakeupTime > currentTime) {
16. uint64_t timeout = uint64_t(nextWakeupTime - currentTime);
17. timeout = (timeout + 999999LL) / 1000000LL;
18. timeoutMillis = timeout > INT_MAX ? -1 : int32_t(timeout);
19. } else {
20. timeoutMillis = 0;
21. }
22. mLooper->pollOnce(timeoutMillis);
23. }
[cpp] view plaincopyprint?
1. void InputDispatcher::dispatchOnce() {
2. nsecs_t keyRepeatTimeout = mPolicy->getKeyRepeatTimeout();
3. nsecs_t keyRepeatDelay = mPolicy->getKeyRepeatDelay();
4. nsecs_t nextWakeupTime = LONG_LONG_MAX;
5. { // acquire lock
6. AutoMutex _l(mLock);
7. dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime);
8. if (runCommandsLockedInterruptible()) {
9. nextWakeupTime = LONG_LONG_MIN; // force next poll to wake up immediately
10. }
11. } // release lock
12. // Wait for callback or timeout or wake. (make sure we round up, not down)
13. nsecs_t currentTime = now();
14. int32_t timeoutMillis;
15. if (nextWakeupTime > currentTime) {
16. uint64_t timeout = uint64_t(nextWakeupTime - currentTime);
17. timeout = (timeout + 999999LL) / 1000000LL;
18. timeoutMillis = timeout > INT_MAX ? -1 : int32_t(timeout);
19. } else {
20. timeoutMillis = 0;
21. }
22. mLooper->pollOnce(timeoutMillis);
23. }
```
void InputDispatcher::dispatchOnce() {
    nsecs_t keyRepeatTimeout = mPolicy->getKeyRepeatTimeout();
    nsecs_t keyRepeatDelay = mPolicy->getKeyRepeatDelay();

    nsecs_t nextWakeupTime = LONG_LONG_MAX;
    { // acquire lock
        AutoMutex _l(mLock);
        dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime);

        if (runCommandsLockedInterruptible()) {
            nextWakeupTime = LONG_LONG_MIN;  // force next poll to wake up immediately
        }
    } // release lock

    // Wait for callback or timeout or wake.  (make sure we round up, not down)
    nsecs_t currentTime = now();
    int32_t timeoutMillis;
    if (nextWakeupTime > currentTime) {
        uint64_t timeout = uint64_t(nextWakeupTime - currentTime);
        timeout = (timeout + 999999LL) / 1000000LL;
        timeoutMillis = timeout > INT_MAX ? -1 : int32_t(timeout);
    } else {
        timeoutMillis = 0;
    }

    mLooper->pollOnce(timeoutMillis);
}
```
最關鍵的是
Cpp程式碼
1. dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime);
[cpp] view plaincopyprint?
1. dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime);
```
  dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime);
```
和
Cpp程式碼
1. mLooper->pollOnce(timeoutMillis);（這個方法在有個回撥，與事件有關的是【管道裝置的檔案描述符】。
2. 具體機制在後面講。這個東西實際上是個跨程序的訊號。傳送給了Android的使用者程序的JNI，又通過JNI呼叫InputQueue的的
3. 靜態方法如：dispatchMotionEvent。後面回提到dispatchMotionEvent才是Android使用者程序的事件入口函式。）
4. ）
[cpp] view plaincopyprint?
1. mLooper->pollOnce(timeoutMillis);（這個方法在有個回撥，與事件有關的是【管道裝置的檔案描述符】。
2. 具體機制在後面講。這個東西實際上是個跨程序的訊號。傳送給了Android的使用者程序的JNI，又通過JNI呼叫InputQueue的的
3. 靜態方法如：dispatchMotionEvent。後面回提到dispatchMotionEvent才是Android使用者程序的事件入口函式。）
4. ）
```
    mLooper->pollOnce(timeoutMillis);（這個方法在有個回撥，與事件有關的是【管道裝置的檔案描述符】。
  具體機制在後面講。這個東西實際上是個跨程序的訊號。傳送給了Android的使用者程序的JNI，又通過JNI呼叫InputQueue的的
靜態方法如：dispatchMotionEvent。後面回提到dispatchMotionEvent才是Android使用者程序的事件入口函式。）
）
```
程式碼又長又臭
Java程式碼
1. void InputDispatcher::dispatchOnceInnerLocked(nsecs_t keyRepeatTimeout,
2. nsecs_t keyRepeatDelay, nsecs_t* nextWakeupTime) {
3. case EventEntry::TYPE_MOTION: {
4. MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);
5. if (dropReason == DROP_REASON_NOT_DROPPED && isAppSwitchDue) {
6. dropReason = DROP_REASON_APP_SWITCH;
7. }
8. done = dispatchMotionLocked(currentTime, typedEntry,
9. &dropReason, nextWakeupTime);
10. break;
11. }
12. }
[java] view plaincopyprint?
1. void InputDispatcher::dispatchOnceInnerLocked(nsecs_t keyRepeatTimeout,
2. nsecs_t keyRepeatDelay, nsecs_t* nextWakeupTime) {
3. case EventEntry::TYPE_MOTION: {
4. MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);
5. if (dropReason == DROP_REASON_NOT_DROPPED && isAppSwitchDue) {
6. dropReason = DROP_REASON_APP_SWITCH;
7. }
8. done = dispatchMotionLocked(currentTime, typedEntry,
9. &dropReason, nextWakeupTime);
10. break;
11. }
12. }
```
void InputDispatcher::dispatchOnceInnerLocked(nsecs_t keyRepeatTimeout,
        nsecs_t keyRepeatDelay, nsecs_t* nextWakeupTime) {
    case EventEntry::TYPE_MOTION: {
        MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);
        if (dropReason == DROP_REASON_NOT_DROPPED && isAppSwitchDue) {
            dropReason = DROP_REASON_APP_SWITCH;
        }
        done = dispatchMotionLocked(currentTime, typedEntry,
                &dropReason, nextWakeupTime);
        break;
    }

}
```
Java程式碼
1. dispatchMotionLocked
[java] view plaincopyprint?
1. dispatchMotionLocked
```
dispatchMotionLocked
```
方法呼叫prepareDispatchCycleLocked，呼叫startDispatchCycleLocked，最終呼叫

       // Publish the key event.
        status = connection->inputPublisher.publishKeyEvent(keyEntry->deviceId, keyEntry->source,
                action, flags, keyEntry->keyCode, keyEntry->scanCode,
                keyEntry->metaState, keyEntry->repeatCount, keyEntry->downTime,
                keyEntry->eventTime);

或者 // Publish the motion event and the first motion sample.
        status = co

Android輸入輸出機制之來龍去脈之前生後世

先講一下基本一般的輸入處理方式的知識。一般的輸入輸出採用生產者，消費者模式，並構造佇列進行處理，如下圖這種輸入模型在android的系統中很多地方採用，先從最底層說起：為了由於觸屏事件頻率很高，android設計者講一個迴圈執行緒，拆分為兩級迴圈，並做了個佇列來進行緩衝。 InputDis

Android的訊息機制之ThreadLocal的工作原理

提到訊息機制大家應該都不陌生，在日常開發中不可避免地要涉及到這方面的內容。從開發的角度來說，Handler是Android訊息機制的上層介面，這使得開發過程中只需要和Handler互動即可。Handler的使用過程很簡單，通過它可以輕鬆地將一個任務切換到Handl

【Android 開發】: Android 訊息處理機制之四: Android 訊息迴圈 Looper 及其原始碼解析

上一講我們學習Handler和Message的一些使用方式，我們知道Handler它會發送訊息和處理訊息，並且關聯一個子執行緒，如何傳送訊息入隊和出隊處理訊息等這些都是交給Looper去管理分發的，也就是它是負責整個訊息佇列運轉的一個類，這一講我們就來學習一下Andr

Android 新安全機制之動態許可權申請

Android6.0的SDK，對許可權的申請機制發生了一些變化。在Android6.0之前，使用者安裝APP時就要為其授予對應的許可權，不然程式就無法安裝，而6.0之後，我們可以直接安裝，並可對應用的許可權進行管理，這樣極大的保護了使用者的隱私，但也給我們開

【Android 開發】: Android 訊息處理機制之三: Handler 中 sendMessage() 原始碼剖析

閱讀此文,請先閱讀以下相關連線： sendMessage()的幾種過載方法的使用方式的不同以及它們的原始碼的剖析. 通過前面幾講的內容,我們知道Android不但可以使用非同步任務處理多執行

Android的許可權機制之—— “沙箱”機制sharedUserId和簽名

Android“沙箱”的本質是為了實現不同應用程式和程序之間的互相隔離，即在預設情況下，應用程式沒有許可權訪問系統資源或其它應用程式的資源。每個APP和系統程序都被分配唯一併且固定的User Id，這個uid與核心層程序的uid對應。每個APP在各自獨立的Dalvi

C++ 輸入輸出流之字串流

字串流介紹字串流以記憶體中使用者定義的字元陣列(字串)作為輸入輸出物件。字串流也有緩衝區，當緩衝區滿了(或遇到換行符)，流緩衝的資料一起存入字元陣列。標頭檔案<strstream>1. 建立輸出字串流物件 ostrestream的建構函式： ostrestre

Android進階——Android檢視工作機制之measure、layout、draw

前言自定義View一直是初學者們最頭疼的事情，因為他們並沒有瞭解到真正的實現原理就開始試著做自定義View，碰到很多看不懂的程式碼只能選擇迴避，做多了會覺得很沒自信。其實只要瞭解了View的工作機制後，會發現是挺簡單的，自定義View就是藉助View的工作機

C++ 輸入輸出流之檔案操作和檔案流

使用成員函式read和write讀取二進位制檔案 istream &read(char *buffer, int len);ostream& write(constchar *buffer, int len)舉例：將一批資料存入磁碟檔案 student stu[2] = {{"Li", 100

OJ題目八大輸入輸出格式之Python版

根據杭電的那篇教程寫的，現在部落格裡面再存一篇 # encoding: utf-8 ''' Created on Nov 6th, 2014 @author: Speedcell ''' '''Python的輸入是野生字串，所以要自己轉型別 strip去掉左右兩

【精華】ACM八大輸入輸出格式之Python版

根據杭電的那篇教程寫的，現在部落格裡面再存一篇 # encoding: utf-8 ''' Created on Nov 6th, 2014 @author: Speedcell ''' '''Python的輸入是野生字串，所以要自己轉型別 strip去掉左右兩端

Android簽名機制之---簽名過程具體解釋

先來文件內容 rfi eating general class stat ket 寫文章一、前言又是過了好長時間，沒寫文章的雙手都有點難受了。今天是聖誕節，還是得上班。由於前幾天有一個之前的同事，在申請微信SDK的時候，遇到簽名的問題，問了我一下，結果把我難倒了。。我

Android性能優化之ListView緩存機制

ner data b2c 模式 ret hold ren state err 要想優化ListView首先要了解它的工作原理，列表的顯示須要三個元素：ListView、Adapter、顯示的數據。這裏的Adapter就是用到了適配器模式，無論傳入的是什麽View在Li

基於C#解決OJ刷題之輸入輸出問題的總結（AKOJ1064-1071A+B問題匯總）

-s har article not edit stat sig nbsp rgs 聲明：題目部分為akoj題目，代碼為本人AC代碼。因為本人學校的oj支持各種環境，非常正常的當中就包括了C#。然暑假在家較為空暇，本著學習C#和復習算法的態度

Android HandlerThread 消息循環機制之源代碼解析

addclass 好的擒賊先擒王 lstat ack 鏈表結構 mcal 回調 prior 關於 HandlerThread 這個類。可能有些人眼睛一瞟，手指放在鍵盤上，然後就是一陣狂敲。立即就能敲出一段段華麗的代碼： HandlerThread

python 筆記之輸入輸出 login

getpasscat login.py #!/usr/bin/pythonimport getpass ###getpass模塊中的getpass方法 usname = raw_input(‘username:‘) ###接收用戶輸入的字符passwd = getpass.getpass(‘passwo

Python學習筆記系列之002：變量註釋輸入輸出

練習題命名 outer 計算機鍵盤 -a 考題 onerror rac 導讀： 1.變量 2.字符編碼 3.註釋 4.輸出 5.輸入 6.縮進 7.報錯單詞釋義 8.代碼規範基礎語法是任何語言的基礎，只有熟練掌握，才能靈活用語言，寫出高效、優美、簡潔的代碼。 Py

Shell腳本編程之Shell輸入/輸出重定向

設備 dev oob out 發送信息合並標準輸出文件描述符 1.大多數情況下UNIX系統命令從你的終端接受輸入並將所產生的輸出發送回到你的終端重定向命令列表如下： 2.輸出重定向：重定向一般通過命令間插入特定的符號來實現； #!/

python3之格式輸入輸出

不能打開 src 分享 idt 添加多個文件否則 ---恢復內容開始--- 一，變量 1）變量賦值方式 2）快速賦值：ctrl+d 變量替換快捷方式：ctrl+r 3）字符串拼接二，輸入—輸出 1 輸入 1）字符串輸出：　　

openjudge 1.1編程基礎之輸入輸出

sca span info bsp eve () font can 技術分享 01: 1 #include<iostream> 2 using namespace std; 3 int main() 4 { 5 cout<&l

Android輸入輸出機制之來龍去脈之前生後世

相關推薦