【安卓Sensor框架-3】Sensor事件上报流程

sensor事件上报流程 主要为如下：

由前面一篇博文分析，hal层传感器事件会上报给 aidl 层，会调用 postEventsToMessageQueue 方法

/hardware/interfaces/sensors/common/default/2.X/multihal/HalProxy.cpp

661  void HalProxy::postEventsToMessageQueue(const std::vector<Event>& events, size_t numWakeupEvents,
662                                          V2_0::implementation::ScopedWakelock wakelock) {
663      size_t numToWrite = 0;
664      std::lock_guard<std::mutex> lock(mEventQueueWriteMutex);
665      if (wakelock.isLocked()) {
666          incrementRefCountAndMaybeAcquireWakelock(numWakeupEvents);
667      }
668      if (mPendingWriteEventsQueue.empty()) {
669          numToWrite = std::min(events.size(), mEventQueue->availableToWrite());
670          if (numToWrite > 0) {
// 写入sensor 事件到 mEventQueue
671              if (mEventQueue->write(events.data(), numToWrite)) {
672                  // TODO(b/143302327): While loop if mEventQueue->avaiableToWrite > 0 to possibly fit
673                  // in more writes immediately
// 唤醒处理sensor事件
674                  mEventQueueFlag->wake(static_cast<uint32_t>(EventQueueFlagBits::READ_AND_PROCESS));

而对应的系统进程sensorservice 会创建个线程监听hal 层的数据

// 对应的监听是在 SensorService线程中监听的

1040  bool SensorService::threadLoop() {
1041      ALOGD("nuSensorService thread starting...");
1042  
1043      // each virtual sensor could generate an event per "real" event, that's why we need to size
1044      // numEventMax much smaller than MAX_RECEIVE_BUFFER_EVENT_COUNT.  in practice, this is too
1045      // aggressive, but guaranteed to be enough.
1046      const size_t vcount = mSensors.getVirtualSensors().size();
1047      const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT;
1048      const size_t numEventMax = minBufferSize / (1 + vcount);
1049  
1050      SensorDevice& device(SensorDevice::getInstance());
1051  
1052      const int halVersion = device.getHalDeviceVersion();
1053      do {
// 调用 SensorDevice 监听 sensor数据
1054          ssize_t count = device.poll(mSensorEventBuffer, numEventMax);
1055          if (count < 0) {
1056              if(count == DEAD_OBJECT && device.isReconnecting()) {
。。。
1172          const std::vector<sp<SensorEventConnection>> activeConnections = connLock.getActiveConnections();
。。。
// 遍历所有的connection，去通知到应用客户端
// 调用 SensorEventConnection 的 sendEvents 方法
1235          for (const sp<SensorEventConnection>& connection : activeConnections) {
1236              connection->sendEvents(mSensorEventBuffer, count, mSensorEventScratch,
1237                      mMapFlushEventsToConnections);
1238              needsWakeLock |= connection->needsWakeLock();

// 调用 SensorDevice 监听 sensor数据

/frameworks/native/services/sensorservice/SensorDevice.cpp

351  ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
352      if (mHalWrapper == nullptr) return NO_INIT;
353  
354      ssize_t eventsRead = 0;
// aidlhal 是为true 的
355      if (mHalWrapper->supportsMessageQueues()) {
// 调用 的pollFmq 
356          eventsRead = mHalWrapper->pollFmq(buffer, count);
357      } else if (mHalWrapper->supportsPolling()) {
358          eventsRead = mHalWrapper->poll(buffer, count);
359      } else {
360          ALOGE("Must support polling or FMQ");
361          eventsRead = -1;
362      }
363  
364      if (eventsRead > 0) {

/frameworks/native/services/sensorservice/AidlSensorHalWrapper.cpp

160  ssize_t AidlSensorHalWrapper::pollFmq(sensors_event_t *buffer, size_t maxNumEventsToRead) {
161      ssize_t eventsRead = 0;
162      size_t availableEvents = mEventQueue->availableToRead();
163  
164      if (availableEvents == 0) {
165          uint32_t eventFlagState = 0;
166  
167          // Wait for events to become available. This is necessary so that the Event FMQ's read() is
168          // able to be called with the correct number of events to read. If the specified number of
169          // events is not available, then read() would return no events, possibly introducing
170          // additional latency in delivering events to applications.
// 等待数据通过 mEventQueueFlag
//  这里 postEventsToMessageQueue 会唤醒
171          if (mEventQueueFlag != nullptr) {
172              mEventQueueFlag->wait(asBaseType(ISensors::EVENT_QUEUE_FLAG_BITS_READ_AND_PROCESS) |
173                                            asBaseType(INTERNAL_WAKE),
174                                    &eventFlagState);
175          }
176          availableEvents = mEventQueue->availableToRead();

一个应用注册一个监听，会创建对应的 SensorEventConnection 。

// 调用 SensorEventConnection 的 sendEvents 方法

/frameworks/native/services/sensorservice/SensorEventConnection.cpp

290  status_t SensorService::SensorEventConnection::sendEvents(
// buffer 是传入的sensor  的数据
291          sensors_event_t const* buffer, size_t numEvents,
292          sensors_event_t* scratch,
293          wp<const SensorEventConnection> const * mapFlushEventsToConnections) {
294      // filter out events not for this connection
295  
296      std::unique_ptr<sensors_event_t[]> sanitizedBuffer;
297  
298      int count = 0;
299      Mutex::Autolock _l(mConnectionLock);
300      if (scratch) {
301          size_t i=0;
302          while (i<numEvents) {
303              int32_t sensor_handle = buffer[i].sensor;
304              if (buffer[i].type == SENSOR_TYPE_META_DATA) {
305                  ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ",
306                          buffer[i].meta_data.sensor);
307                  // Setting sensor_handle to the correct sensor to ensure the sensor events per
308                  // connection are filtered correctly.  buffer[i].sensor is zero for meta_data
309                  // events.
// 获取到sensor 的handle
310                  sensor_handle = buffer[i].meta_data.sensor;
311              }
312  
313              // Check if this connection has registered for this sensor. If not continue to the
314              // next sensor_event.
// 一个 应用有一个SensorEventConnection，对应一个sensor
// 遍历是否是该 SensorEventConnection 的sensor
315              if (mSensorInfo.count(sensor_handle) == 0) {
316                  ++i;
317                  continue;
318              }
。。。。
405      // NOTE: ASensorEvent and sensors_event_t are the same type.
// socket 通信通知到 sensorservice
406      ssize_t size = SensorEventQueue::write(mChannel,
407                                      reinterpret_cast<ASensorEvent const*>(scratch), count);

61  ssize_t SensorEventQueue::write(const sp<BitTube>& tube,
62          ASensorEvent const* events, size_t numEvents) {
63      return BitTube::sendObjects(tube, events, numEvents);
64  }

// 由前面分析，在android_hardware_SensorManager创建了 Receiver，监听了socket事件

• nativeInitSensorEventQueue注册初始化Receiver

• Receiver实例化后调用onFirstRef()，handler\Looper
  轮询LooperCallback监听回调Receiver::handleEvent()

• mSensorQueue->getFd() 实际就是 SensorEventQueue > SensorEventConnection >
  BitTube::getFd() 里边mReceiveFd = sockets[0]

• env->CallVoidMethod(…gBaseEventQueueClassInfo.dispatchSensorEvent…)
  JNI 调用Java层SensorEventQueue中dispatchSensorEvent方法

/frameworks/base/core/jni/android_hardware_SensorManager.cpp

327  class Receiver : public LooperCallback {
328      sp<SensorEventQueue> mSensorQueue;
329      sp<MessageQueue> mMessageQueue;
330      jobject mReceiverWeakGlobal;
331      jfloatArray mFloatScratch;
332      jintArray   mIntScratch;

359  private:
360      virtual void onFirstRef() {
361          LooperCallback::onFirstRef();
362          mMessageQueue->getLooper()->addFd(mSensorQueue->getFd(), 0,
363                  ALOOPER_EVENT_INPUT, this, mSensorQueue.get());
364      }

// loopper 会回调handleEvent 方法

366      virtual int handleEvent(int fd, int events, void* data) {
367          JNIEnv* env = AndroidRuntime::getJNIEnv();
368          sp<SensorEventQueue> q = reinterpret_cast<SensorEventQueue *>(data);
369          ScopedLocalRef<jobject> receiverObj(env, GetReferent(env, mReceiverWeakGlobal));
370  
371          ssize_t n;
372          ASensorEvent buffer[16];
373          while ((n = q->read(buffer, 16)) > 0) {
374              for (int i=0 ; i<n ; i++) {
375                  if (buffer[i].type == SENSOR_TYPE_STEP_COUNTER) {
376                      // step-counter returns a uint64, but the java API only deals with floats
377                      float value = float(buffer[i].u64.step_counter);
378                      env->SetFloatArrayRegion(mFloatScratch, 0, 1, &value);
。。。
433                      if (receiverObj.get()) {
// 回调java层的方法
434                          env->CallVoidMethod(receiverObj.get(),
435                                              gBaseEventQueueClassInfo.dispatchSensorEvent,
436                                              buffer[i].sensor,
437                                              mFloatScratch,
438                                              status,
439                                              buffer[i].timestamp);
440                      }

/frameworks/base/core/java/android/hardware/SystemSensorManager.java

966          // Called from native code.
967          @SuppressWarnings("unused")
968          @Override
969          protected void dispatchSensorEvent(int handle, float[] values, int inAccuracy,
970                  long timestamp) {
971              final Sensor sensor = mManager.mHandleToSensor.get(handle);
972              if (sensor == null) {
973                  // sensor disconnected
974                  return;
975              }
976  
977              SensorEvent t = null;
978              synchronized (mSensorsEvents) {
979                  t = mSensorsEvents.get(handle);
980              }
981  
982              if (t == null) {
983                  // This may happen if the client has unregistered and there are pending events in
984                  // the queue waiting to be delivered. Ignore.
985                  return;
986              }
987              // Copy from the values array.
988              System.arraycopy(values, 0, t.values, 0, t.values.length);
989              t.timestamp = timestamp;
990              t.accuracy = inAccuracy;
991              t.sensor = sensor;
992  
993              // call onAccuracyChanged() only if the value changes
994              final int accuracy = mSensorAccuracies.get(handle);
995              if (t.accuracy >= 0 && accuracy != t.accuracy) {
996                  mSensorAccuracies.put(handle, t.accuracy);
997                  mListener.onAccuracyChanged(t.sensor, t.accuracy);
998              }
999  
1000              // Indicate if the discontinuity count changed
1001              t.firstEventAfterDiscontinuity = false;
1002              if (t.sensor.getType() == Sensor.TYPE_HEAD_TRACKER) {
1003                  final int lastCount = mSensorDiscontinuityCounts.get(handle);
1004                  final int curCount = Float.floatToIntBits(values[6]);
1005                  if (lastCount >= 0 && lastCount != curCount) {
1006                      mSensorDiscontinuityCounts.put(handle, curCount);
1007                      t.firstEventAfterDiscontinuity = true;
1008                  }
1009              }
1010  
// 回调观察者的 onSensorChanged方法
1011              mListener.onSensorChanged(t);
1012          }

// 回调观察者的 onSensorChanged方法

/frameworks/base/services/core/java/com/android/server/display/AutomaticBrightnessController.java

1346      private final SensorEventListener mLightSensorListener = new SensorEventListener() {
1347          @Override
1348          public void onSensorChanged(SensorEvent event) {
1349              if (mLightSensorEnabled) {
1350                  final long time = mClock.uptimeMillis();
1351                  final float lux = event.values[0];
1352                  handleLightSensorEvent(time, lux);
1353              }
1354          }

845      private void updateAmbientLux(long time) {
846          // If the light sensor was just turned on then immediately update our initial
847          // estimate of the current ambient light level.
848          if (!mAmbientLuxValid) {
849              final long timeWhenSensorWarmedUp =
850                  mLightSensorWarmUpTimeConfig + mLightSensorEnableTime;
851              if (time < timeWhenSensorWarmedUp) {
852                  if (mLoggingEnabled) {
853                      Slog.d(TAG, "updateAmbientLux: Sensor not ready yet: "
854                              + "time=" + time + ", "
855                              + "timeWhenSensorWarmedUp=" + timeWhenSensorWarmedUp);
856                  }
。。。
884          if ((mSlowAmbientLux >= mAmbientBrighteningThreshold
885                  && mFastAmbientLux >= mAmbientBrighteningThreshold
886                  && nextBrightenTransition <= time)
887                  || (mSlowAmbientLux <= mAmbientDarkeningThreshold
888                          && mFastAmbientLux <= mAmbientDarkeningThreshold
889                          && nextDarkenTransition <= time)) {
890              mPreThresholdLux = mAmbientLux;
891              setAmbientLux(mFastAmbientLux);
892              if (mLoggingEnabled) {
893                  Slog.d(TAG, "updateAmbientLux: "
894                          + ((mFastAmbientLux > mAmbientLux) ? "Brightened" : "Darkened") + ": "
895                          + "mAmbientBrighteningThreshold=" + mAmbientBrighteningThreshold + ", "
896                          + "mAmbientDarkeningThreshold=" + mAmbientDarkeningThreshold + ", "
897                          + "mAmbientLightRingBuffer=" + mAmbientLightRingBuffer + ", "
898                          + "mAmbientLux=" + mAmbientLux);
899              }
// 这里去更新亮度
900              updateAutoBrightness(true /* sendUpdate */, false /* isManuallySet */);
901              nextBrightenTransition = nextAmbientLightBrighteningTransition(time);
902              nextDarkenTransition = nextAmbientLightDarkeningTransition(time);
903          }

// 对自动亮度算法的一些计算

920      private void updateAutoBrightness(boolean sendUpdate, boolean isManuallySet) {
921          if (!mAmbientLuxValid) {
922              return;
923          }
924  
925          float value = mCurrentBrightnessMapper.getBrightness(mAmbientLux, mForegroundAppPackageName,
926                  mForegroundAppCategory);
927          mRawScreenAutoBrightness = value;
928          float newScreenAutoBrightness = clampScreenBrightness(value);
。。。
975              if (sendUpdate) {
// 通知到 DisplayPowerController
976                  mCallbacks.updateBrightness();
977              }
978          }
979      }

// 调用 DisplayPowerController的updateBrightness

/frameworks/base/services/core/java/com/android/server/display/DisplayPowerController2.java

1744      @Override
1745      public void updateBrightness() {
1746          sendUpdatePowerState();
1747      }

886      private void sendUpdatePowerState() {
887          synchronized (mLock) {
888              sendUpdatePowerStateLocked();
889          }
890      }

892      @GuardedBy("mLock")
893      private void sendUpdatePowerStateLocked() {
894          if (!mStopped && !mPendingUpdatePowerStateLocked) {
895              mPendingUpdatePowerStateLocked = true;
896              Message msg = mHandler.obtainMessage(MSG_UPDATE_POWER_STATE);
897              mHandler.sendMessageAtTime(msg, mClock.uptimeMillis());
898          }
899      }

2714          @Override
2715          public void handleMessage(Message msg) {
2716              switch (msg.what) {
2717                  case MSG_UPDATE_POWER_STATE:
2718                      updatePowerState();
2719                      break;

1230      // Call from handler thread
1231      private void updatePowerState() {
1232          Trace.traceBegin(Trace.TRACE_TAG_POWER,
1233                  "DisplayPowerController#updatePowerState");
1234          updatePowerStateInternal();
1235          Trace.traceEnd(Trace.TRACE_TAG_POWER);
1236      }

1238      private void updatePowerStateInternal() {
1239          // Update the power state request.
1240          final boolean mustNotify;
1241          final int previousPolicy;
。。。
1339          int brightnessAdjustmentFlags = 0;
1340          if (Float.isNaN(brightnessState)) {
// 从下列获取到自动亮度的值
1341              if (mAutomaticBrightnessStrategy.isAutoBrightnessEnabled()) {
1342                  brightnessState = mAutomaticBrightnessStrategy.getAutomaticScreenBrightness(
1343                          mTempBrightnessEvent);
1344                  if (BrightnessUtils.isValidBrightnessValue(brightnessState)
1345                          || brightnessState == PowerManager.BRIGHTNESS_OFF_FLOAT) {
1346                      rawBrightnessState = mAutomaticBrightnessController
1347                              .getRawAutomaticScreenBrightness();
1348                      brightnessState = clampScreenBrightness(brightnessState);
1349                      // slowly adapt to auto-brightness
1350                      // TODO(b/253226419): slowChange should be decided by strategy.updateBrightness
1351                      slowChange = mAutomaticBrightnessStrategy.hasAppliedAutoBrightness()
1352                              && !mAutomaticBrightnessStrategy.getAutoBrightnessAdjustmentChanged();
1353                      brightnessAdjustmentFlags =
1354                              mAutomaticBrightnessStrategy.getAutoBrightnessAdjustmentReasonsFlags();
1355                      updateScreenBrightnessSetting = currentBrightnessSetting != brightnessState;
1356                      mAutomaticBrightnessStrategy.setAutoBrightnessApplied(true);
1357                      mBrightnessReasonTemp.setReason(BrightnessReason.REASON_AUTOMATIC);
1358                      if (mScreenOffBrightnessSensorController != null) {
1359                          mScreenOffBrightnessSensorController.setLightSensorEnabled(false);
1360                      }
1361                  } else {
1362                      mAutomaticBrightnessStrategy.setAutoBrightnessApplied(false);
1363                  }
1364              }
。。。
1551              if (BrightnessUtils.isValidBrightnessValue(animateValue)
1552                      && (animateValue != currentBrightness
1553                      || sdrAnimateValue != currentSdrBrightness)) {
1554                  if (initialRampSkip || hasBrightnessBuckets
1555                          || !isDisplayContentVisible || brightnessIsTemporary) {
1556                      animateScreenBrightness(animateValue, sdrAnimateValue,
1557                              SCREEN_ANIMATION_RATE_MINIMUM);
1558                  } else {
1559                      boolean isIncreasing = animateValue > currentBrightness;
1560                      final float rampSpeed;
1561                      if (isIncreasing && slowChange) {
1562                          rampSpeed = mBrightnessRampRateSlowIncrease;
1563                      } else if (isIncreasing && !slowChange) {
1564                          rampSpeed = mBrightnessRampRateFastIncrease;
1565                      } else if (!isIncreasing && slowChange) {
1566                          rampSpeed = mBrightnessRampRateSlowDecrease;
1567                      } else {
1568                          rampSpeed = mBrightnessRampRateFastDecrease;
1569                      }
// 然后调用 animateScreenBrightness 方法
1570                      animateScreenBrightness(animateValue, sdrAnimateValue, rampSpeed);
1571                  }
1572              }

// 然后调用 animateScreenBrightness 方法

2017      private void animateScreenBrightness(float target, float sdrTarget, float rate) {
2018          if (DEBUG) {
2019              Slog.d(mTag, "Animating brightness: target=" + target + ", sdrTarget=" + sdrTarget
2020                      + ", rate=" + rate);
2021          }
2022          if (mScreenBrightnessRampAnimator.animateTo(target, sdrTarget, rate)) {
2023              Trace.traceCounter(Trace.TRACE_TAG_POWER, "TargetScreenBrightness", (int) target);
2024  
2025              String propertyKey = "debug.tracing.screen_brightness";
2026              String propertyValue = String.valueOf(target);
2027              try {
2028                  // TODO(b/153319140) remove when we can get this from the above trace invocation
2029                  SystemProperties.set(propertyKey, propertyValue);
2030              } catch (RuntimeException e) {
2031                  Slog.e(mTag, "Failed to set a system property: key=" + propertyKey
2032                          + " value=" + propertyValue + " " + e.getMessage());
2033              }
2034  
2035              noteScreenBrightness(target);
2036          }
2037      }

// 先看下 mScreenBrightnessRampAnimator 对象

917          mScreenBrightnessRampAnimator = mInjector.getDualRampAnimator(mPowerState,
918                  DisplayPowerState.SCREEN_BRIGHTNESS_FLOAT,
919                  DisplayPowerState.SCREEN_SDR_BRIGHTNESS_FLOAT);

2890          DualRampAnimator<DisplayPowerState> getDualRampAnimator(DisplayPowerState dps,
2891                  FloatProperty<DisplayPowerState> firstProperty,
2892                  FloatProperty<DisplayPowerState> secondProperty) {
2893              return new DualRampAnimator(dps, firstProperty, secondProperty);
2894          }

// 对应的是 DualRampAnimator 对象

187      static class DualRampAnimator<T> {
188          private final Choreographer mChoreographer;
189          private final RampAnimator<T> mFirst;
190          private final RampAnimator<T> mSecond;
191  
192          private Listener mListener;
193          private boolean mAwaitingCallback;
194  
195          DualRampAnimator(T object, FloatProperty<T> firstProperty,
196                  FloatProperty<T> secondProperty) {
197              mChoreographer = Choreographer.getInstance();
// first 用 RampAnimator 包装了
198              mFirst = new RampAnimator<>(object, firstProperty);
199              mSecond = new RampAnimator<>(object, secondProperty);
200          }

// 接下来调用 animateTo 方法

224          public boolean animateTo(float linearFirstTarget, float linearSecondTarget, float rate) {
225              boolean animationTargetChanged = mFirst.setAnimationTarget(linearFirstTarget, rate);
226              animationTargetChanged |= mSecond.setAnimationTarget(linearSecondTarget, rate);
227              boolean shouldBeAnimating = isAnimating();
228  
229              if (shouldBeAnimating != mAwaitingCallback) {
230                  if (shouldBeAnimating) {
231                      mAwaitingCallback = true;
232                      postAnimationCallback();
233                  } else if (mAwaitingCallback) {
234                      mChoreographer.removeCallbacks(Choreographer.CALLBACK_ANIMATION,
235                              mAnimationCallback, null);
236                      mAwaitingCallback = false;
237                  }
238              }
239              return animationTargetChanged;
240          }

//其中 mFirst 为 new RampAnimator<>(object, firstProperty)
// 调用 setAnimationTarget 方法

77      boolean setAnimationTarget(float targetLinear, float rate) {
78          // Convert the target from the linear into the HLG space.
79          final float target = BrightnessUtils.convertLinearToGamma(targetLinear);
80  
81          // Immediately jump to the target the first time.
82          if (mFirstTime || rate <= 0) {
83              if (mFirstTime || target != mCurrentValue) {
84                  mFirstTime = false;
85                  mRate = 0;
86                  mTargetHlgValue = target;
87                  mTargetLinearValue = targetLinear;
88                  mCurrentValue = target;
// 给属性设置值
89                  setPropertyValue(target);
90                  mAnimating = false;
91                  return true;
92              }
93              return false;
94          }
95

144      private void setPropertyValue(float val) {
145          // To avoid linearVal inconsistency when converting to HLG and back to linear space
146          // used original target linear value for final animation step
147          float linearVal =
148                  val == mTargetHlgValue ? mTargetLinearValue : BrightnessUtils.convertGammaToLinear(
149                          val);
150          mProperty.setValue(mObject, linearVal);
151      }

mProperty 的值为如下：

116      public static final FloatProperty<DisplayPowerState> SCREEN_BRIGHTNESS_FLOAT =
117              new FloatProperty<DisplayPowerState>("screenBrightnessFloat") {
118                  @Override
// object 的值为DisplayPowerState 
119                  public void setValue(DisplayPowerState object, float value) {
120                      object.setScreenBrightness(value);
121                  }
122  
123                  @Override
124                  public Float get(DisplayPowerState object) {
125                      return object.getScreenBrightness();
126                  }
127              };

// 所以调用 DisplayPowerState setScreenBrightness 方法

/frameworks/base/services/core/java/com/android/server/display/DisplayPowerState.java

197      public void setScreenBrightness(float brightness) {
198          if (mScreenBrightness != brightness) {
199              if (DEBUG) {
200                  Slog.d(TAG, "setScreenBrightness: brightness=" + brightness);
201              }
202  
203              mScreenBrightness = brightness;
204              if (mScreenState != Display.STATE_OFF) {
205                  mScreenReady = false;
206                  scheduleScreenUpdate();
207              }
208          }
209      }

351      private void scheduleScreenUpdate() {
352          if (!mScreenUpdatePending) {
353              mScreenUpdatePending = true;
354              postScreenUpdateThreadSafe();
355          }
356      }

358      private void postScreenUpdateThreadSafe() {
359          mHandler.removeCallbacks(mScreenUpdateRunnable);
360          mHandler.post(mScreenUpdateRunnable);
361      }

379      private final Runnable mScreenUpdateRunnable = new Runnable() {
380          @Override
381          public void run() {
382              mScreenUpdatePending = false;
383  
384              float brightnessState = mScreenState != Display.STATE_OFF
385                      && mColorFadeLevel > 0f ? mScreenBrightness : PowerManager.BRIGHTNESS_OFF_FLOAT;
386              float sdrBrightnessState = mScreenState != Display.STATE_OFF
387                      && mColorFadeLevel > 0f
388                              ? mSdrScreenBrightness : PowerManager.BRIGHTNESS_OFF_FLOAT;
389              if (mPhotonicModulator.setState(mScreenState, brightnessState, sdrBrightnessState)) {
390                  if (DEBUG) {
391                      Slog.d(TAG, "Screen ready");
392                  }
393                  mScreenReady = true;
394                  invokeCleanListenerIfNeeded();
395              } else {
396                  if (DEBUG) {
397                      Slog.d(TAG, "Screen not ready");
398                  }
399              }
400          }
401      };

PhotonicModulator是个线程

437          public PhotonicModulator() {
438              super("PhotonicModulator");
439          }
440  
441          public boolean setState(int state, float brightnessState, float sdrBrightnessState) {
442              synchronized (mLock) {
443                  boolean stateChanged = state != mPendingState;
444                  boolean backlightChanged = brightnessState != mPendingBacklight
445                          || sdrBrightnessState != mPendingSdrBacklight;
446                  if (stateChanged || backlightChanged) {
447                      if (DEBUG) {
448                          Slog.d(TAG, "Requesting new screen state: state="
449                                  + Display.stateToString(state) + ", backlight=" + brightnessState);
450                      }
451  
452                      mPendingState = state;
453                      mPendingBacklight = brightnessState;
454                      mPendingSdrBacklight = sdrBrightnessState;
455                      boolean changeInProgress = mStateChangeInProgress || mBacklightChangeInProgress;
456                      mStateChangeInProgress = stateChanged || mStateChangeInProgress;
457                      mBacklightChangeInProgress = backlightChanged || mBacklightChangeInProgress;
458  
// 唤醒主线程
459                      if (!changeInProgress) {
460                          mLock.notifyAll();
461                      }
462                  }
463                  return !mStateChangeInProgress;
464              }
465          }

// 执行run 方法

482          @Override
483          public void run() {
484              for (;;) {
485                  // Get pending change.
486                  final int state;
487                  final boolean stateChanged;
488                  final float brightnessState;
489                  final float sdrBrightnessState;
490                  final boolean backlightChanged;
。。。。
511                          try {
512                              mLock.wait();
513                          } catch (InterruptedException ex) {
514                              if (mStopped) {
515                                  return;
516                              }
517                          }
518                          continue;
519                      }
520                      mActualState = state;
521                      mActualBacklight = brightnessState;
522                      mActualSdrBacklight = sdrBrightnessState;
523                  }
524  
525                  // Apply pending change.
526                  if (DEBUG) {
527                      Slog.d(TAG, "Updating screen state: id=" + mDisplayId +  ", state="
528                              + Display.stateToString(state) + ", backlight=" + brightnessState
529                              + ", sdrBacklight=" + sdrBrightnessState);
530                  }
531                  mBlanker.requestDisplayState(mDisplayId, state, brightnessState,
532                          sdrBrightnessState);
533              }
534          }

/frameworks/base/services/core/java/com/android/server/display/DisplayManagerService.java

337      private final DisplayBlanker mDisplayBlanker = new DisplayBlanker() {
338          // Synchronized to avoid race conditions when updating multiple display states.
339          @Override
340          public synchronized void requestDisplayState(int displayId, int state, float brightness,
341                  float sdrBrightness) {
342              boolean allInactive = true;
343              boolean allOff = true;
344              final boolean stateChanged;
345              synchronized (mSyncRoot) {
346                  final int index = mDisplayStates.indexOfKey(displayId);
347                  if (index > -1) {
348                      final int currentState = mDisplayStates.valueAt(index);
349                      stateChanged = state != currentState;
350                      if (stateChanged) {
351                          final int size = mDisplayStates.size();
352                          for (int i = 0; i < size; i++) {
353                              final int displayState = i == index ? state : mDisplayStates.valueAt(i);
354                              if (displayState != Display.STATE_OFF) {
355                                  allOff = false;
356                              }
357                              if (Display.isActiveState(displayState)) {
358                                  allInactive = false;
359                              }
360                              if (!allOff && !allInactive) {
361                                  break;
362                              }
363                          }
364                      }
365                  } else {
366                      stateChanged = false;
367                  }
368              }
369  
370              // The order of operations is important for legacy reasons.
371              if (state == Display.STATE_OFF) {
372                  requestDisplayStateInternal(displayId, state, brightness, sdrBrightness);
373              }
374  
375              if (stateChanged) {
376                  mDisplayPowerCallbacks.onDisplayStateChange(allInactive, allOff);
377              }
378  
379              if (state != Display.STATE_OFF) {
380                  requestDisplayStateInternal(displayId, state, brightness, sdrBrightness);
381              }
382          }
383      };

864      private void requestDisplayStateInternal(int displayId, int state, float brightnessState,
865              float sdrBrightnessState) {
866          if (state == Display.STATE_UNKNOWN) {
867              state = Display.STATE_ON;
868          }
869  
870          brightnessState = clampBrightness(state, brightnessState);
871          sdrBrightnessState = clampBrightness(state, sdrBrightnessState);
872  
873          // Update the display state within the lock.
874          // Note that we do not need to schedule traversals here although it
875          // may happen as a side-effect of displays changing state.
876          final Runnable runnable;
877          final String traceMessage;
878          synchronized (mSyncRoot) {
。。。
// 获取到 runnable  方法并执行
901              runnable = updateDisplayStateLocked(mLogicalDisplayMapper.getDisplayLocked(displayId)
902                      .getPrimaryDisplayDeviceLocked());
903              if (Trace.isTagEnabled(Trace.TRACE_TAG_POWER)) {
904                  Trace.asyncTraceForTrackEnd(Trace.TRACE_TAG_POWER,
905                          "requestDisplayStateInternal:" + displayId, displayId);
906              }
907          }
908  
909          // Setting the display power state can take hundreds of milliseconds
910          // to complete so we defer the most expensive part of the work until
911          // after we have exited the critical section to avoid blocking other
912          // threads for a long time.
913          if (runnable != null) {
914              runnable.run();
915          }
916      }

1992      private Runnable updateDisplayStateLocked(DisplayDevice device) {
1993          // Blank or unblank the display immediately to match the state requested
1994          // by the display power controller (if known).
1995          DisplayDeviceInfo info = device.getDisplayDeviceInfoLocked();
1996          if ((info.flags & DisplayDeviceInfo.FLAG_NEVER_BLANK) == 0) {
1997              final LogicalDisplay display = mLogicalDisplayMapper.getDisplayLocked(device);
1998              if (display == null) {
1999                  return null;
2000              }
2001              final int displayId = display.getDisplayIdLocked();
2002              final int state = mDisplayStates.get(displayId);
2003  
2004              // Only send a request for display state if display state has already been initialized.
2005              if (state != Display.STATE_UNKNOWN) {
2006                  final BrightnessPair brightnessPair = mDisplayBrightnesses.get(displayId);
2007                  return device.requestDisplayStateLocked(state, brightnessPair.brightness,
2008                          brightnessPair.sdrBrightness);
2009              }
2010          }
2011          return null;
2012      }

/frameworks/base/services/core/java/com/android/server/display/LocalDisplayAdapter.java

748          @Override
749          public Runnable requestDisplayStateLocked(final int state, final float brightnessState,
750                  final float sdrBrightnessState) {
751              // Assume that the brightness is off if the display is being turned off.
752              assert state != Display.STATE_OFF
753                      || brightnessState == PowerManager.BRIGHTNESS_OFF_FLOAT;
754              final boolean stateChanged = (mState != state);
755              final boolean brightnessChanged = mBrightnessState != brightnessState
756                      || mSdrBrightnessState != sdrBrightnessState;
757              if (stateChanged || brightnessChanged) {
758                  final long physicalDisplayId = mPhysicalDisplayId;
759                  final IBinder token = getDisplayTokenLocked();
760                  final int oldState = mState;
761  
762                  if (stateChanged) {
763                      mState = state;
764                      updateDeviceInfoLocked();
765                  }
766  
767                  // Defer actually setting the display state until after we have exited
768                  // the critical section since it can take hundreds of milliseconds
769                  // to complete.
770                  return new Runnable() {
771                      @Override
772                      public void run() {
773                          // Exit a suspended state before making any changes.
774                          int currentState = oldState;
775                          if (Display.isSuspendedState(oldState)
776                                  || oldState == Display.STATE_UNKNOWN) {
777                              if (!Display.isSuspendedState(state)) {
778                                  setDisplayState(state);
779                                  currentState = state;
780                              } else if (state == Display.STATE_DOZE_SUSPEND
781                                      || oldState == Display.STATE_DOZE_SUSPEND) {
782                                  setDisplayState(Display.STATE_DOZE);
783                                  currentState = Display.STATE_DOZE;
784                              } else if (state == Display.STATE_ON_SUSPEND
785                                      || oldState == Display.STATE_ON_SUSPEND) {
786                                  setDisplayState(Display.STATE_ON);
787                                  currentState = Display.STATE_ON;
788  
789                              // If UNKNOWN, we still want to set the initial display state,
790                              // otherwise, return early.
791                              } else if (oldState != Display.STATE_UNKNOWN) {
792                                  return; // old state and new state is off
793                              }
794                          }
795  
796                          // Apply brightness changes given that we are in a non-suspended state.
797                          if (brightnessChanged) {

// 执行设置亮度

861                      private void setDisplayBrightness(float brightnessState,
862                              float sdrBrightnessState) {
863                          // brightnessState includes invalid, off and full range.
864                          if (Float.isNaN(brightnessState) || Float.isNaN(sdrBrightnessState)) {
865                              return;
866                          }
867  
868                          if (DEBUG) {
869                              Slog.d(TAG, "setDisplayBrightness("
870                                      + "id=" + physicalDisplayId
871                                      + ", brightnessState=" + brightnessState
872                                      + ", sdrBrightnessState=" + sdrBrightnessState + ")");
873                          }
874  
875                          Trace.traceBegin(Trace.TRACE_TAG_POWER, "setDisplayBrightness("
876                                  + "id=" + physicalDisplayId + ", brightnessState="
877                                  + brightnessState + ", sdrBrightnessState=" + sdrBrightnessState
878                                  + ")");
879                          try {
880                              final float backlight = brightnessToBacklight(brightnessState);
881                              final float sdrBacklight = brightnessToBacklight(sdrBrightnessState);
882  
883                              final float nits = backlightToNits(backlight);
884                              final float sdrNits = backlightToNits(sdrBacklight);
885  
886                              mBacklightAdapter.setBacklight(sdrBacklight, sdrNits, backlight, nits);
887                              Trace.traceCounter(Trace.TRACE_TAG_POWER,
888                                      "ScreenBrightness",
889                                      BrightnessSynchronizer.brightnessFloatToInt(brightnessState));
890                              Trace.traceCounter(Trace.TRACE_TAG_POWER,
891                                      "SdrScreenBrightness",
892                                      BrightnessSynchronizer.brightnessFloatToInt(
893                                              sdrBrightnessState));
894  
895                              if (getDisplayDeviceConfig().hasSdrToHdrRatioSpline()) {
896                                  handleHdrSdrNitsChanged(nits, sdrNits);
897                              }
898  
899                          } finally {
900                              Trace.traceEnd(Trace.TRACE_TAG_POWER);
901                          }
902                      }