页面比较

  static sp<GraphicBuffer> from(ANativeWindowBuffer *);

typedef struct native_handle {
  int version;
  int numFds;
  int numInts;
} native_handle_t;

    mCompositionEngine->getHwComposer().setCallback(this);
    
    
    //包含如下接口函数，显示插拔，垂直同步信号，合成刷新等
    class ComposerCallbackBridge : public hal::IComposerCallback {
public:
    ComposerCallbackBridge(ComposerCallback* callback, bool vsyncSwitchingSupported)
          : mCallback(callback), mVsyncSwitchingSupported(vsyncSwitchingSupported) {}
​
    Return<void> onHotplug(hal::HWDisplayId display, hal::Connection connection) override {
        mCallback->onComposerHalHotplug(display, connection);
        return Void();
    }
​
    Return<void> onRefresh(hal::HWDisplayId display) override {
        mCallback->onComposerHalRefresh(display);
        return Void();
    }
​
    Return<void> onVsync(hal::HWDisplayId display, int64_t timestamp) override {
        if (!mVsyncSwitchingSupported) {
            mCallback->onComposerHalVsync(display, timestamp, std::nullopt);
        } else {
            ALOGW("Unexpected onVsync callback on composer >= 2.4, ignoring.");
        }
        return Void();
    }
​
    Return<void> onVsync_2_4(hal::HWDisplayId display, int64_t timestamp,
                             hal::VsyncPeriodNanos vsyncPeriodNanos) override {
        if (mVsyncSwitchingSupported) {
            mCallback->onComposerHalVsync(display, timestamp, vsyncPeriodNanos);
        } else {
            ALOGW("Unexpected onVsync_2_4 callback on composer <= 2.3, ignoring.");
        }
        return Void();
    }
​
    Return<void> onVsyncPeriodTimingChanged(
            hal::HWDisplayId display, const hal::VsyncPeriodChangeTimeline& timeline) override {
        mCallback->onComposerHalVsyncPeriodTimingChanged(display, timeline);
        return Void();
    }
​
    Return<void> onSeamlessPossible(hal::HWDisplayId display) override {
        mCallback->onComposerHalSeamlessPossible(display);
        return Void();
    }
​
private:
    ComposerCallback* const mCallback;
    const bool mVsyncSwitchingSupported;
};   
    

void SurfaceFlinger::onComposerHalRefresh(hal::HWDisplayId) {
    Mutex::Autolock lock(mStateLock);
    repaintEverythingForHWC();
}

Display 0 HWC layers:
---------------------------------------------------------------------------------------------------------------------------------------------------------------
 Layer name
           Z |  Window Type |  Comp Type |  Transform |   Disp Frame (LTRB) |          Source Crop (LTRB) |     Frame Rate (Explicit) (Seamlessness) [Focused]
---------------------------------------------------------------------------------------------------------------------------------------------------------------
 Wallpaper BBQ wrapper#0
  rel      0 |         2013 |     DEVICE |          0 |    0    0 1080 2400 |    0.0    0.0 1080.0 2400.0 |
                                 [ ]
---------------------------------------------------------------------------------------------------------------------------------------------------------------
 com.miui.home/com.miui.home.launcher.Launcher#0
  rel      0 |            1 |     DEVICE |          0 |    0    0 1080 2400 |    0.0    0.0 1080.0 2400.0 |
                                 [*]
---------------------------------------------------------------------------------------------------------------------------------------------------------------
 StatusBar#0
  rel      0 |         2000 |     DEVICE |          0 |    0    0 1080   96 |    0.0    0.0 1080.0   96.0 |
                                 [ ]
---------------------------------------------------------------------------------------------------------------------------------------------------------------
 NavigationBar0#0
  rel      0 |         2019 |     DEVICE |          0 |    0 2356 1080 2400 |    0.0    0.0 1080.0   44.0 |
                                 [ ]
