/* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ // TODO(b/129481165): remove the #pragma below and fix conversion issues #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wconversion" //#define LOG_NDEBUG 0 #undef LOG_TAG #define LOG_TAG "Layer" #define ATRACE_TAG ATRACE_TAG_GRAPHICS #include "Layer.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "BufferLayer.h" #include "Colorizer.h" #include "DisplayDevice.h" #include "DisplayHardware/HWComposer.h" #include "EffectLayer.h" #include "FrameTracer/FrameTracer.h" #include "LayerProtoHelper.h" #include "LayerRejecter.h" #include "MonitoredProducer.h" #include "SurfaceFlinger.h" #include "TimeStats/TimeStats.h" #define DEBUG_RESIZE 0 namespace android { using base::StringAppendF; std::atomic Layer::sSequence{1}; Layer::Layer(const LayerCreationArgs& args) : mFlinger(args.flinger), mName(args.name), mClientRef(args.client), mWindowType(args.metadata.getInt32(METADATA_WINDOW_TYPE, 0)) { uint32_t layerFlags = 0; if (args.flags & ISurfaceComposerClient::eHidden) layerFlags |= layer_state_t::eLayerHidden; if (args.flags & ISurfaceComposerClient::eOpaque) layerFlags |= layer_state_t::eLayerOpaque; if (args.flags & ISurfaceComposerClient::eSecure) layerFlags |= layer_state_t::eLayerSecure; mCurrentState.active_legacy.w = args.w; mCurrentState.active_legacy.h = args.h; mCurrentState.flags = layerFlags; mCurrentState.active_legacy.transform.set(0, 0); mCurrentState.crop_legacy.makeInvalid(); mCurrentState.requestedCrop_legacy = mCurrentState.crop_legacy; mCurrentState.z = 0; mCurrentState.color.a = 1.0f; mCurrentState.layerStack = 0; mCurrentState.sequence = 0; mCurrentState.requested_legacy = mCurrentState.active_legacy; mCurrentState.active.w = UINT32_MAX; mCurrentState.active.h = UINT32_MAX; mCurrentState.active.transform.set(0, 0); mCurrentState.frameNumber = 0; mCurrentState.transform = 0; mCurrentState.transformToDisplayInverse = false; mCurrentState.crop.makeInvalid(); mCurrentState.acquireFence = new Fence(-1); mCurrentState.dataspace = ui::Dataspace::UNKNOWN; mCurrentState.hdrMetadata.validTypes = 0; mCurrentState.surfaceDamageRegion = Region::INVALID_REGION; mCurrentState.cornerRadius = 0.0f; mCurrentState.backgroundBlurRadius = 0; mCurrentState.api = -1; mCurrentState.hasColorTransform = false; mCurrentState.colorSpaceAgnostic = false; mCurrentState.frameRateSelectionPriority = PRIORITY_UNSET; mCurrentState.metadata = args.metadata; mCurrentState.shadowRadius = 0.f; mCurrentState.treeHasFrameRateVote = false; mCurrentState.fixedTransformHint = ui::Transform::ROT_INVALID; mCurrentState.isTrustedOverlay = false; mCurrentState.dropInputMode = gui::DropInputMode::NONE; if (args.flags & ISurfaceComposerClient::eNoColorFill) { // Set an invalid color so there is no color fill. mCurrentState.color.r = -1.0_hf; mCurrentState.color.g = -1.0_hf; mCurrentState.color.b = -1.0_hf; } // drawing state & current state are identical mDrawingState = mCurrentState; CompositorTiming compositorTiming; args.flinger->getCompositorTiming(&compositorTiming); mFrameEventHistory.initializeCompositorTiming(compositorTiming); mFrameTracker.setDisplayRefreshPeriod(compositorTiming.interval); mCallingPid = args.callingPid; mCallingUid = args.callingUid; } void Layer::onFirstRef() { mFlinger->onLayerFirstRef(this); } Layer::~Layer() { sp c(mClientRef.promote()); if (c != 0) { c->detachLayer(this); } mFrameTracker.logAndResetStats(mName); mFlinger->onLayerDestroyed(this); } LayerCreationArgs::LayerCreationArgs(SurfaceFlinger* flinger, sp client, std::string name, uint32_t w, uint32_t h, uint32_t flags, LayerMetadata metadata) : flinger(flinger), client(std::move(client)), name(std::move(name)), w(w), h(h), flags(flags), metadata(std::move(metadata)) { IPCThreadState* ipc = IPCThreadState::self(); callingPid = ipc->getCallingPid(); callingUid = ipc->getCallingUid(); } // --------------------------------------------------------------------------- // callbacks // --------------------------------------------------------------------------- /* * onLayerDisplayed is only meaningful for BufferLayer, but, is called through * Layer. So, the implementation is done in BufferLayer. When called on a * EffectLayer object, it's essentially a NOP. */ void Layer::onLayerDisplayed(const sp& /*releaseFence*/) {} void Layer::removeRemoteSyncPoints() { for (auto& point : mRemoteSyncPoints) { point->setTransactionApplied(); } mRemoteSyncPoints.clear(); { for (State pendingState : mPendingStates) { pendingState.barrierLayer_legacy = nullptr; } } } void Layer::removeRelativeZ(const std::vector& layersInTree) { if (mCurrentState.zOrderRelativeOf == nullptr) { return; } sp strongRelative = mCurrentState.zOrderRelativeOf.promote(); if (strongRelative == nullptr) { setZOrderRelativeOf(nullptr); return; } if (!std::binary_search(layersInTree.begin(), layersInTree.end(), strongRelative.get())) { strongRelative->removeZOrderRelative(this); mFlinger->setTransactionFlags(eTraversalNeeded); setZOrderRelativeOf(nullptr); } } void Layer::removeFromCurrentState() { mRemovedFromCurrentState = true; // Since we are no longer reachable from CurrentState SurfaceFlinger // will no longer invoke doTransaction for us, and so we will // never finish applying transactions. We signal the sync point // now so that another layer will not become indefinitely // blocked. removeRemoteSyncPoints(); { Mutex::Autolock syncLock(mLocalSyncPointMutex); for (auto& point : mLocalSyncPoints) { point->setFrameAvailable(); } mLocalSyncPoints.clear(); } mFlinger->markLayerPendingRemovalLocked(this); } sp Layer::getRootLayer() { sp parent = getParent(); if (parent == nullptr) { return this; } return parent->getRootLayer(); } void Layer::onRemovedFromCurrentState() { // Use the root layer since we want to maintain the hierarchy for the entire subtree. auto layersInTree = getRootLayer()->getLayersInTree(LayerVector::StateSet::Current); std::sort(layersInTree.begin(), layersInTree.end()); traverse(LayerVector::StateSet::Current, [&](Layer* layer) { layer->removeFromCurrentState(); layer->removeRelativeZ(layersInTree); }); } void Layer::addToCurrentState() { mRemovedFromCurrentState = false; for (const auto& child : mCurrentChildren) { child->addToCurrentState(); } } // --------------------------------------------------------------------------- // set-up // --------------------------------------------------------------------------- bool Layer::getPremultipledAlpha() const { return mPremultipliedAlpha; } sp Layer::getHandle() { Mutex::Autolock _l(mLock); if (mGetHandleCalled) { ALOGE("Get handle called twice" ); return nullptr; } mGetHandleCalled = true; return new Handle(mFlinger, this); } // --------------------------------------------------------------------------- // h/w composer set-up // --------------------------------------------------------------------------- static Rect reduce(const Rect& win, const Region& exclude) { if (CC_LIKELY(exclude.isEmpty())) { return win; } if (exclude.isRect()) { return win.reduce(exclude.getBounds()); } return Region(win).subtract(exclude).getBounds(); } static FloatRect reduce(const FloatRect& win, const Region& exclude) { if (CC_LIKELY(exclude.isEmpty())) { return win; } // Convert through Rect (by rounding) for lack of FloatRegion return Region(Rect{win}).subtract(exclude).getBounds().toFloatRect(); } Rect Layer::getScreenBounds(bool reduceTransparentRegion) const { if (!reduceTransparentRegion) { return Rect{mScreenBounds}; } FloatRect bounds = getBounds(); ui::Transform t = getTransform(); // Transform to screen space. bounds = t.transform(bounds); return Rect{bounds}; } FloatRect Layer::getBounds() const { const State& s(getDrawingState()); return getBounds(getActiveTransparentRegion(s)); } FloatRect Layer::getBounds(const Region& activeTransparentRegion) const { // Subtract the transparent region and snap to the bounds. return reduce(mBounds, activeTransparentRegion); } ui::Transform Layer::getBufferScaleTransform() const { // If the layer is not using NATIVE_WINDOW_SCALING_MODE_FREEZE (e.g. // it isFixedSize) then there may be additional scaling not accounted // for in the layer transform. if (!isFixedSize() || getBuffer() == nullptr) { return {}; } // If the layer is a buffer state layer, the active width and height // could be infinite. In that case, return the effective transform. const uint32_t activeWidth = getActiveWidth(getDrawingState()); const uint32_t activeHeight = getActiveHeight(getDrawingState()); if (activeWidth >= UINT32_MAX && activeHeight >= UINT32_MAX) { return {}; } int bufferWidth = getBuffer()->getWidth(); int bufferHeight = getBuffer()->getHeight(); if (getBufferTransform() & NATIVE_WINDOW_TRANSFORM_ROT_90) { std::swap(bufferWidth, bufferHeight); } float sx = activeWidth / static_cast(bufferWidth); float sy = activeHeight / static_cast(bufferHeight); ui::Transform extraParentScaling; extraParentScaling.set(sx, 0, 0, sy); return extraParentScaling; } ui::Transform Layer::getTransformWithScale(const ui::Transform& bufferScaleTransform) const { // We need to mirror this scaling to child surfaces or we will break the contract where WM can // treat child surfaces as pixels in the parent surface. if (!isFixedSize() || getBuffer() == nullptr) { return mEffectiveTransform; } return mEffectiveTransform * bufferScaleTransform; } FloatRect Layer::getBoundsPreScaling(const ui::Transform& bufferScaleTransform) const { // We need the pre scaled layer bounds when computing child bounds to make sure the child is // cropped to its parent layer after any buffer transform scaling is applied. if (!isFixedSize() || getBuffer() == nullptr) { return mBounds; } return bufferScaleTransform.inverse().transform(mBounds); } void Layer::computeBounds(FloatRect parentBounds, ui::Transform parentTransform, float parentShadowRadius) { const State& s(getDrawingState()); // Calculate effective layer transform mEffectiveTransform = parentTransform * getActiveTransform(s); // Transform parent bounds to layer space parentBounds = getActiveTransform(s).inverse().transform(parentBounds); // Calculate source bounds mSourceBounds = computeSourceBounds(parentBounds); // Calculate bounds by croping diplay frame with layer crop and parent bounds FloatRect bounds = mSourceBounds; const Rect layerCrop = getCrop(s); if (!layerCrop.isEmpty()) { bounds = mSourceBounds.intersect(layerCrop.toFloatRect()); } bounds = bounds.intersect(parentBounds); mBounds = bounds; mScreenBounds = mEffectiveTransform.transform(mBounds); // Use the layer's own shadow radius if set. Otherwise get the radius from // parent. if (s.shadowRadius > 0.f) { mEffectiveShadowRadius = s.shadowRadius; } else { mEffectiveShadowRadius = parentShadowRadius; } // Shadow radius is passed down to only one layer so if the layer can draw shadows, // don't pass it to its children. const float childShadowRadius = canDrawShadows() ? 0.f : mEffectiveShadowRadius; // Add any buffer scaling to the layer's children. ui::Transform bufferScaleTransform = getBufferScaleTransform(); for (const sp& child : mDrawingChildren) { child->computeBounds(getBoundsPreScaling(bufferScaleTransform), getTransformWithScale(bufferScaleTransform), childShadowRadius); } } Rect Layer::getCroppedBufferSize(const State& s) const { Rect size = getBufferSize(s); Rect crop = getCrop(s); if (!crop.isEmpty() && size.isValid()) { size.intersect(crop, &size); } else if (!crop.isEmpty()) { size = crop; } return size; } void Layer::setupRoundedCornersCropCoordinates(Rect win, const FloatRect& roundedCornersCrop) const { // Translate win by the rounded corners rect coordinates, to have all values in // layer coordinate space. win.left -= roundedCornersCrop.left; win.right -= roundedCornersCrop.left; win.top -= roundedCornersCrop.top; win.bottom -= roundedCornersCrop.top; } void Layer::prepareBasicGeometryCompositionState() { const auto& drawingState{getDrawingState()}; const uint32_t layerStack = getLayerStack(); const auto alpha = static_cast(getAlpha()); const bool opaque = isOpaque(drawingState); const bool usesRoundedCorners = getRoundedCornerState().radius != 0.f; auto blendMode = Hwc2::IComposerClient::BlendMode::NONE; if (!opaque || alpha != 1.0f) { blendMode = mPremultipliedAlpha ? Hwc2::IComposerClient::BlendMode::PREMULTIPLIED : Hwc2::IComposerClient::BlendMode::COVERAGE; } auto* compositionState = editCompositionState(); compositionState->layerStackId = (layerStack != ~0u) ? std::make_optional(layerStack) : std::nullopt; compositionState->internalOnly = getPrimaryDisplayOnly(); compositionState->isVisible = isVisible(); compositionState->isOpaque = opaque && !usesRoundedCorners && alpha == 1.f; compositionState->shadowRadius = mEffectiveShadowRadius; compositionState->contentDirty = contentDirty; contentDirty = false; compositionState->geomLayerBounds = mBounds; compositionState->geomLayerTransform = getTransform(); compositionState->geomInverseLayerTransform = compositionState->geomLayerTransform.inverse(); compositionState->transparentRegionHint = getActiveTransparentRegion(drawingState); compositionState->blendMode = static_cast(blendMode); compositionState->alpha = alpha; compositionState->backgroundBlurRadius = drawingState.backgroundBlurRadius; } void Layer::prepareGeometryCompositionState() { const auto& drawingState{getDrawingState()}; int type = drawingState.metadata.getInt32(METADATA_WINDOW_TYPE, 0); int appId = drawingState.metadata.getInt32(METADATA_OWNER_UID, 0); sp parent = mDrawingParent.promote(); if (parent.get()) { auto& parentState = parent->getDrawingState(); const int parentType = parentState.metadata.getInt32(METADATA_WINDOW_TYPE, 0); const int parentAppId = parentState.metadata.getInt32(METADATA_OWNER_UID, 0); if (parentType > 0 && parentAppId > 0) { type = parentType; appId = parentAppId; } } auto* compositionState = editCompositionState(); compositionState->geomBufferSize = getBufferSize(drawingState); compositionState->geomContentCrop = getBufferCrop(); compositionState->geomCrop = getCrop(drawingState); compositionState->geomBufferTransform = getBufferTransform(); compositionState->geomBufferUsesDisplayInverseTransform = getTransformToDisplayInverse(); compositionState->geomUsesSourceCrop = usesSourceCrop(); compositionState->isSecure = isSecure(); compositionState->type = type; compositionState->appId = appId; compositionState->metadata.clear(); const auto& supportedMetadata = mFlinger->getHwComposer().getSupportedLayerGenericMetadata(); for (const auto& [key, mandatory] : supportedMetadata) { const auto& genericLayerMetadataCompatibilityMap = mFlinger->getGenericLayerMetadataKeyMap(); auto compatIter = genericLayerMetadataCompatibilityMap.find(key); if (compatIter == std::end(genericLayerMetadataCompatibilityMap)) { continue; } const uint32_t id = compatIter->second; auto it = drawingState.metadata.mMap.find(id); if (it == std::end(drawingState.metadata.mMap)) { continue; } compositionState->metadata .emplace(key, compositionengine::GenericLayerMetadataEntry{mandatory, it->second}); } } void Layer::preparePerFrameCompositionState() { const auto& drawingState{getDrawingState()}; auto* compositionState = editCompositionState(); compositionState->forceClientComposition = false; compositionState->isColorspaceAgnostic = isColorSpaceAgnostic(); compositionState->dataspace = getDataSpace(); compositionState->colorTransform = getColorTransform(); compositionState->colorTransformIsIdentity = !hasColorTransform(); compositionState->surfaceDamage = surfaceDamageRegion; compositionState->hasProtectedContent = isProtected(); const bool usesRoundedCorners = getRoundedCornerState().radius != 0.f; compositionState->isOpaque = isOpaque(drawingState) && !usesRoundedCorners && getAlpha() == 1.0_hf; // Force client composition for special cases known only to the front-end. if (isHdrY410() || usesRoundedCorners || drawShadows()) { compositionState->forceClientComposition = true; } } void Layer::prepareCursorCompositionState() { const State& drawingState{getDrawingState()}; auto* compositionState = editCompositionState(); // Apply the layer's transform, followed by the display's global transform // Here we're guaranteed that the layer's transform preserves rects Rect win = getCroppedBufferSize(drawingState); // Subtract the transparent region and snap to the bounds Rect bounds = reduce(win, getActiveTransparentRegion(drawingState)); Rect frame(getTransform().transform(bounds)); compositionState->cursorFrame = frame; } sp Layer::asLayerFE() const { return const_cast( static_cast(this)); } sp Layer::getCompositionEngineLayerFE() const { return nullptr; } compositionengine::LayerFECompositionState* Layer::editCompositionState() { return nullptr; } const compositionengine::LayerFECompositionState* Layer::getCompositionState() const { return nullptr; } bool Layer::onPreComposition(nsecs_t) { return false; } void Layer::prepareCompositionState(compositionengine::LayerFE::StateSubset subset) { using StateSubset = compositionengine::LayerFE::StateSubset; switch (subset) { case StateSubset::BasicGeometry: prepareBasicGeometryCompositionState(); break; case StateSubset::GeometryAndContent: prepareBasicGeometryCompositionState(); prepareGeometryCompositionState(); preparePerFrameCompositionState(); break; case StateSubset::Content: preparePerFrameCompositionState(); break; case StateSubset::Cursor: prepareCursorCompositionState(); break; } } const char* Layer::getDebugName() const { return mName.c_str(); } // --------------------------------------------------------------------------- // drawing... // --------------------------------------------------------------------------- std::optional Layer::prepareClientComposition( compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) { if (!getCompositionState()) { return {}; } FloatRect bounds = getBounds(); half alpha = getAlpha(); compositionengine::LayerFE::LayerSettings layerSettings; layerSettings.geometry.boundaries = bounds; if (targetSettings.useIdentityTransform) { layerSettings.geometry.positionTransform = mat4(); } else { layerSettings.geometry.positionTransform = getTransform().asMatrix4(); } if (hasColorTransform()) { layerSettings.colorTransform = getColorTransform(); } const auto roundedCornerState = getRoundedCornerState(); layerSettings.geometry.roundedCornersRadius = roundedCornerState.radius; layerSettings.geometry.roundedCornersCrop = roundedCornerState.cropRect; layerSettings.alpha = alpha; layerSettings.sourceDataspace = getDataSpace(); layerSettings.backgroundBlurRadius = getBackgroundBlurRadius(); return layerSettings; } std::optional Layer::prepareShadowClientComposition( const LayerFE::LayerSettings& casterLayerSettings, const Rect& displayViewport, ui::Dataspace outputDataspace) { renderengine::ShadowSettings shadow = getShadowSettings(displayViewport); if (shadow.length <= 0.f) { return {}; } const float casterAlpha = casterLayerSettings.alpha; const bool casterIsOpaque = ((casterLayerSettings.source.buffer.buffer != nullptr) && casterLayerSettings.source.buffer.isOpaque); compositionengine::LayerFE::LayerSettings shadowLayer = casterLayerSettings; shadowLayer.shadow = shadow; shadowLayer.geometry.boundaries = mBounds; // ignore transparent region // If the casting layer is translucent, we need to fill in the shadow underneath the layer. // Otherwise the generated shadow will only be shown around the casting layer. shadowLayer.shadow.casterIsTranslucent = !casterIsOpaque || (casterAlpha < 1.0f); shadowLayer.shadow.ambientColor *= casterAlpha; shadowLayer.shadow.spotColor *= casterAlpha; shadowLayer.sourceDataspace = outputDataspace; shadowLayer.source.buffer.buffer = nullptr; shadowLayer.source.buffer.fence = nullptr; shadowLayer.frameNumber = 0; shadowLayer.bufferId = 0; if (shadowLayer.shadow.ambientColor.a <= 0.f && shadowLayer.shadow.spotColor.a <= 0.f) { return {}; } float casterCornerRadius = shadowLayer.geometry.roundedCornersRadius; const FloatRect& cornerRadiusCropRect = shadowLayer.geometry.roundedCornersCrop; const FloatRect& casterRect = shadowLayer.geometry.boundaries; // crop used to set the corner radius may be larger than the content rect. Adjust the corner // radius accordingly. if (casterCornerRadius > 0.f) { float cropRectOffset = std::max(std::abs(cornerRadiusCropRect.top - casterRect.top), std::abs(cornerRadiusCropRect.left - casterRect.left)); if (cropRectOffset > casterCornerRadius) { casterCornerRadius = 0; } else { casterCornerRadius -= cropRectOffset; } shadowLayer.geometry.roundedCornersRadius = casterCornerRadius; } return shadowLayer; } void Layer::prepareClearClientComposition(LayerFE::LayerSettings& layerSettings, bool blackout) const { layerSettings.source.buffer.buffer = nullptr; layerSettings.source.solidColor = half3(0.0, 0.0, 0.0); layerSettings.disableBlending = true; layerSettings.bufferId = 0; layerSettings.frameNumber = 0; // If layer is blacked out, force alpha to 1 so that we draw a black color layer. layerSettings.alpha = blackout ? 1.0f : 0.0f; } std::vector Layer::prepareClientCompositionList( compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) { std::optional layerSettings = prepareClientComposition(targetSettings); // Nothing to render. if (!layerSettings) { return {}; } // HWC requests to clear this layer. if (targetSettings.clearContent) { prepareClearClientComposition(*layerSettings, false /* blackout */); return {*layerSettings}; } std::optional shadowSettings = prepareShadowClientComposition(*layerSettings, targetSettings.viewport, targetSettings.dataspace); // There are no shadows to render. if (!shadowSettings) { return {*layerSettings}; } // If the layer casts a shadow but the content casting the shadow is occluded, skip // composing the non-shadow content and only draw the shadows. if (targetSettings.realContentIsVisible) { return {*shadowSettings, *layerSettings}; } return {*shadowSettings}; } Hwc2::IComposerClient::Composition Layer::getCompositionType(const DisplayDevice& display) const { const auto outputLayer = findOutputLayerForDisplay(&display); if (outputLayer == nullptr) { return Hwc2::IComposerClient::Composition::INVALID; } if (outputLayer->getState().hwc) { return (*outputLayer->getState().hwc).hwcCompositionType; } else { return Hwc2::IComposerClient::Composition::CLIENT; } } bool Layer::addSyncPoint(const std::shared_ptr& point) { if (point->getFrameNumber() <= mCurrentFrameNumber) { // Don't bother with a SyncPoint, since we've already latched the // relevant frame return false; } if (isRemovedFromCurrentState()) { return false; } Mutex::Autolock lock(mLocalSyncPointMutex); mLocalSyncPoints.push_back(point); return true; } // ---------------------------------------------------------------------------- // local state // ---------------------------------------------------------------------------- bool Layer::isSecure() const { const State& s(mDrawingState); return (s.flags & layer_state_t::eLayerSecure); } // ---------------------------------------------------------------------------- // transaction // ---------------------------------------------------------------------------- void Layer::pushPendingState() { if (!mCurrentState.modified) { return; } ATRACE_CALL(); // If this transaction is waiting on the receipt of a frame, generate a sync // point and send it to the remote layer. // We don't allow installing sync points after we are removed from the current state // as we won't be able to signal our end. if (mCurrentState.barrierLayer_legacy != nullptr && !isRemovedFromCurrentState()) { sp barrierLayer = mCurrentState.barrierLayer_legacy.promote(); if (barrierLayer == nullptr) { ALOGE("[%s] Unable to promote barrier Layer.", getDebugName()); // If we can't promote the layer we are intended to wait on, // then it is expired or otherwise invalid. Allow this transaction // to be applied as per normal (no synchronization). mCurrentState.barrierLayer_legacy = nullptr; } else { auto syncPoint = std::make_shared(mCurrentState.frameNumber_legacy, this); if (barrierLayer->addSyncPoint(syncPoint)) { std::stringstream ss; ss << "Adding sync point " << mCurrentState.frameNumber_legacy; ATRACE_NAME(ss.str().c_str()); mRemoteSyncPoints.push_back(std::move(syncPoint)); } else { // We already missed the frame we're supposed to synchronize // on, so go ahead and apply the state update mCurrentState.barrierLayer_legacy = nullptr; } } // Wake us up to check if the frame has been received setTransactionFlags(eTransactionNeeded); mFlinger->setTransactionFlags(eTraversalNeeded); } mPendingStates.push_back(mCurrentState); ATRACE_INT(mTransactionName.c_str(), mPendingStates.size()); } void Layer::popPendingState(State* stateToCommit) { ATRACE_CALL(); *stateToCommit = mPendingStates[0]; mPendingStates.removeAt(0); ATRACE_INT(mTransactionName.c_str(), mPendingStates.size()); } bool Layer::applyPendingStates(State* stateToCommit) { bool stateUpdateAvailable = false; while (!mPendingStates.empty()) { if (mPendingStates[0].barrierLayer_legacy != nullptr) { if (mRemoteSyncPoints.empty()) { // If we don't have a sync point for this, apply it anyway. It // will be visually wrong, but it should keep us from getting // into too much trouble. ALOGE("[%s] No local sync point found", getDebugName()); popPendingState(stateToCommit); stateUpdateAvailable = true; continue; } if (mRemoteSyncPoints.front()->getFrameNumber() != mPendingStates[0].frameNumber_legacy) { ALOGE("[%s] Unexpected sync point frame number found", getDebugName()); // Signal our end of the sync point and then dispose of it mRemoteSyncPoints.front()->setTransactionApplied(); mRemoteSyncPoints.pop_front(); continue; } if (mRemoteSyncPoints.front()->frameIsAvailable()) { ATRACE_NAME("frameIsAvailable"); // Apply the state update popPendingState(stateToCommit); stateUpdateAvailable = true; // Signal our end of the sync point and then dispose of it mRemoteSyncPoints.front()->setTransactionApplied(); mRemoteSyncPoints.pop_front(); } else { ATRACE_NAME("!frameIsAvailable"); break; } } else { popPendingState(stateToCommit); stateUpdateAvailable = true; } } // If we still have pending updates, we need to ensure SurfaceFlinger // will keep calling doTransaction, and so we force a traversal. // However, our pending states won't clear until a frame is available, // and so there is no need to specifically trigger a wakeup. if (!mPendingStates.empty()) { setTransactionFlags(eTransactionNeeded); mFlinger->setTraversalNeeded(); } mCurrentState.modified = false; return stateUpdateAvailable; } uint32_t Layer::doTransactionResize(uint32_t flags, State* stateToCommit) { const State& s(getDrawingState()); const bool sizeChanged = (stateToCommit->requested_legacy.w != s.requested_legacy.w) || (stateToCommit->requested_legacy.h != s.requested_legacy.h); if (sizeChanged) { // the size changed, we need to ask our client to request a new buffer ALOGD_IF(DEBUG_RESIZE, "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" " requested={ wh={%4u,%4u} }}\n" " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" " requested={ wh={%4u,%4u} }}\n", this, getName().c_str(), getBufferTransform(), getEffectiveScalingMode(), stateToCommit->active_legacy.w, stateToCommit->active_legacy.h, stateToCommit->crop_legacy.left, stateToCommit->crop_legacy.top, stateToCommit->crop_legacy.right, stateToCommit->crop_legacy.bottom, stateToCommit->crop_legacy.getWidth(), stateToCommit->crop_legacy.getHeight(), stateToCommit->requested_legacy.w, stateToCommit->requested_legacy.h, s.active_legacy.w, s.active_legacy.h, s.crop_legacy.left, s.crop_legacy.top, s.crop_legacy.right, s.crop_legacy.bottom, s.crop_legacy.getWidth(), s.crop_legacy.getHeight(), s.requested_legacy.w, s.requested_legacy.h); } // Don't let Layer::doTransaction update the drawing state // if we have a pending resize, unless we are in fixed-size mode. // the drawing state will be updated only once we receive a buffer // with the correct size. // // In particular, we want to make sure the clip (which is part // of the geometry state) is latched together with the size but is // latched immediately when no resizing is involved. // // If a sideband stream is attached, however, we want to skip this // optimization so that transactions aren't missed when a buffer // never arrives // // In the case that we don't have a buffer we ignore other factors // and avoid entering the resizePending state. At a high level the // resizePending state is to avoid applying the state of the new buffer // to the old buffer. However in the state where we don't have an old buffer // there is no such concern but we may still be being used as a parent layer. const bool resizePending = ((stateToCommit->requested_legacy.w != stateToCommit->active_legacy.w) || (stateToCommit->requested_legacy.h != stateToCommit->active_legacy.h)) && (getBuffer() != nullptr); if (!isFixedSize()) { if (resizePending && mSidebandStream == nullptr) { flags |= eDontUpdateGeometryState; } } // Here we apply various requested geometry states, depending on our // latching configuration. See Layer.h for a detailed discussion of // how geometry latching is controlled. if (!(flags & eDontUpdateGeometryState)) { State& editCurrentState(getCurrentState()); // There is an awkward asymmetry in the handling of the crop states in the position // states, as can be seen below. Largely this arises from position and transform // being stored in the same data structure while having different latching rules. // b/38182305 // // Careful that "stateToCommit" and editCurrentState may not begin as equivalent due to // applyPendingStates in the presence of deferred transactions. editCurrentState.active_legacy = editCurrentState.requested_legacy; stateToCommit->active_legacy = stateToCommit->requested_legacy; } return flags; } uint32_t Layer::doTransaction(uint32_t flags) { ATRACE_CALL(); if (mLayerDetached) { // Ensure BLAST buffer callbacks are processed. // detachChildren and mLayerDetached were implemented to avoid geometry updates // to layers in the cases of animation. For BufferQueue layers buffers are still // consumed as normal. This is useful as otherwise the client could get hung // inevitably waiting on a buffer to return. We recreate this semantic for BufferQueue // even though it is a little consistent. detachChildren is shortly slated for removal // by the hierarchy mirroring work so we don't need to worry about it too much. forceSendCallbacks(); mCurrentState.callbackHandles = {}; return flags; } if (mChildrenChanged) { flags |= eVisibleRegion; mChildrenChanged = false; } pushPendingState(); State c = getCurrentState(); if (!applyPendingStates(&c)) { return flags; } flags = doTransactionResize(flags, &c); const State& s(getDrawingState()); if (getActiveGeometry(c) != getActiveGeometry(s)) { // invalidate and recompute the visible regions if needed flags |= Layer::eVisibleRegion; } if (c.sequence != s.sequence) { // invalidate and recompute the visible regions if needed flags |= eVisibleRegion; this->contentDirty = true; // we may use linear filtering, if the matrix scales us const uint8_t type = getActiveTransform(c).getType(); mNeedsFiltering = (!getActiveTransform(c).preserveRects() || type >= ui::Transform::SCALE); } if (mCurrentState.inputInfoChanged) { flags |= eInputInfoChanged; mCurrentState.inputInfoChanged = false; } // Commit the transaction commitTransaction(c); mPendingStatesSnapshot = mPendingStates; mCurrentState.callbackHandles = {}; return flags; } void Layer::commitTransaction(const State& stateToCommit) { mDrawingState = stateToCommit; } uint32_t Layer::getTransactionFlags(uint32_t flags) { return mTransactionFlags.fetch_and(~flags) & flags; } uint32_t Layer::setTransactionFlags(uint32_t flags) { return mTransactionFlags.fetch_or(flags); } bool Layer::setPosition(float x, float y) { if (mCurrentState.requested_legacy.transform.tx() == x && mCurrentState.requested_legacy.transform.ty() == y) return false; mCurrentState.sequence++; // We update the requested and active position simultaneously because // we want to apply the position portion of the transform matrix immediately, // but still delay scaling when resizing a SCALING_MODE_FREEZE layer. mCurrentState.requested_legacy.transform.set(x, y); // Here we directly update the active state // unlike other setters, because we store it within // the transform, but use different latching rules. // b/38182305 mCurrentState.active_legacy.transform.set(x, y); mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setChildLayer(const sp& childLayer, int32_t z) { ssize_t idx = mCurrentChildren.indexOf(childLayer); if (idx < 0) { return false; } if (childLayer->setLayer(z)) { mCurrentChildren.removeAt(idx); mCurrentChildren.add(childLayer); return true; } return false; } bool Layer::setChildRelativeLayer(const sp& childLayer, const sp& relativeToHandle, int32_t relativeZ) { ssize_t idx = mCurrentChildren.indexOf(childLayer); if (idx < 0) { return false; } if (childLayer->setRelativeLayer(relativeToHandle, relativeZ)) { mCurrentChildren.removeAt(idx); mCurrentChildren.add(childLayer); return true; } return false; } bool Layer::setLayer(int32_t z) { if (mCurrentState.z == z && !usingRelativeZ(LayerVector::StateSet::Current)) return false; mCurrentState.sequence++; mCurrentState.z = z; mCurrentState.modified = true; // Discard all relative layering. if (mCurrentState.zOrderRelativeOf != nullptr) { sp strongRelative = mCurrentState.zOrderRelativeOf.promote(); if (strongRelative != nullptr) { strongRelative->removeZOrderRelative(this); } setZOrderRelativeOf(nullptr); } setTransactionFlags(eTransactionNeeded); return true; } void Layer::removeZOrderRelative(const wp& relative) { mCurrentState.zOrderRelatives.remove(relative); mCurrentState.sequence++; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); } void Layer::addZOrderRelative(const wp& relative) { mCurrentState.zOrderRelatives.add(relative); mCurrentState.modified = true; mCurrentState.sequence++; setTransactionFlags(eTransactionNeeded); } void Layer::setZOrderRelativeOf(const wp& relativeOf) { mCurrentState.zOrderRelativeOf = relativeOf; mCurrentState.sequence++; mCurrentState.modified = true; mCurrentState.isRelativeOf = relativeOf != nullptr; setTransactionFlags(eTransactionNeeded); } bool Layer::setRelativeLayer(const sp& relativeToHandle, int32_t relativeZ) { sp handle = static_cast(relativeToHandle.get()); if (handle == nullptr) { return false; } sp relative = handle->owner.promote(); if (relative == nullptr) { return false; } if (mCurrentState.z == relativeZ && usingRelativeZ(LayerVector::StateSet::Current) && mCurrentState.zOrderRelativeOf == relative) { return false; } mCurrentState.sequence++; mCurrentState.modified = true; mCurrentState.z = relativeZ; auto oldZOrderRelativeOf = mCurrentState.zOrderRelativeOf.promote(); if (oldZOrderRelativeOf != nullptr) { oldZOrderRelativeOf->removeZOrderRelative(this); } setZOrderRelativeOf(relative); relative->addZOrderRelative(this); setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setTrustedOverlay(bool isTrustedOverlay) { if (mCurrentState.isTrustedOverlay == isTrustedOverlay) return false; mCurrentState.isTrustedOverlay = isTrustedOverlay; mCurrentState.modified = true; mCurrentState.inputInfoChanged = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::isTrustedOverlay() const { if (getDrawingState().isTrustedOverlay) { return true; } const auto& p = mDrawingParent.promote(); return (p != nullptr) && p->isTrustedOverlay(); } bool Layer::setSize(uint32_t w, uint32_t h) { if (mCurrentState.requested_legacy.w == w && mCurrentState.requested_legacy.h == h) return false; mCurrentState.requested_legacy.w = w; mCurrentState.requested_legacy.h = h; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); // record the new size, from this point on, when the client request // a buffer, it'll get the new size. setDefaultBufferSize(mCurrentState.requested_legacy.w, mCurrentState.requested_legacy.h); return true; } bool Layer::setAlpha(float alpha) { if (mCurrentState.color.a == alpha) return false; mCurrentState.sequence++; mCurrentState.color.a = alpha; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace) { if (!mCurrentState.bgColorLayer && alpha == 0) { return false; } mCurrentState.sequence++; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); if (!mCurrentState.bgColorLayer && alpha != 0) { // create background color layer if one does not yet exist uint32_t flags = ISurfaceComposerClient::eFXSurfaceEffect; std::string name = mName + "BackgroundColorLayer"; mCurrentState.bgColorLayer = mFlinger->getFactory().createEffectLayer( LayerCreationArgs(mFlinger.get(), nullptr, std::move(name), 0, 0, flags, LayerMetadata())); // add to child list addChild(mCurrentState.bgColorLayer); mFlinger->mLayersAdded = true; // set up SF to handle added color layer if (isRemovedFromCurrentState()) { mCurrentState.bgColorLayer->onRemovedFromCurrentState(); } mFlinger->setTransactionFlags(eTransactionNeeded); } else if (mCurrentState.bgColorLayer && alpha == 0) { mCurrentState.bgColorLayer->reparent(nullptr); mCurrentState.bgColorLayer = nullptr; return true; } mCurrentState.bgColorLayer->setColor(color); mCurrentState.bgColorLayer->setLayer(std::numeric_limits::min()); mCurrentState.bgColorLayer->setAlpha(alpha); mCurrentState.bgColorLayer->setDataspace(dataspace); return true; } bool Layer::setCornerRadius(float cornerRadius) { if (mCurrentState.cornerRadius == cornerRadius) return false; mCurrentState.sequence++; mCurrentState.cornerRadius = cornerRadius; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setBackgroundBlurRadius(int backgroundBlurRadius) { if (mCurrentState.backgroundBlurRadius == backgroundBlurRadius) return false; mCurrentState.sequence++; mCurrentState.backgroundBlurRadius = backgroundBlurRadius; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix, bool allowNonRectPreservingTransforms) { ui::Transform t; t.set(matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy); if (!allowNonRectPreservingTransforms && !t.preserveRects()) { ALOGW("Attempt to set rotation matrix without permission ACCESS_SURFACE_FLINGER ignored"); return false; } mCurrentState.sequence++; mCurrentState.requested_legacy.transform.set(matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy); mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setTransparentRegionHint(const Region& transparent) { mCurrentState.requestedTransparentRegion_legacy = transparent; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setFlags(uint8_t flags, uint8_t mask) { const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); if (mCurrentState.flags == newFlags) return false; mCurrentState.sequence++; mCurrentState.flags = newFlags; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setCrop_legacy(const Rect& crop) { if (mCurrentState.requestedCrop_legacy == crop) return false; mCurrentState.sequence++; mCurrentState.requestedCrop_legacy = crop; mCurrentState.crop_legacy = crop; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setOverrideScalingMode(int32_t scalingMode) { if (scalingMode == mOverrideScalingMode) return false; mOverrideScalingMode = scalingMode; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setMetadata(const LayerMetadata& data) { if (!mCurrentState.metadata.merge(data, true /* eraseEmpty */)) return false; mCurrentState.sequence++; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setLayerStack(uint32_t layerStack) { if (mCurrentState.layerStack == layerStack) return false; mCurrentState.sequence++; mCurrentState.layerStack = layerStack; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setColorSpaceAgnostic(const bool agnostic) { if (mCurrentState.colorSpaceAgnostic == agnostic) { return false; } mCurrentState.sequence++; mCurrentState.colorSpaceAgnostic = agnostic; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setFrameRateSelectionPriority(int32_t priority) { if (mCurrentState.frameRateSelectionPriority == priority) return false; mCurrentState.frameRateSelectionPriority = priority; mCurrentState.sequence++; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } int32_t Layer::getFrameRateSelectionPriority() const { // Check if layer has priority set. if (mDrawingState.frameRateSelectionPriority != PRIORITY_UNSET) { return mDrawingState.frameRateSelectionPriority; } // If not, search whether its parents have it set. sp parent = getParent(); if (parent != nullptr) { return parent->getFrameRateSelectionPriority(); } return Layer::PRIORITY_UNSET; } bool Layer::isLayerFocusedBasedOnPriority(int32_t priority) { return priority == PRIORITY_FOCUSED_WITH_MODE || priority == PRIORITY_FOCUSED_WITHOUT_MODE; }; uint32_t Layer::getLayerStack() const { auto p = mDrawingParent.promote(); if (p == nullptr) { return getDrawingState().layerStack; } return p->getLayerStack(); } bool Layer::setShadowRadius(float shadowRadius) { if (mCurrentState.shadowRadius == shadowRadius) { return false; } mCurrentState.sequence++; mCurrentState.shadowRadius = shadowRadius; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } bool Layer::setFixedTransformHint(ui::Transform::RotationFlags fixedTransformHint) { if (mCurrentState.fixedTransformHint == fixedTransformHint) { return false; } mCurrentState.sequence++; mCurrentState.fixedTransformHint = fixedTransformHint; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } void Layer::updateTreeHasFrameRateVote() { const auto traverseTree = [&](const LayerVector::Visitor& visitor) { auto parent = getParent(); while (parent) { visitor(parent.get()); parent = parent->getParent(); } traverse(LayerVector::StateSet::Current, visitor); }; // update parents and children about the vote // First traverse the tree and count how many layers has votes int layersWithVote = 0; traverseTree([&layersWithVote](Layer* layer) { const auto layerVotedWithDefaultCompatibility = layer->mCurrentState.frameRate.rate > 0 && layer->mCurrentState.frameRate.type == FrameRateCompatibility::Default; const auto layerVotedWithNoVote = layer->mCurrentState.frameRate.type == FrameRateCompatibility::NoVote; // We do not count layers that are ExactOrMultiple for the same reason // we are allowing touch boost for those layers. See // RefreshRateConfigs::getBestRefreshRate for more details. if (layerVotedWithDefaultCompatibility || layerVotedWithNoVote) { layersWithVote++; } }); // Now update the other layers bool transactionNeeded = false; traverseTree([layersWithVote, &transactionNeeded](Layer* layer) { if (layer->mCurrentState.treeHasFrameRateVote != layersWithVote > 0) { layer->mCurrentState.sequence++; layer->mCurrentState.treeHasFrameRateVote = layersWithVote > 0; layer->mCurrentState.modified = true; layer->setTransactionFlags(eTransactionNeeded); transactionNeeded = true; } }); if (transactionNeeded) { mFlinger->setTransactionFlags(eTraversalNeeded); } } bool Layer::setFrameRate(FrameRate frameRate) { if (!mFlinger->useFrameRateApi) { return false; } if (mCurrentState.frameRate == frameRate) { return false; } // Activate the layer in Scheduler's LayerHistory mFlinger->mScheduler->recordLayerHistory(this, systemTime(), LayerHistory::LayerUpdateType::SetFrameRate); mCurrentState.sequence++; mCurrentState.frameRate = frameRate; mCurrentState.modified = true; updateTreeHasFrameRateVote(); setTransactionFlags(eTransactionNeeded); return true; } Layer::FrameRate Layer::getFrameRateForLayerTree() const { const auto frameRate = getDrawingState().frameRate; if (frameRate.rate > 0 || frameRate.type == FrameRateCompatibility::NoVote) { return frameRate; } // This layer doesn't have a frame rate. If one of its ancestors or successors // have a vote, return a NoVote for ancestors/successors to set the vote if (getDrawingState().treeHasFrameRateVote) { return {0, FrameRateCompatibility::NoVote}; } return frameRate; } void Layer::deferTransactionUntil_legacy(const sp& barrierLayer, uint64_t frameNumber) { ATRACE_CALL(); if (mLayerDetached) { // If the layer is detached, then we don't defer this transaction since we will not // commit the pending state while the layer is detached. Adding sync points may cause // the barrier layer to wait for the states to be committed before dequeuing a buffer. return; } mCurrentState.barrierLayer_legacy = barrierLayer; mCurrentState.frameNumber_legacy = frameNumber; // We don't set eTransactionNeeded, because just receiving a deferral // request without any other state updates shouldn't actually induce a delay mCurrentState.modified = true; pushPendingState(); mCurrentState.barrierLayer_legacy = nullptr; mCurrentState.frameNumber_legacy = 0; mCurrentState.modified = false; } void Layer::deferTransactionUntil_legacy(const sp& barrierHandle, uint64_t frameNumber) { sp handle = static_cast(barrierHandle.get()); deferTransactionUntil_legacy(handle->owner.promote(), frameNumber); } // ---------------------------------------------------------------------------- // pageflip handling... // ---------------------------------------------------------------------------- bool Layer::isHiddenByPolicy() const { const State& s(mDrawingState); const auto& parent = mDrawingParent.promote(); if (parent != nullptr && parent->isHiddenByPolicy()) { return true; } if (usingRelativeZ(LayerVector::StateSet::Drawing)) { auto zOrderRelativeOf = mDrawingState.zOrderRelativeOf.promote(); if (zOrderRelativeOf != nullptr) { if (zOrderRelativeOf->isHiddenByPolicy()) { return true; } } } return s.flags & layer_state_t::eLayerHidden; } uint32_t Layer::getEffectiveUsage(uint32_t usage) const { // TODO: should we do something special if mSecure is set? if (mProtectedByApp) { // need a hardware-protected path to external video sink usage |= GraphicBuffer::USAGE_PROTECTED; } if (mPotentialCursor) { usage |= GraphicBuffer::USAGE_CURSOR; } usage |= GraphicBuffer::USAGE_HW_COMPOSER; return usage; } void Layer::updateTransformHint(ui::Transform::RotationFlags transformHint) { if (mFlinger->mDebugDisableTransformHint || transformHint & ui::Transform::ROT_INVALID) { transformHint = ui::Transform::ROT_0; } setTransformHint(transformHint); } // ---------------------------------------------------------------------------- // debugging // ---------------------------------------------------------------------------- // TODO(marissaw): add new layer state info to layer debugging LayerDebugInfo Layer::getLayerDebugInfo(const DisplayDevice* display) const { using namespace std::string_literals; LayerDebugInfo info; const State& ds = getDrawingState(); info.mName = getName(); sp parent = mDrawingParent.promote(); info.mParentName = parent ? parent->getName() : "none"s; info.mType = getType(); info.mTransparentRegion = ds.activeTransparentRegion_legacy; info.mVisibleRegion = getVisibleRegion(display); info.mSurfaceDamageRegion = surfaceDamageRegion; info.mLayerStack = getLayerStack(); info.mX = ds.active_legacy.transform.tx(); info.mY = ds.active_legacy.transform.ty(); info.mZ = ds.z; info.mWidth = ds.active_legacy.w; info.mHeight = ds.active_legacy.h; info.mCrop = ds.crop_legacy; info.mColor = ds.color; info.mFlags = ds.flags; info.mPixelFormat = getPixelFormat(); info.mDataSpace = static_cast(getDataSpace()); info.mMatrix[0][0] = ds.active_legacy.transform[0][0]; info.mMatrix[0][1] = ds.active_legacy.transform[0][1]; info.mMatrix[1][0] = ds.active_legacy.transform[1][0]; info.mMatrix[1][1] = ds.active_legacy.transform[1][1]; { sp buffer = getBuffer(); if (buffer != 0) { info.mActiveBufferWidth = buffer->getWidth(); info.mActiveBufferHeight = buffer->getHeight(); info.mActiveBufferStride = buffer->getStride(); info.mActiveBufferFormat = buffer->format; } else { info.mActiveBufferWidth = 0; info.mActiveBufferHeight = 0; info.mActiveBufferStride = 0; info.mActiveBufferFormat = 0; } } info.mNumQueuedFrames = getQueuedFrameCount(); info.mRefreshPending = isBufferLatched(); info.mIsOpaque = isOpaque(ds); info.mContentDirty = contentDirty; return info; } void Layer::miniDumpHeader(std::string& result) { result.append("-------------------------------"); result.append("-------------------------------"); result.append("-------------------------------"); result.append("-------------------------------"); result.append("-------------------\n"); result.append(" Layer name\n"); result.append(" Z | "); result.append(" Window Type | "); result.append(" Comp Type | "); result.append(" Transform | "); result.append(" Disp Frame (LTRB) | "); result.append(" Source Crop (LTRB) | "); result.append(" Frame Rate (Explicit) [Focused]\n"); result.append("-------------------------------"); result.append("-------------------------------"); result.append("-------------------------------"); result.append("-------------------------------"); result.append("-------------------\n"); } std::string Layer::frameRateCompatibilityString(Layer::FrameRateCompatibility compatibility) { switch (compatibility) { case FrameRateCompatibility::Default: return "Default"; case FrameRateCompatibility::ExactOrMultiple: return "ExactOrMultiple"; case FrameRateCompatibility::NoVote: return "NoVote"; } } void Layer::miniDump(std::string& result, const DisplayDevice& display) const { const auto outputLayer = findOutputLayerForDisplay(&display); if (!outputLayer) { return; } std::string name; if (mName.length() > 77) { std::string shortened; shortened.append(mName, 0, 36); shortened.append("[...]"); shortened.append(mName, mName.length() - 36); name = std::move(shortened); } else { name = mName; } StringAppendF(&result, " %s\n", name.c_str()); const State& layerState(getDrawingState()); const auto& outputLayerState = outputLayer->getState(); if (layerState.zOrderRelativeOf != nullptr || mDrawingParent != nullptr) { StringAppendF(&result, " rel %6d | ", layerState.z); } else { StringAppendF(&result, " %10d | ", layerState.z); } StringAppendF(&result, " %10d | ", mWindowType); StringAppendF(&result, "%10s | ", toString(getCompositionType(display)).c_str()); StringAppendF(&result, "%10s | ", toString(outputLayerState.bufferTransform).c_str()); const Rect& frame = outputLayerState.displayFrame; StringAppendF(&result, "%4d %4d %4d %4d | ", frame.left, frame.top, frame.right, frame.bottom); const FloatRect& crop = outputLayerState.sourceCrop; StringAppendF(&result, "%6.1f %6.1f %6.1f %6.1f | ", crop.left, crop.top, crop.right, crop.bottom); if (layerState.frameRate.rate != 0 || layerState.frameRate.type != FrameRateCompatibility::Default) { StringAppendF(&result, "% 6.2ffps %15s", layerState.frameRate.rate, frameRateCompatibilityString(layerState.frameRate.type).c_str()); } else { StringAppendF(&result, " "); } const auto focused = isLayerFocusedBasedOnPriority(getFrameRateSelectionPriority()); StringAppendF(&result, " [%s]\n", focused ? "*" : " "); result.append("- - - - - - - - - - - - - - - - "); result.append("- - - - - - - - - - - - - - - - "); result.append("- - - - - - - - - - - - - - - - "); result.append("- - - - - - - - - - - - - - - - "); result.append("- - - - - - - -\n"); } void Layer::dumpFrameStats(std::string& result) const { mFrameTracker.dumpStats(result); } void Layer::clearFrameStats() { mFrameTracker.clearStats(); } void Layer::logFrameStats() { mFrameTracker.logAndResetStats(mName); } void Layer::getFrameStats(FrameStats* outStats) const { mFrameTracker.getStats(outStats); } void Layer::dumpFrameEvents(std::string& result) { StringAppendF(&result, "- Layer %s (%s, %p)\n", getName().c_str(), getType(), this); Mutex::Autolock lock(mFrameEventHistoryMutex); mFrameEventHistory.checkFencesForCompletion(); mFrameEventHistory.dump(result); } void Layer::dumpCallingUidPid(std::string& result) const { StringAppendF(&result, "Layer %s (%s) pid:%d uid:%d\n", getName().c_str(), getType(), mCallingPid, mCallingUid); } void Layer::onDisconnect() { Mutex::Autolock lock(mFrameEventHistoryMutex); mFrameEventHistory.onDisconnect(); const int32_t layerId = getSequence(); mFlinger->mTimeStats->onDestroy(layerId); mFlinger->mFrameTracer->onDestroy(layerId); } void Layer::addAndGetFrameTimestamps(const NewFrameEventsEntry* newTimestamps, FrameEventHistoryDelta* outDelta) { if (newTimestamps) { mFlinger->mTimeStats->setPostTime(getSequence(), newTimestamps->frameNumber, getName().c_str(), newTimestamps->postedTime); mFlinger->mTimeStats->setAcquireFence(getSequence(), newTimestamps->frameNumber, newTimestamps->acquireFence); } Mutex::Autolock lock(mFrameEventHistoryMutex); if (newTimestamps) { // If there are any unsignaled fences in the aquire timeline at this // point, the previously queued frame hasn't been latched yet. Go ahead // and try to get the signal time here so the syscall is taken out of // the main thread's critical path. mAcquireTimeline.updateSignalTimes(); // Push the new fence after updating since it's likely still pending. mAcquireTimeline.push(newTimestamps->acquireFence); mFrameEventHistory.addQueue(*newTimestamps); } if (outDelta) { mFrameEventHistory.getAndResetDelta(outDelta); } } size_t Layer::getChildrenCount() const { size_t count = 0; for (const sp& child : mCurrentChildren) { count += 1 + child->getChildrenCount(); } return count; } void Layer::addChild(const sp& layer) { mChildrenChanged = true; setTransactionFlags(eTransactionNeeded); mCurrentChildren.add(layer); layer->setParent(this); updateTreeHasFrameRateVote(); } ssize_t Layer::removeChild(const sp& layer) { mChildrenChanged = true; setTransactionFlags(eTransactionNeeded); layer->setParent(nullptr); const auto removeResult = mCurrentChildren.remove(layer); updateTreeHasFrameRateVote(); layer->updateTreeHasFrameRateVote(); return removeResult; } void Layer::reparentChildren(const sp& newParent) { if (attachChildren()) { setTransactionFlags(eTransactionNeeded); } for (const sp& child : mCurrentChildren) { newParent->addChild(child); } mCurrentChildren.clear(); updateTreeHasFrameRateVote(); } bool Layer::reparentChildren(const sp& newParentHandle) { sp handle = nullptr; sp newParent = nullptr; if (newParentHandle == nullptr) { return false; } handle = static_cast(newParentHandle.get()); newParent = handle->owner.promote(); if (newParent == nullptr) { ALOGE("Unable to promote Layer handle"); return false; } reparentChildren(newParent); return true; } void Layer::setChildrenDrawingParent(const sp& newParent) { for (const sp& child : mDrawingChildren) { child->mDrawingParent = newParent; child->computeBounds(newParent->mBounds, newParent->getTransformWithScale(newParent->getBufferScaleTransform()), newParent->mEffectiveShadowRadius); } } bool Layer::reparent(const sp& newParentHandle) { bool callSetTransactionFlags = false; // While layers are detached, we allow most operations // and simply halt performing the actual transaction. However // for reparent != null we would enter the mRemovedFromCurrentState // state, regardless of whether doTransaction was called, and // so we need to prevent the update here. if (mLayerDetached && newParentHandle == nullptr) { return false; } sp newParent; if (newParentHandle != nullptr) { auto handle = static_cast(newParentHandle.get()); newParent = handle->owner.promote(); if (newParent == nullptr) { ALOGE("Unable to promote Layer handle"); return false; } if (newParent == this) { ALOGE("Invalid attempt to reparent Layer (%s) to itself", getName().c_str()); return false; } } sp parent = getParent(); if (parent != nullptr) { parent->removeChild(this); } if (newParentHandle != nullptr) { newParent->addChild(this); if (!newParent->isRemovedFromCurrentState()) { addToCurrentState(); } else { onRemovedFromCurrentState(); } if (mLayerDetached) { mLayerDetached = false; callSetTransactionFlags = true; } } else { onRemovedFromCurrentState(); } if (callSetTransactionFlags || attachChildren()) { setTransactionFlags(eTransactionNeeded); } return true; } bool Layer::detachChildren() { for (const sp& child : mCurrentChildren) { sp parentClient = mClientRef.promote(); sp client(child->mClientRef.promote()); if (client != nullptr && parentClient != client) { child->mLayerDetached = true; child->detachChildren(); child->removeRemoteSyncPoints(); } } return true; } bool Layer::attachChildren() { bool changed = false; for (const sp& child : mCurrentChildren) { sp parentClient = mClientRef.promote(); sp client(child->mClientRef.promote()); if (client != nullptr && parentClient != client) { if (child->mLayerDetached) { child->mLayerDetached = false; changed = true; } changed |= child->attachChildren(); } } return changed; } bool Layer::setColorTransform(const mat4& matrix) { static const mat4 identityMatrix = mat4(); if (mCurrentState.colorTransform == matrix) { return false; } ++mCurrentState.sequence; mCurrentState.colorTransform = matrix; mCurrentState.hasColorTransform = matrix != identityMatrix; mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; } mat4 Layer::getColorTransform() const { mat4 colorTransform = mat4(getDrawingState().colorTransform); if (sp parent = mDrawingParent.promote(); parent != nullptr) { colorTransform = parent->getColorTransform() * colorTransform; } return colorTransform; } bool Layer::hasColorTransform() const { bool hasColorTransform = getDrawingState().hasColorTransform; if (sp parent = mDrawingParent.promote(); parent != nullptr) { hasColorTransform = hasColorTransform || parent->hasColorTransform(); } return hasColorTransform; } bool Layer::isLegacyDataSpace() const { // return true when no higher bits are set return !(getDataSpace() & (ui::Dataspace::STANDARD_MASK | ui::Dataspace::TRANSFER_MASK | ui::Dataspace::RANGE_MASK)); } void Layer::setParent(const sp& layer) { mCurrentParent = layer; } int32_t Layer::getZ(LayerVector::StateSet stateSet) const { const bool useDrawing = stateSet == LayerVector::StateSet::Drawing; const State& state = useDrawing ? mDrawingState : mCurrentState; return state.z; } bool Layer::usingRelativeZ(LayerVector::StateSet stateSet) const { const bool useDrawing = stateSet == LayerVector::StateSet::Drawing; const State& state = useDrawing ? mDrawingState : mCurrentState; return state.isRelativeOf; } __attribute__((no_sanitize("unsigned-integer-overflow"))) LayerVector Layer::makeTraversalList( LayerVector::StateSet stateSet, bool* outSkipRelativeZUsers) { LOG_ALWAYS_FATAL_IF(stateSet == LayerVector::StateSet::Invalid, "makeTraversalList received invalid stateSet"); const bool useDrawing = stateSet == LayerVector::StateSet::Drawing; const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren; const State& state = useDrawing ? mDrawingState : mCurrentState; if (state.zOrderRelatives.size() == 0) { *outSkipRelativeZUsers = true; return children; } LayerVector traverse(stateSet); for (const wp& weakRelative : state.zOrderRelatives) { sp strongRelative = weakRelative.promote(); if (strongRelative != nullptr) { traverse.add(strongRelative); } } for (const sp& child : children) { if (child->usingRelativeZ(stateSet)) { continue; } traverse.add(child); } return traverse; } /** * Negatively signed relatives are before 'this' in Z-order. */ void Layer::traverseInZOrder(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor) { // In the case we have other layers who are using a relative Z to us, makeTraversalList will // produce a new list for traversing, including our relatives, and not including our children // who are relatives of another surface. In the case that there are no relative Z, // makeTraversalList returns our children directly to avoid significant overhead. // However in this case we need to take the responsibility for filtering children which // are relatives of another surface here. bool skipRelativeZUsers = false; const LayerVector list = makeTraversalList(stateSet, &skipRelativeZUsers); size_t i = 0; for (; i < list.size(); i++) { const auto& relative = list[i]; if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) { continue; } if (relative->getZ(stateSet) >= 0) { break; } relative->traverseInZOrder(stateSet, visitor); } visitor(this); for (; i < list.size(); i++) { const auto& relative = list[i]; if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) { continue; } relative->traverseInZOrder(stateSet, visitor); } } /** * Positively signed relatives are before 'this' in reverse Z-order. */ void Layer::traverseInReverseZOrder(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor) { // See traverseInZOrder for documentation. bool skipRelativeZUsers = false; LayerVector list = makeTraversalList(stateSet, &skipRelativeZUsers); int32_t i = 0; for (i = int32_t(list.size()) - 1; i >= 0; i--) { const auto& relative = list[i]; if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) { continue; } if (relative->getZ(stateSet) < 0) { break; } relative->traverseInReverseZOrder(stateSet, visitor); } visitor(this); for (; i >= 0; i--) { const auto& relative = list[i]; if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) { continue; } relative->traverseInReverseZOrder(stateSet, visitor); } } void Layer::traverse(LayerVector::StateSet state, const LayerVector::Visitor& visitor) { visitor(this); const LayerVector& children = state == LayerVector::StateSet::Drawing ? mDrawingChildren : mCurrentChildren; for (const sp& child : children) { child->traverse(state, visitor); } } LayerVector Layer::makeChildrenTraversalList(LayerVector::StateSet stateSet, const std::vector& layersInTree) { LOG_ALWAYS_FATAL_IF(stateSet == LayerVector::StateSet::Invalid, "makeTraversalList received invalid stateSet"); const bool useDrawing = stateSet == LayerVector::StateSet::Drawing; const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren; const State& state = useDrawing ? mDrawingState : mCurrentState; LayerVector traverse(stateSet); for (const wp& weakRelative : state.zOrderRelatives) { sp strongRelative = weakRelative.promote(); // Only add relative layers that are also descendents of the top most parent of the tree. // If a relative layer is not a descendent, then it should be ignored. if (std::binary_search(layersInTree.begin(), layersInTree.end(), strongRelative.get())) { traverse.add(strongRelative); } } for (const sp& child : children) { const State& childState = useDrawing ? child->mDrawingState : child->mCurrentState; // If a layer has a relativeOf layer, only ignore if the layer it's relative to is a // descendent of the top most parent of the tree. If it's not a descendent, then just add // the child here since it won't be added later as a relative. if (std::binary_search(layersInTree.begin(), layersInTree.end(), childState.zOrderRelativeOf.promote().get())) { continue; } traverse.add(child); } return traverse; } void Layer::traverseChildrenInZOrderInner(const std::vector& layersInTree, LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor) { const LayerVector list = makeChildrenTraversalList(stateSet, layersInTree); size_t i = 0; for (; i < list.size(); i++) { const auto& relative = list[i]; if (relative->getZ(stateSet) >= 0) { break; } relative->traverseChildrenInZOrderInner(layersInTree, stateSet, visitor); } visitor(this); for (; i < list.size(); i++) { const auto& relative = list[i]; relative->traverseChildrenInZOrderInner(layersInTree, stateSet, visitor); } } std::vector Layer::getLayersInTree(LayerVector::StateSet stateSet) { const bool useDrawing = stateSet == LayerVector::StateSet::Drawing; const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren; std::vector layersInTree = {this}; for (size_t i = 0; i < children.size(); i++) { const auto& child = children[i]; std::vector childLayers = child->getLayersInTree(stateSet); layersInTree.insert(layersInTree.end(), childLayers.cbegin(), childLayers.cend()); } return layersInTree; } void Layer::traverseChildrenInZOrder(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor) { std::vector layersInTree = getLayersInTree(stateSet); std::sort(layersInTree.begin(), layersInTree.end()); traverseChildrenInZOrderInner(layersInTree, stateSet, visitor); } ui::Transform Layer::getTransform() const { return mEffectiveTransform; } half Layer::getAlpha() const { const auto& p = mDrawingParent.promote(); half parentAlpha = (p != nullptr) ? p->getAlpha() : 1.0_hf; return parentAlpha * getDrawingState().color.a; } ui::Transform::RotationFlags Layer::getFixedTransformHint() const { ui::Transform::RotationFlags fixedTransformHint = mCurrentState.fixedTransformHint; if (fixedTransformHint != ui::Transform::ROT_INVALID) { return fixedTransformHint; } const auto& p = mCurrentParent.promote(); if (!p) return fixedTransformHint; return p->getFixedTransformHint(); } half4 Layer::getColor() const { const half4 color(getDrawingState().color); return half4(color.r, color.g, color.b, getAlpha()); } int32_t Layer::getBackgroundBlurRadius() const { return getDrawingState().backgroundBlurRadius; } Layer::RoundedCornerState Layer::getRoundedCornerState() const { const auto& p = mDrawingParent.promote(); if (p != nullptr) { RoundedCornerState parentState = p->getRoundedCornerState(); if (parentState.radius > 0) { ui::Transform t = getActiveTransform(getDrawingState()); t = t.inverse(); parentState.cropRect = t.transform(parentState.cropRect); // The rounded corners shader only accepts 1 corner radius for performance reasons, // but a transform matrix can define horizontal and vertical scales. // Let's take the average between both of them and pass into the shader, practically we // never do this type of transformation on windows anyway. auto scaleX = sqrtf(t[0][0] * t[0][0] + t[0][1] * t[0][1]); auto scaleY = sqrtf(t[1][0] * t[1][0] + t[1][1] * t[1][1]); parentState.radius *= (scaleX + scaleY) / 2.0f; return parentState; } } const float radius = getDrawingState().cornerRadius; return radius > 0 && getCrop(getDrawingState()).isValid() ? RoundedCornerState(getCrop(getDrawingState()).toFloatRect(), radius) : RoundedCornerState(); } renderengine::ShadowSettings Layer::getShadowSettings(const Rect& viewport) const { renderengine::ShadowSettings state = mFlinger->mDrawingState.globalShadowSettings; // Shift the spot light x-position to the middle of the display and then // offset it by casting layer's screen pos. state.lightPos.x = (viewport.width() / 2.f) - mScreenBounds.left; state.lightPos.y -= mScreenBounds.top; state.length = mEffectiveShadowRadius; return state; } void Layer::commitChildList() { for (size_t i = 0; i < mCurrentChildren.size(); i++) { const auto& child = mCurrentChildren[i]; child->commitChildList(); } mDrawingChildren = mCurrentChildren; mDrawingParent = mCurrentParent; } static wp extractLayerFromBinder(const wp& weakBinderHandle) { if (weakBinderHandle == nullptr) { return nullptr; } sp binderHandle = weakBinderHandle.promote(); if (binderHandle == nullptr) { return nullptr; } sp handle = static_cast(binderHandle.get()); if (handle == nullptr) { return nullptr; } return handle->owner; } void Layer::setInputInfo(const InputWindowInfo& info) { mCurrentState.inputInfo = info; mCurrentState.touchableRegionCrop = extractLayerFromBinder(info.touchableRegionCropHandle); mCurrentState.modified = true; mCurrentState.inputInfoChanged = true; setTransactionFlags(eTransactionNeeded); } LayerProto* Layer::writeToProto(LayersProto& layersProto, uint32_t traceFlags, const DisplayDevice* display) const { LayerProto* layerProto = layersProto.add_layers(); writeToProtoDrawingState(layerProto, traceFlags, display); writeToProtoCommonState(layerProto, LayerVector::StateSet::Drawing, traceFlags); if (traceFlags & SurfaceTracing::TRACE_COMPOSITION) { // Only populate for the primary display. if (display) { const Hwc2::IComposerClient::Composition compositionType = getCompositionType(*display); layerProto->set_hwc_composition_type(static_cast(compositionType)); } } for (const sp& layer : mDrawingChildren) { layer->writeToProto(layersProto, traceFlags, display); } return layerProto; } void Layer::writeToProtoDrawingState(LayerProto* layerInfo, uint32_t traceFlags, const DisplayDevice* display) const { ui::Transform transform = getTransform(); if (traceFlags & SurfaceTracing::TRACE_CRITICAL) { for (const auto& pendingState : mPendingStatesSnapshot) { auto barrierLayer = pendingState.barrierLayer_legacy.promote(); if (barrierLayer != nullptr) { BarrierLayerProto* barrierLayerProto = layerInfo->add_barrier_layer(); barrierLayerProto->set_id(barrierLayer->sequence); barrierLayerProto->set_frame_number(pendingState.frameNumber_legacy); } } auto buffer = getBuffer(); if (buffer != nullptr) { LayerProtoHelper::writeToProto(buffer, [&]() { return layerInfo->mutable_active_buffer(); }); LayerProtoHelper::writeToProto(ui::Transform(getBufferTransform()), layerInfo->mutable_buffer_transform()); } layerInfo->set_invalidate(contentDirty); layerInfo->set_is_protected(isProtected()); layerInfo->set_dataspace(dataspaceDetails(static_cast(getDataSpace()))); layerInfo->set_queued_frames(getQueuedFrameCount()); layerInfo->set_refresh_pending(isBufferLatched()); layerInfo->set_curr_frame(mCurrentFrameNumber); layerInfo->set_effective_scaling_mode(getEffectiveScalingMode()); layerInfo->set_corner_radius(getRoundedCornerState().radius); layerInfo->set_is_trusted_overlay(isTrustedOverlay()); LayerProtoHelper::writeToProto(transform, layerInfo->mutable_transform()); LayerProtoHelper::writePositionToProto(transform.tx(), transform.ty(), [&]() { return layerInfo->mutable_position(); }); LayerProtoHelper::writeToProto(mBounds, [&]() { return layerInfo->mutable_bounds(); }); if (traceFlags & SurfaceTracing::TRACE_COMPOSITION) { LayerProtoHelper::writeToProto(getVisibleRegion(display), [&]() { return layerInfo->mutable_visible_region(); }); } LayerProtoHelper::writeToProto(surfaceDamageRegion, [&]() { return layerInfo->mutable_damage_region(); }); if (hasColorTransform()) { LayerProtoHelper::writeToProto(getColorTransform(), layerInfo->mutable_color_transform()); } } LayerProtoHelper::writeToProto(mSourceBounds, [&]() { return layerInfo->mutable_source_bounds(); }); LayerProtoHelper::writeToProto(mScreenBounds, [&]() { return layerInfo->mutable_screen_bounds(); }); LayerProtoHelper::writeToProto(getRoundedCornerState().cropRect, [&]() { return layerInfo->mutable_corner_radius_crop(); }); layerInfo->set_shadow_radius(mEffectiveShadowRadius); } void Layer::writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet stateSet, uint32_t traceFlags) const { const bool useDrawing = stateSet == LayerVector::StateSet::Drawing; const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren; const State& state = useDrawing ? mDrawingState : mCurrentState; ui::Transform requestedTransform = state.active_legacy.transform; if (traceFlags & SurfaceTracing::TRACE_CRITICAL) { layerInfo->set_id(sequence); layerInfo->set_name(getName().c_str()); layerInfo->set_type(getType()); for (const auto& child : children) { layerInfo->add_children(child->sequence); } for (const wp& weakRelative : state.zOrderRelatives) { sp strongRelative = weakRelative.promote(); if (strongRelative != nullptr) { layerInfo->add_relatives(strongRelative->sequence); } } LayerProtoHelper::writeToProto(state.activeTransparentRegion_legacy, [&]() { return layerInfo->mutable_transparent_region(); }); layerInfo->set_layer_stack(getLayerStack()); layerInfo->set_z(state.z); LayerProtoHelper::writePositionToProto(requestedTransform.tx(), requestedTransform.ty(), [&]() { return layerInfo->mutable_requested_position(); }); LayerProtoHelper::writeSizeToProto(state.active_legacy.w, state.active_legacy.h, [&]() { return layerInfo->mutable_size(); }); LayerProtoHelper::writeToProto(state.crop_legacy, [&]() { return layerInfo->mutable_crop(); }); layerInfo->set_is_opaque(isOpaque(state)); layerInfo->set_pixel_format(decodePixelFormat(getPixelFormat())); LayerProtoHelper::writeToProto(getColor(), [&]() { return layerInfo->mutable_color(); }); LayerProtoHelper::writeToProto(state.color, [&]() { return layerInfo->mutable_requested_color(); }); layerInfo->set_flags(state.flags); LayerProtoHelper::writeToProto(requestedTransform, layerInfo->mutable_requested_transform()); auto parent = useDrawing ? mDrawingParent.promote() : mCurrentParent.promote(); if (parent != nullptr) { layerInfo->set_parent(parent->sequence); } else { layerInfo->set_parent(-1); } auto zOrderRelativeOf = state.zOrderRelativeOf.promote(); if (zOrderRelativeOf != nullptr) { layerInfo->set_z_order_relative_of(zOrderRelativeOf->sequence); } else { layerInfo->set_z_order_relative_of(-1); } layerInfo->set_is_relative_of(state.isRelativeOf); } if (traceFlags & SurfaceTracing::TRACE_INPUT) { LayerProtoHelper::writeToProto(state.inputInfo, state.touchableRegionCrop, [&]() { return layerInfo->mutable_input_window_info(); }); } if (traceFlags & SurfaceTracing::TRACE_EXTRA) { auto protoMap = layerInfo->mutable_metadata(); for (const auto& entry : state.metadata.mMap) { (*protoMap)[entry.first] = std::string(entry.second.cbegin(), entry.second.cend()); } } } bool Layer::isRemovedFromCurrentState() const { return mRemovedFromCurrentState; } gui::DropInputMode Layer::getDropInputMode() const { gui::DropInputMode mode = mDrawingState.dropInputMode; if (mode == gui::DropInputMode::ALL) { return mode; } sp parent = mDrawingParent.promote(); if (parent) { gui::DropInputMode parentMode = parent->getDropInputMode(); if (parentMode != gui::DropInputMode::NONE) { return parentMode; } } return mode; } void Layer::handleDropInputMode(InputWindowInfo& info) const { if ((mDrawingState.inputInfo.inputFeatures & InputWindowInfo::INPUT_FEATURE_NO_INPUT_CHANNEL) == InputWindowInfo::INPUT_FEATURE_NO_INPUT_CHANNEL) { return; } // Check if we need to drop input unconditionally gui::DropInputMode dropInputMode = getDropInputMode(); if (dropInputMode == gui::DropInputMode::ALL) { info.inputFeatures |= InputWindowInfo::INPUT_FEATURE_DROP_INPUT; ALOGV("Dropping input for %s as requested by policy.", getDebugName()); return; } } InputWindowInfo Layer::fillInputInfo() { if (!hasInputInfo()) { mDrawingState.inputInfo.name = getName(); mDrawingState.inputInfo.ownerUid = mCallingUid; mDrawingState.inputInfo.ownerPid = mCallingPid; mDrawingState.inputInfo.inputFeatures = InputWindowInfo::INPUT_FEATURE_NO_INPUT_CHANNEL; mDrawingState.inputInfo.layoutParamsFlags = InputWindowInfo::FLAG_NOT_TOUCH_MODAL; mDrawingState.inputInfo.displayId = getLayerStack(); } InputWindowInfo info = mDrawingState.inputInfo; info.id = sequence; if (info.displayId == ADISPLAY_ID_NONE) { info.displayId = getLayerStack(); } ui::Transform t = getTransform(); const float xScale = t.sx(); const float yScale = t.sy(); int32_t xSurfaceInset = info.surfaceInset; int32_t ySurfaceInset = info.surfaceInset; if (xScale != 1.0f || yScale != 1.0f) { info.windowXScale *= (xScale != 0.0f) ? 1.0f / xScale : 0.0f; info.windowYScale *= (yScale != 0.0f) ? 1.0f / yScale : 0.0f; info.touchableRegion.scaleSelf(xScale, yScale); xSurfaceInset = std::round(xSurfaceInset * xScale); ySurfaceInset = std::round(ySurfaceInset * yScale); } // Transform layer size to screen space and inset it by surface insets. // If this is a portal window, set the touchableRegion to the layerBounds. Rect layerBounds = info.portalToDisplayId == ADISPLAY_ID_NONE ? getBufferSize(getDrawingState()) : info.touchableRegion.getBounds(); if (!layerBounds.isValid()) { layerBounds = getCroppedBufferSize(getDrawingState()); } layerBounds = t.transform(layerBounds); // clamp inset to layer bounds xSurfaceInset = (xSurfaceInset >= 0) ? std::min(xSurfaceInset, layerBounds.getWidth() / 2) : 0; ySurfaceInset = (ySurfaceInset >= 0) ? std::min(ySurfaceInset, layerBounds.getHeight() / 2) : 0; // inset while protecting from overflow TODO(b/161235021): What is going wrong // in the overflow scenario? { int32_t tmp; if (!__builtin_add_overflow(layerBounds.left, xSurfaceInset, &tmp)) layerBounds.left = tmp; if (!__builtin_sub_overflow(layerBounds.right, xSurfaceInset, &tmp)) layerBounds.right = tmp; if (!__builtin_add_overflow(layerBounds.top, ySurfaceInset, &tmp)) layerBounds.top = tmp; if (!__builtin_sub_overflow(layerBounds.bottom, ySurfaceInset, &tmp)) layerBounds.bottom = tmp; } // Input coordinate should match the layer bounds. info.frameLeft = layerBounds.left; info.frameTop = layerBounds.top; info.frameRight = layerBounds.right; info.frameBottom = layerBounds.bottom; // Position the touchable region relative to frame screen location and restrict it to frame // bounds. info.touchableRegion = info.touchableRegion.translate(info.frameLeft, info.frameTop); // For compatibility reasons we let layers which can receive input // receive input before they have actually submitted a buffer. Because // of this we use canReceiveInput instead of isVisible to check the // policy-visibility, ignoring the buffer state. However for layers with // hasInputInfo()==false we can use the real visibility state. // We are just using these layers for occlusion detection in // InputDispatcher, and obviously if they aren't visible they can't occlude // anything. info.visible = hasInputInfo() ? canReceiveInput() : isVisible(); handleDropInputMode(info); auto cropLayer = mDrawingState.touchableRegionCrop.promote(); if (info.replaceTouchableRegionWithCrop) { if (cropLayer == nullptr) { info.touchableRegion = Region(Rect{mScreenBounds}); } else { info.touchableRegion = Region(Rect{cropLayer->mScreenBounds}); } } else if (cropLayer != nullptr) { info.touchableRegion = info.touchableRegion.intersect(Rect{cropLayer->mScreenBounds}); } // Inherit the trusted state from the parent hierarchy, but don't clobber the trusted state // if it was set by WM for a known system overlay info.trustedOverlay = info.trustedOverlay || isTrustedOverlay(); // If the layer is a clone, we need to crop the input region to cloned root to prevent // touches from going outside the cloned area. if (isClone()) { sp clonedRoot = getClonedRoot(); if (clonedRoot != nullptr) { Rect rect(clonedRoot->mScreenBounds); info.touchableRegion = info.touchableRegion.intersect(rect); } } return info; } sp Layer::getClonedRoot() { if (mClonedChild != nullptr) { return this; } if (mDrawingParent == nullptr || mDrawingParent.promote() == nullptr) { return nullptr; } return mDrawingParent.promote()->getClonedRoot(); } bool Layer::hasInputInfo() const { return mDrawingState.inputInfo.token != nullptr; } bool Layer::canReceiveInput() const { return !isHiddenByPolicy(); } compositionengine::OutputLayer* Layer::findOutputLayerForDisplay( const DisplayDevice* display) const { if (!display) return nullptr; return display->getCompositionDisplay()->getOutputLayerForLayer(getCompositionEngineLayerFE()); } Region Layer::getVisibleRegion(const DisplayDevice* display) const { const auto outputLayer = findOutputLayerForDisplay(display); return outputLayer ? outputLayer->getState().visibleRegion : Region(); } void Layer::setInitialValuesForClone(const sp& clonedFrom) { // copy drawing state from cloned layer mDrawingState = clonedFrom->mDrawingState; mClonedFrom = clonedFrom; } void Layer::updateMirrorInfo() { if (mClonedChild == nullptr || !mClonedChild->isClonedFromAlive()) { // If mClonedChild is null, there is nothing to mirror. If isClonedFromAlive returns false, // it means that there is a clone, but the layer it was cloned from has been destroyed. In // that case, we want to delete the reference to the clone since we want it to get // destroyed. The root, this layer, will still be around since the client can continue // to hold a reference, but no cloned layers will be displayed. mClonedChild = nullptr; return; } std::map, sp> clonedLayersMap; // If the real layer exists and is in current state, add the clone as a child of the root. // There's no need to remove from drawingState when the layer is offscreen since currentState is // copied to drawingState for the root layer. So the clonedChild is always removed from // drawingState and then needs to be added back each traversal. if (!mClonedChild->getClonedFrom()->isRemovedFromCurrentState()) { addChildToDrawing(mClonedChild); } mClonedChild->updateClonedDrawingState(clonedLayersMap); mClonedChild->updateClonedChildren(this, clonedLayersMap); mClonedChild->updateClonedRelatives(clonedLayersMap); } void Layer::updateClonedDrawingState(std::map, sp>& clonedLayersMap) { // If the layer the clone was cloned from is alive, copy the content of the drawingState // to the clone. If the real layer is no longer alive, continue traversing the children // since we may be able to pull out other children that are still alive. if (isClonedFromAlive()) { sp clonedFrom = getClonedFrom(); mDrawingState = clonedFrom->mDrawingState; clonedLayersMap.emplace(clonedFrom, this); } // The clone layer may have children in drawingState since they may have been created and // added from a previous request to updateMirorInfo. This is to ensure we don't recreate clones // that already exist, since we can just re-use them. // The drawingChildren will not get overwritten by the currentChildren since the clones are // not updated in the regular traversal. They are skipped since the root will lose the // reference to them when it copies its currentChildren to drawing. for (sp& child : mDrawingChildren) { child->updateClonedDrawingState(clonedLayersMap); } } void Layer::updateClonedChildren(const sp& mirrorRoot, std::map, sp>& clonedLayersMap) { mDrawingChildren.clear(); if (!isClonedFromAlive()) { return; } sp clonedFrom = getClonedFrom(); for (sp& child : clonedFrom->mDrawingChildren) { if (child == mirrorRoot) { // This is to avoid cyclical mirroring. continue; } sp clonedChild = clonedLayersMap[child]; if (clonedChild == nullptr) { clonedChild = child->createClone(); clonedLayersMap[child] = clonedChild; } addChildToDrawing(clonedChild); clonedChild->updateClonedChildren(mirrorRoot, clonedLayersMap); } } void Layer::updateClonedInputInfo(const std::map, sp>& clonedLayersMap) { auto cropLayer = mDrawingState.touchableRegionCrop.promote(); if (cropLayer != nullptr) { if (clonedLayersMap.count(cropLayer) == 0) { // Real layer had a crop layer but it's not in the cloned hierarchy. Just set to // self as crop layer to avoid going outside bounds. mDrawingState.touchableRegionCrop = this; } else { const sp& clonedCropLayer = clonedLayersMap.at(cropLayer); mDrawingState.touchableRegionCrop = clonedCropLayer; } } // Cloned layers shouldn't handle watch outside since their z order is not determined by // WM or the client. mDrawingState.inputInfo.layoutParamsFlags &= ~InputWindowInfo::FLAG_WATCH_OUTSIDE_TOUCH; } void Layer::updateClonedRelatives(const std::map, sp>& clonedLayersMap) { mDrawingState.zOrderRelativeOf = nullptr; mDrawingState.zOrderRelatives.clear(); if (!isClonedFromAlive()) { return; } const sp& clonedFrom = getClonedFrom(); for (wp& relativeWeak : clonedFrom->mDrawingState.zOrderRelatives) { const sp& relative = relativeWeak.promote(); if (clonedLayersMap.count(relative) > 0) { auto& clonedRelative = clonedLayersMap.at(relative); mDrawingState.zOrderRelatives.add(clonedRelative); } } // Check if the relativeLayer for the real layer is part of the cloned hierarchy. // It's possible that the layer it's relative to is outside the requested cloned hierarchy. // In that case, we treat the layer as if the relativeOf has been removed. This way, it will // still traverse the children, but the layer with the missing relativeOf will not be shown // on screen. const sp& relativeOf = clonedFrom->mDrawingState.zOrderRelativeOf.promote(); if (clonedLayersMap.count(relativeOf) > 0) { const sp& clonedRelativeOf = clonedLayersMap.at(relativeOf); mDrawingState.zOrderRelativeOf = clonedRelativeOf; } updateClonedInputInfo(clonedLayersMap); for (sp& child : mDrawingChildren) { child->updateClonedRelatives(clonedLayersMap); } } void Layer::addChildToDrawing(const sp& layer) { mDrawingChildren.add(layer); layer->mDrawingParent = this; } Layer::FrameRateCompatibility Layer::FrameRate::convertCompatibility(int8_t compatibility) { switch (compatibility) { case ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_DEFAULT: return FrameRateCompatibility::Default; case ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_FIXED_SOURCE: return FrameRateCompatibility::ExactOrMultiple; default: LOG_ALWAYS_FATAL("Invalid frame rate compatibility value %d", compatibility); return FrameRateCompatibility::Default; } } bool Layer::setDropInputMode(gui::DropInputMode mode) { if (mCurrentState.dropInputMode == mode) { return false; } mCurrentState.dropInputMode = mode; mCurrentState.modified = true; mCurrentState.inputInfoChanged = true; setTransactionFlags(eTransactionNeeded); return true; } // --------------------------------------------------------------------------- }; // namespace android #if defined(__gl_h_) #error "don't include gl/gl.h in this file" #endif #if defined(__gl2_h_) #error "don't include gl2/gl2.h in this file" #endif // TODO(b/129481165): remove the #pragma below and fix conversion issues #pragma clang diagnostic pop // ignored "-Wconversion"