SurfaceFlinger中Layer的修改 - 安卓R

SurfaceControl的内部类Transaction

根据SurfaceFlinger中Layer的创建流程，一般在app中创建Surface，SurfaceFlinger中有一个Layer与之对应，通过BufferQueue机制将app的Surface图像传给SurfaceFlinger的Layer进行SurfaceFlinger中Layer的合成并显示到屏幕上。而SurfaceControl是对Surface包装，如果希望修改Surface对应的Layer的状态例如位置、大小等，则可以使用SurfaceControl的内部静态类Transaction实现，示例代码如下：

// val sc: SurfaceControl
SurfaceControl.Transaction().apply {
     // 创建SurfaceControl.Transaction对象
    setPosition(sc, x, y)  // 设置某个SurfaceControl的位置
    setAlpha(sc, alpha)  // 设置某个SurfaceControl的透明度
    show(sc)  // 设置某个SurfaceControl显示
    apply()  // 提交之前的设置
}

首先创建SurfaceControl.Transaction对象，然后调用一些set方法设置某个SurfaceControl的状态，最后调用apply方法提交状态设置。

那么我们从Transaction的setPosition来看其是怎么实现的（frameworks/base/core/java/android/view/SurfaceControl.java）：

        /**
         * @hide
         */
        @UnsupportedAppUsage
        public Transaction setPosition(SurfaceControl sc, float x, float y) {
   
            checkPreconditions(sc);
            nativeSetPosition(mNativeObject, sc.mNativeObject, x, y);
            return this;
        }

直接调用了frameworks/base/core/jni/android_view_SurfaceControl.cpp的nativeSetPosition方法：

static void nativeSetPosition(JNIEnv* env, jclass clazz, jlong transactionObj,
        jlong nativeObject, jfloat x, jfloat y) {
   
    auto transaction = reinterpret_cast<SurfaceComposerClient::Transaction*>(transactionObj);

    SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject);
    transaction->setPosition(ctrl, x, y);
}

还原了native的Transaction对象和SurfaceControl对象，其中Transaction是SurfaceComposerClient的内部类，调用了transaction的setPosition方法（frameworks/native/libs/gui/SurfaceComposerClient.cpp）：

SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setPosition(
        const sp<SurfaceControl>& sc, float x, float y) {
   
    layer_state_t* s = getLayerState(sc);
    if (!s) {
   
        mStatus = BAD_INDEX;
        return *this;
    }
    s->what |= layer_state_t::ePositionChanged;
    s->x = x;
    s->y = y;

    registerSurfaceControlForCallback(sc);
    return *this;
}

在layer_state_t对象中保存了x和y的值，并对位置的改变记录在了what中，那么继续看Transaction的getLayerState方法是怎么拿到layer_state_t对象的（frameworks/native/libs/gui/include/gui/SurfaceComposerClient.h和cpp）：

    class Transaction : public Parcelable {
   
    protected:
        std::unordered_map<sp<IBinder>, ComposerState, IBinderHash> mComposerStates;
        ......
        layer_state_t* getLayerState(const sp<SurfaceControl>& sc) {
   
            return getLayerState(sc->getHandle());
        }
        ......
    }

layer_state_t* SurfaceComposerClient::Transaction::getLayerState(const sp<IBinder>& handle) {
   
    if (mComposerStates.count(handle) == 0) {
   
        // we don't have it, add an initialized layer_state to our list
        ComposerState s;
        s.state.surface = handle;
        mComposerStates[handle] = s;
    }

    return &(mComposerStates[handle].state);
}

mComposerStates的key是SurfaceControl的mHandle，值是ComposerState对象，其有layer_state_t类型的成员遍历state，这里面存放了what、x、y等一些状态变量。

因此根据对Transaction的setPosition方法分析得知，Transaction将每个SurfaceControl设置的状态保存在其相应native对象的mComposerStates成员变量中。

接下来分析Transaction的apply方法（frameworks/base/core/java/android/view/SurfaceControl.java）：

        /**
         * Apply the transaction, clearing it's state, and making it usable
         * as a new transaction.
         */
        public void apply() {
   
            apply(false);
        }

        /**
         * Jankier version of apply. Avoid use (b/28068298).
         * @hide
         */
        public void apply(boolean sync) {
   
            applyResizedSurfaces();  // 直接改变SurfaceControl的with和height
            notifyReparentedSurfaces();  // 调用OnReparentListener的onReparent方法
            nativeApplyTransaction(mNativeObject, sync);
        }

调用了frameworks/base/core/jni/android_view_SurfaceControl.cpp的nativeApplyTransaction方法：

static void nativeApplyTransaction(JNIEnv* env, jclass clazz, jlong transactionObj, jboolean sync) {
   
    auto transaction = reinterpret_cast<SurfaceComposerClient::Transaction*>(transactionObj);
    transaction->apply(sync);
}

进而调用了SurfaceComposerClient::Transaction的apply方法：

status_t SurfaceComposerClient::Transaction::apply(bool synchronous) {
   
    if (mStatus != NO_ERROR) {
   
        return mStatus;
    }

    sp<ISurfaceComposer> sf(ComposerService::getComposerService());

    bool hasListenerCallbacks = !mListenerCallbacks.empty();
    std::vector<ListenerCallbacks> listenerCallbacks;
    // For every listener with registered callbacks
    for (const auto& [listener, callbackInfo] : mListenerCallbacks) {
   
        auto& [callbackIds, surfaceControls] = callbackInfo;
        if (callbackIds.empty()) {
   
            continue;
        }

        if (surfaceControls.empty()) {
   
            listenerCallbacks.emplace_back(IInterface::asBinder(listener), std::move(callbackIds));
        } else {
   
            // If the listener has any SurfaceControls set on this Transaction update the surface
            // state
            for (const auto& surfaceControl : surfaceControls) {
   
                layer_state_t* s = getLayerState(surfaceControl);
                if (!s) {
   
                    ALOGE("failed to get layer state");
                    continue;
                }
                std::vector<CallbackId> callbacks(callbackIds.begin(), callbackIds.end());
                s->what |= layer_state_t::eHasListenerCallbacksChanged;
                s->listeners.emplace_back(IInterface::asBinder(listener), callbacks);
            }
        }
    }

    mListenerCallbacks.clear();

    cacheBuffers();

    Vector<ComposerState> composerStates;
    Vector<DisplayState> displayStates;
    uint32_t flags = 0;

    mForceSynchronous |= synchronous;

    for (auto const& kv : mComposerStates){
   
        composerStates.add(kv.second);
    }

    mComposerStates.clear();

    displayStates = mDisplayStates;
    mDisplayStates.clear();

    if (mForceSynchronous) {
   
        flags |= ISurfaceComposer::eSynchronous;
    }
    if (mAnimation) {
   
        flags |= ISurfaceComposer::eAnimation;
    }
    if (mEarlyWakeup) {
   
        flags |= ISurfaceComposer::eEarlyWakeup;
    }

    // If both mExplicitEarlyWakeupStart and mExplicitEarlyWakeupEnd are set
    // it is equivalent for none