---------------------------------------------------------------------------------------------------------------------------------------------------------------

status_t SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture,
                                             TraverseLayersFunction traverseLayers,
                                             ui::Size bufferSize, ui::PixelFormat reqPixelFormat,
                                             bool allowProtected, bool grayscale,
                                             const sp<IScreenCaptureListener>& captureListener)

//全屏渲染后，保存到文件
getRenderEngine().drawLayers(clientCompositionDisplay, clientCompositionLayerPointers, buffer,
                                 kUseFramebufferCache, std::move(bufferFence), &drawFence);
                                 
captureListener->onScreenCaptureCompleted(captureResults);

typedef enum {
    HWC2_COMPOSITION_INVALID = 0,
​
    /* The client will composite this layer into the client target buffer
     * (provided to the device through setClientTarget).
     *
     * The device must not request any composition type changes for layers of
     * this type. */
    HWC2_COMPOSITION_CLIENT = 1,
​
    /* The device will handle the composition of this layer through a hardware
     * overlay or other similar means.
     *
     * Upon validateDisplay, the device may request a change from this type to
     * HWC2_COMPOSITION_CLIENT. */
    HWC2_COMPOSITION_DEVICE = 2,

​void OutputLayer::writeStateToHWC(bool includeGeometry, bool skipLayer, uint32_t z,
                                  bool zIsOverridden, bool isPeekingThrough) {
    const auto& state = getState();
    // Skip doing this if there is no HWC interface
    if (!state.hwc) {
        return;
    }
​
    auto& hwcLayer = (*state.hwc).hwcLayer;
    if (!hwcLayer) {
        ALOGE("[%s] failed to write composition state to HWC -- no hwcLayer for output %s",
              getLayerFE().getDebugName(), getOutput().getName().c_str());
        return;
    }
​
    const auto* outputIndependentState = getLayerFE().getCompositionState();
    if (!outputIndependentState) {
        return;
    }
​
    auto requestedCompositionType = outputIndependentState->compositionType;
​
    // TODO(b/181172795): We now update geometry for all flattened layers. We should update it
    // only when the geometry actually changes
    const bool isOverridden =
            state.overrideInfo.buffer != nullptr || isPeekingThrough || zIsOverridden;
    const bool prevOverridden = state.hwc->stateOverridden;
    if (isOverridden || prevOverridden || skipLayer || includeGeometry) {
        writeOutputDependentGeometryStateToHWC(hwcLayer.get(), requestedCompositionType, z);
        writeOutputIndependentGeometryStateToHWC(hwcLayer.get(), *outputIndependentState,
                                                 skipLayer);
    }
​
    writeOutputDependentPerFrameStateToHWC(hwcLayer.get());
    writeOutputIndependentPerFrameStateToHWC(hwcLayer.get(), *outputIndependentState, skipLayer);
​
    writeCompositionTypeToHWC(hwcLayer.get(), requestedCompositionType, isPeekingThrough,
                              skipLayer);
​
    // Always set the layer color after setting the composition type.
    writeSolidColorStateToHWC(hwcLayer.get(), *outputIndependentState);
​
    editState().hwc->stateOverridden = isOverridden;
    editState().hwc->layerSkipped = skipLayer;
}

  if (mStartPropertySetThread->Start() != NO_ERROR) {
     ALOGE("Run StartPropertySetThread failed!");
  }

status_t StartPropertySetThread::Start() {
  return run("SurfaceFlinger::StartPropertySetThread", PRIORITY_NORMAL);
}
​
bool StartPropertySetThread::threadLoop() {
  // Set property service.sf.present_timestamp, consumer need check its readiness
  property_set(kTimestampProperty, mTimestampPropertyValue ? "1" : "0");
  // Clear BootAnimation exit flag
  property_set("service.bootanim.exit", "0");
  // Start BootAnimation if not started
  property_set("ctl.start", "bootanim");
  // Exit immediately
  return false;
}

int main()
{
  setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_DISPLAY);
  bool noBootAnimation = bootAnimationDisabled();
  ALOGI_IF(noBootAnimation,  "boot animation disabled");
  if (!noBootAnimation) {
    sp<ProcessState> proc(ProcessState::self());
    ProcessState::self()->startThreadPool();
    // create the boot animation object (may take up to 200ms for 2MB zip)
    sp<BootAnimation> boot = new BootAnimation(audioplay::createAnimationCallbacks());
    waitForSurfaceFlinger();
    boot->run("BootAnimation", PRIORITY_DISPLAY);
    ALOGV("Boot animation set up. Joining pool.");
   IPCThreadState::self()->joinThreadPool();
  }
  return 0;
}

