點擊(此處)折疊或打開

1. class ServerThread extends Thread {
   
2.     //省略。。
   
3.     public void run() {
   
4.         // Create a handler thread just for the window manager to enjoy.
   
5.         HandlerThread wmHandlerThread = new HandlerThread("WindowManager");
   
6.         wmHandlerThread.start();
   
7.         Handler wmHandler = new Handler(wmHandlerThread.getLooper());
   
8.         //此處省略5k字。。
   
9.         Slog.i(TAG, "Input Manager");
   
10.         inputManager = new InputManagerService(context, wmHandler);
    
11.     }
    
12. }

點擊(此處)折疊或打開

1. public InputManagerService(Context context, Handler handler) {
   
2.     this.mContext = context;
   
3.     this.mHandler = new InputManagerHandler(handler.getLooper());
   
4. 
   
5.     mUseDevInputEventForAudioJack =
   
6.                 context.getResources().getBoolean(R.bool.config_useDevInputEventForAudioJack);
   
7.     Slog.i(TAG, "Initializing input manager, mUseDevInputEventForAudioJack="
   
8.                     + mUseDevInputEventForAudioJack);
   
9.     mPtr = nativeInit(this, mContext, mHandler.getLooper().getQueue());
   
10. }

點擊(此處)折疊或打開

1. static jint nativeInit(JNIEnv* env, jclass clazz,
   
2.     jobject serviceObj, jobject contextObj, jobject messageQueueObj) {
   
3.     sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
   
4.     NativeInputManager* im = new NativeInputManager(contextObj, serviceObj,
   
5.     messageQueue->getLooper());
   
6.     im->incStrong(serviceObj);
   
7.     return reinterpret_cast<jint>(im);
   
8. }

點擊(此處)折疊或打開

1. NativeInputManager::NativeInputManager(jobject contextObj,
   
2.     jobject serviceObj, const sp<Looper>& looper) :
   
3.     mLooper(looper) {
   
4.     JNIEnv* env = jniEnv();
   
5. 
   
6.     mContextObj = env->NewGlobalRef(contextObj);
   
7.     mServiceObj = env->NewGlobalRef(serviceObj);
   
8. 
   
9.     {
   
10.         AutoMutex _l(mLock);
    
11.         mLocked.systemUiVisibility = ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE;
    
12.         mLocked.pointerSpeed = 0;
    
13.         mLocked.pointerGesturesEnabled = true;
    
14.         mLocked.showTouches = false;
    
15.     }
    
16. 
    
17.     sp<EventHub> eventHub = new EventHub();
    
18.     mInputManager = new InputManager(eventHub, this, this);
    
19. }

點擊(此處)折疊或打開

1. ServiceManager.addService(Context.INPUT_SERVICE, inputManager);
   
2.     inputManager.start();
   
3.     //InputManager的start函數(shù)：
   
4.     public void start() {
   
5.     Slog.i(TAG, "Starting input manager");
   
6.     nativeStart(mPtr);
   
7.     //省略。。
   
8. }

點擊(此處)折疊或打開

1. static void nativeStart(JNIEnv* env, jclass clazz, jint ptr) {
   
2.     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
   
3. 
   
4.     status_t result = im->getInputManager()->start();
   
5.     if (result) {
   
6.         jniThrowRuntimeException(env, "Input manager could not be started.");
   
7.     }
   
8. }

點擊(此處)折疊或打開

1. status_t InputManager::start() {
   
2.     status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);
   
3.     if (result) {
   
4.     ALOGE("Could not start InputDispatcher thread due to error %d.", result);
   
5.     return result;
   
6.     }
   
7. 
   
8.     result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);
   
9.     if (result) {
   
10.         ALOGE("Could not start InputReader thread due to error %d.", result);
    
11. 
    
12.         mDispatcherThread->requestExit();
    
13.         return result;
    
14.     }
    
15. 
    
16.     return OK;
    
17. }

點擊(此處)折疊或打開

1. void InputReader::loopOnce() {
   
2.     //......
   
3.     size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
   
4.     //......
   
5.     if (count) {
   
6.         processEventsLocked(mEventBuffer, count);
   
7.     }
   
8.     //......
   
9.     // Flush queued events out to the listener.
   
10.     // This must happen outside of the lock because the listener could potentially call
    
11.     // back into the InputReader's methods, such as getScanCodeState, or become blocked
    
12.     // on another thread similarly waiting to acquire the InputReader lock thereby
    
13.     // resulting in a deadlock. This situation is actually quite plausible because the
    
14.     // listener is actually the input dispatcher, which calls into the window manager,
    
15.     // which occasionally calls into the input reader.
    
16.     mQueuedListener->flush();
    
17. }

點擊(此處)折疊或打開

1. /*
   
2.      * Wait for events to become available and returns them.
   
3.      * After returning, the EventHub holds onto a wake lock until the next call to getEvent.
   
4.      * This ensures that the device will not go to sleep while the event is being processed.
   
5.      * If the device needs to remain awake longer than that, then the caller is responsible
   
6.      * for taking care of it (say, by poking the power manager user activity timer).
   
7.      *
   
8.      * The timeout is advisory only. If the device is asleep, it will not wake just to
   
9.      * service the timeout.
   
10.      *
    
11.      * Returns the number of events obtained, or 0 if the timeout expired.
    
12.      */
    
13.     virtual size_t getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize)

點擊(此處)折疊或打開

1. void InputDevice::process(const RawEvent* rawEvents, size_t count) {
   
2.     //。。。。
   
3.     InputMapper* mapper = mMappers[i];
   
4.     mapper->process(rawEvent);
   
5. }

點擊(此處)折疊或打開

1. InputDevice* InputReader::createDeviceLocked(int32_t deviceId,
   
2.                                                 const InputDeviceIdentifier& identifier, uint32_t classes)

點擊(此處)折疊或打開

1. if (keyboardSource != 0) {
   
2.         device->addMapper(new KeyboardInputMapper(device, keyboardSource, keyboardType));
   
3.     }

點擊(此處)折疊或打開

1. void KeyboardInputMapper::process(const RawEvent* rawEvent) {
   
2.     switch (rawEvent->type) {
   
3.     case EV_KEY: {
   
4.         int32_t scanCode = rawEvent->code;
   
5.         int32_t usageCode = mCurrentHidUsage;
   
6.         mCurrentHidUsage = 0;
   
7. 
   
8.         if (isKeyboardOrGamepadKey(scanCode)) {
   
9.             int32_t keyCode;
   
10.             uint32_t flags;
    
11.             if (getEventHub()->mapKey(getDeviceId(), scanCode, usageCode, &keyCode, &flags)) {
    
12.                 keyCode = AKEYCODE_UNKNOWN;
    
13.                 flags = 0;
    
14.             }
    
15.             processKey(rawEvent->when, rawEvent->value != 0, keyCode, scanCode, flags);
    
16.         }
    
17.         break;
    
18.     }
    
19.     }
    
20. }

點擊(此處)折疊或打開

1. void KeyboardInputMapper::processKey(nsecs_t when, bool down, int32_t keyCode,
   
2.         int32_t scanCode, uint32_t policyFlags) {
   
3.     //忽略到所有的。。只看最后兩行。。
   
4.     NotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags,
   
5.         down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,
   
6.          AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, newMetaState, downTime);
   
7. 
   
8.      getListener()->notifyKey(&args);
   
9. }