学步园

点击(此处)折叠或打开

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函数：
   
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. }