public void start() {
 Slog.i(TAG, "Starting input manager");
 nativeStart(mPtr);
 ........
}

static void nativeStart(JNIEnv* env, jclass /* clazz */, jlong ptr) {
 NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);

 status_t result = im->getInputManager()->start();
 if (result) {
  jniThrowRuntimeException(env, "Input manager could not be started.");
 }
}

status_t InputManager::start() {
 status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);
 if (result) {
  ALOGE("Could not start InputDispatcher thread due to error %d.", result);
  return result;
 }

 result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);
 if (result) {
  ALOGE("Could not start InputReader thread due to error %d.", result);

  mDispatcherThread->requestExit();
  return result;
 }

 return OK;
}

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
 synchronized (this) {
  if (mView == null) {
   mView = view;
   ..........
   if ((mWindowAttributes.inputFeatures
     & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
    mInputChannel = new InputChannel();
   }
   try {
    mOrigWindowType = mWindowAttributes.type;
    mAttachInfo.mRecomputeGlobalAttributes = true;
    collectViewAttributes();

    //Attention here!!!
    res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
      getHostVisibility(), mDisplay.getDisplayId(),
      mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
      mAttachInfo.mOutsets, mInputChannel);
   } catch (RemoteException e) {
    mAdded = false;
    mView = null;
    mAttachInfo.mRootView = null;
    mInputChannel = null;
    mFallbackEventHandler.setView(null);
    unscheduleTraversals();
    setAccessibilityFocus(null, null);
    throw new RuntimeException("Adding window failed", e);
   } finally {
    if (restore) {
     attrs.restore();
    }
   }
   ............
   if (mInputChannel != null) {
     if (mInputQueueCallback != null) {
      mInputQueue = new InputQueue();
      mInputQueueCallback.onInputQueueCreated(mInputQueue);
     }
     mInputEventReceiver = new WindowInputEventReceiver(mInputChannel,
       Looper.myLooper());
   }
  }
 }
}

final IWindowSession mWindowSession;

public ViewRootImpl(Context context, Display display) {
 mContext = context;
 mWindowSession = WindowManagerGlobal.getWindowSession();
 ......
}

public static IWindowSession getWindowSession() {
 synchronized (WindowManagerGlobal.class) {
  if (sWindowSession == null) {
   try {
    InputMethodManager imm = InputMethodManager.getInstance();
    IWindowManager windowManager = getWindowManagerService();
    sWindowSession = windowManager.openSession(
      new IWindowSessionCallback.Stub() {
       @Override
       public void onAnimatorScaleChanged(float scale) {
        ValueAnimator.setDurationScale(scale);
       }
      },
      imm.getClient(), imm.getInputContext());
   } catch (RemoteException e) {
    Log.e(TAG, "Failed to open window session", e);
   }
  }
  return sWindowSession;
 }
}

public int addWindow(Session session, IWindow client, int seq,
  WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
  Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
  InputChannel outInputChannel) {

  ..........
  if (outInputChannel != null && (attrs.inputFeatures
    & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
   String name = win.makeInputChannelName();
   InputChannel[] inputChannels = InputChannel.openInputChannelPair(name);
   win.setInputChannel(inputChannels[0]);
   inputChannels[1].transferTo(outInputChannel);

   mInputManager.registerInputChannel(win.mInputChannel, win.mInputWindowHandle);
  }
  ...........
}

mInputEventReceiver = new WindowInputEventReceiver(mInputChannel,
  Looper.myLooper());

final class WindowInputEventReceiver extends InputEventReceiver {
 public WindowInputEventReceiver(InputChannel inputChannel, Looper looper) {
  super(inputChannel, looper);
 }

 @Override
 public void onInputEvent(InputEvent event) {
  enqueueInputEvent(event, this, 0, true);
 }

 @Override
 public void onBatchedInputEventPending() {
  if (mUnbufferedInputDispatch) {
   super.onBatchedInputEventPending();
  } else {
   scheduleConsumeBatchedInput();
  }
 }

 @Override
 public void dispose() {
  unscheduleConsumeBatchedInput();
  super.dispose();
 }
}

void enqueueInputEvent(InputEvent event,
  InputEventReceiver receiver, int flags, boolean processImmediately) {
 .........
 if (processImmediately) {
  doProcessInputEvents();
 } else {
  scheduleProcessInputEvents();
 }
}

void doProcessInputEvents() {
 ........
 deliverInputEvent(q);
 ........
}

private void deliverInputEvent(QueuedInputEvent q) {
  Trace.asyncTraceBegin(Trace.TRACE_TAG_VIEW, "deliverInputEvent",
    q.mEvent.getSequenceNumber());
  if (mInputEventConsistencyVerifier != null) {
   mInputEventConsistencyVerifier.onInputEvent(q.mEvent, 0);
  }

  InputStage stage;
  if (q.shouldSendToSynthesizer()) {
   stage = mSyntheticInputStage;
  } else {
   stage = q.shouldSkipIme() ? mFirstPostImeInputStage : mFirstInputStage;
  }

  if (stage != null) {
   stage.deliver(q);
  } else {
   finishInputEvent(q);
  }
}

mSyntheticInputStage = new SyntheticInputStage();
InputStage viewPostImeStage = new ViewPostImeInputStage(mSyntheticInputStage);
InputStage nativePostImeStage = new NativePostImeInputStage(viewPostImeStage,
  "aq:native-post-ime:" + counterSuffix);
InputStage earlyPostImeStage = new EarlyPostImeInputStage(nativePostImeStage);
InputStage imeStage = new ImeInputStage(earlyPostImeStage,
  "aq:ime:" + counterSuffix);
InputStage viewPreImeStage = new ViewPreImeInputStage(imeStage);
InputStage nativePreImeStage = new NativePreImeInputStage(viewPreImeStage,
  "aq:native-pre-ime:" + counterSuffix);

mFirstInputStage = nativePreImeStage;
mFirstPostImeInputStage = earlyPostImeStage;

public final void deliver(QueuedInputEvent q) {
 if ((q.mFlags & QueuedInputEvent.FLAG_FINISHED) != 0) {
  forward(q);
 } else if (shouldDropInputEvent(q)) {
  finish(q, false);
 } else {
  apply(q, onProcess(q));
 }
}

@Override
protected int onProcess(QueuedInputEvent q) {
 if (q.mEvent instanceof KeyEvent) {
  return processKeyEvent(q);
 }
 return FORWARD;
}

private int processKeyEvent(QueuedInputEvent q) {
 final KeyEvent event = (KeyEvent)q.mEvent;
 if (mView.dispatchKeyEventPreIme(event)) {
  return FINISH_HANDLED;
 }
 return FORWARD;
}