bool BootAnimation::threadLoop() {
  bool result;
  // We have no bootanimation file, so we use the stock android logo
  // animation.
  if (mZipFileName.isEmpty()) {
    result = android();
  } else {
    result = movie();
  }
  eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
  eglDestroyContext(mDisplay, mContext);
  eglDestroySurface(mDisplay, mSurface);
  mFlingerSurface.clear();
  mFlingerSurfaceControl.clear();
  eglTerminate(mDisplay);
  eglReleaseThread();
  IPCThreadState::self()->stopProcess();
  return result;
}

void BootAnimation::findBootAnimationFile() {
    // If the device has encryption turned on or is in process
    // of being encrypted we show the encrypted boot animation.
    char decrypt[PROPERTY_VALUE_MAX];
    property_get("vold.decrypt", decrypt, "");
​
    bool encryptedAnimation = atoi(decrypt) != 0 ||
        !strcmp("trigger_restart_min_framework", decrypt);
​
    if (!mShuttingDown && encryptedAnimation) {
        static const std::vector<std::string> encryptedBootFiles = {
            PRODUCT_ENCRYPTED_BOOTANIMATION_FILE, SYSTEM_ENCRYPTED_BOOTANIMATION_FILE,
        };
        if (findBootAnimationFileInternal(encryptedBootFiles)) {
            return;
        }
    }
​
    const bool playDarkAnim = android::base::GetIntProperty("ro.boot.theme", 0) == 1;
    static const std::vector<std::string> bootFiles = {
        APEX_BOOTANIMATION_FILE, playDarkAnim ? PRODUCT_BOOTANIMATION_DARK_FILE : PRODUCT_BOOTANIMATION_FILE,
        OEM_BOOTANIMATION_FILE, SYSTEM_BOOTANIMATION_FILE
    };
    static const std::vector<std::string> shutdownFiles = {
        PRODUCT_SHUTDOWNANIMATION_FILE, OEM_SHUTDOWNANIMATION_FILE, SYSTEM_SHUTDOWNANIMATION_FILE, ""
    };
    static const std::vector<std::string> userspaceRebootFiles = {
        PRODUCT_USERSPACE_REBOOT_ANIMATION_FILE, OEM_USERSPACE_REBOOT_ANIMATION_FILE,
        SYSTEM_USERSPACE_REBOOT_ANIMATION_FILE,
    };
​
    if (android::base::GetBoolProperty("sys.init.userspace_reboot.in_progress", false)) {
        findBootAnimationFileInternal(userspaceRebootFiles);
    } else if (mShuttingDown) {
        findBootAnimationFileInternal(shutdownFiles);
    } else {
        findBootAnimationFileInternal(bootFiles);
    }
}

static const char EXIT_PROP_NAME[] = "service.bootanim.exit";
​
​
void BootAnimation::checkExit() {
    // Allow surface flinger to gracefully request shutdown
    char value[PROPERTY_VALUE_MAX];
    property_get(EXIT_PROP_NAME, value, "0");
    int exitnow = atoi(value);
    if (exitnow) {
        requestExit();
        mCallbacks->shutdown();
    }
}

    property_set("service.bootanim.exit", "1");