Layer创建流程

在SurfaceFlinger中，Layer表示一个显示图层，是surfaceflinger合成过程中最重要的基本单元，它提供了一系列属性定义了如何参与合成并与其他Layer交互，包括：

  • 位置：定义Layer出现在屏幕上的位置，包括Layer边缘、Zorder等......

  • 内容：定义Layer上的内容如何显示，包括裁剪（缩小/放大）、转置（旋转/翻转）......

  • 合成：定义Layer如何和其他Layer进行合成，包括混合模式、透明度等......

  • 优化：提供了一些非必要但可用于HWC优化合成的属性，包括visible region等......

同时，Layer具有树结构，子Layer可以继承父Layer的属性。

在之前文章中简单介绍过SurfaceControl，SurfaceControl是暴露给外部进程用于操作surfaceflinger进程中Layer的句柄，它定义了图形缓冲数据、元数据、大小等多个属性，来描述如何显示一个Layer。当实例化一个SurfaceControl时，便会存在一个对应的Layer，并且将持有这个Layer的句柄（LayerHandle），通过LayerHandle管理Layer的保留和销毁。 但需要注意的是，SurfaceControl并非跟Layer是一一对应关系，可以存在多个SurfaceControl对应一个Layer，这取决与SurfaceControl的创建方式。

SurfaceControl和Layer的创建过程表示如下：

从整个图形显示架构来看，应用进程的View内容，实际是在Surface上进行绘制，这个Surface通过BLASTBufferQueue跟SurfaceControl关联，并通过Transaction将图形数据传递给surfaceflinger中对应的Layer进行合成和显示。

同时，SurfaceControl在system_server进程Window Manager中通过WindowState管理，进入surfaceflinger后便以Layer的形式进行处理。

从Android U开始，对surfaceflinger进行了较大重构，引入了"SurfaceFlinger FrontEnd"概念，对“客户端”和本地内的流程和类进行了解偶，以提升可维护性、扩展性以及性能。

"SurfaceFlinger FrontEnd"主要包括三方面：

  • 事务处理；

  • Layer状态及生命周期管理；

  • CompositionEngine快照生成(LayerFE + LayerSnapshot)。

比如，Android U之前Layer对象即作为客户端设置数据的载体，给surfaceflinger中传递buffer，又参与到合成阶段，耦合严重，且不利于扩展。通过FrontEnd重构后，对这部分流程进行解耦，解除了Layer和LayerFE之间的继承关系：

  • Layer只负责"客户端"相关性高的任务；

  • LayerFE则参与到合成阶段，进行合成相关任务。

本篇文章将从SurfaceControl的创建开始，了解Layer的整体创建过程，以及了解一些重要类的使用。

一、相关类结构

客户端进程创建SurfaceControl时创建Layer，而Layer由surfaceflinger创建，因此Layer的创建过程是跨进程的操作，涉及到的跨进程所需要的类如下图所示：

  • SurfaceControl：SurfaceControl是暴露给外部进程用于操作surfaceflinger进程中Layer的句柄，它定义了图形缓冲数据、元数据、大小等多个属性，来描述如何显示一个Layer。

  • SurfaceComposerClient：作为surfaceflinger进程和应用进程间进行IPC交互的“中间件”，内部持有IPC服务实例，用于向SurfaceFlinger中发起交互；

  • Client：实现了gui::ISurfaceComposerClient接口的IPC类，也可以和surfaceflinger进行跨进程交互，在SurfaceComposerClient对象初始化时，由SurfaceComposerAIDL::createConnection()方法创建获取；

  • ComposerService：ISurfaceComposer的包裹类，持有ISurfaceComposer实现对象，负责和surfaceflinger进程的ISurfaceComposer接口进行IPC连接；

  • ComposerServiceAIDL：gui::ISurfaceComposer的包裹类，持有gui::ISurfaceComposer实现对象，负责和surfaceflinger进程的ISurfaceComposerAIDL接口进行IPC连接。

Layer相关类结构如下：

  • compositionengine::LayerFECompositionState：包含了合成过程中供CompositionEngine使用的所有Layer状态；

  • surfaceflinger::frontend::LayerSnapshot：继承于compositionengine.LayerFECompositionState，LayerFECompositionState引用的实际类型，用于保存合成过程中LayerFE和Layer的状态；

  • compositionengine.LayerFE：LayerFE实现的接口类；

  • LayerFE：表示一个"前端"Layer，跟Layer相对应，用于处理Layer在合成阶段的工作；

  • LayerCreationArgs：封装客户端传入的创建Layer所需的属性和其他组件；

  • Layer.State：保存Layer的状态；

  • LayerHandle：Layer句柄，用于传递给客户端，对Layer进行更新和销毁，在SurfaceFlinger中不会持有任何LayerHandle引用。

  • LayerCreatedState：持有Layer、Layer parent弱引用的一个封装类，用于在Layer创建过程中将Layer添加到对应的树结构上；

二、创建SurfaceControl实例

创建SurfaceControl实例，有三种方式：

  • 通过SurfaceControl.Builder构造类创建；

  • 通过SurfaceControl.copyFrom(SurfaceControl sc)拷贝创建；

  • SurfaceContrl实现了Parceable接口，通过SurfaceControl(Parcel in)构造方法创建，用于IPC场景；

其中第一种方式会创建新的SurfaceControl和Layer对象，后两种方式相当于在已创建SurfaceControl对象上拷贝了一份副本，内部共享同一个Layer。

2.1、SurfaceControl.Builder构造器

SurfaceControl.Builder用于创建SurfaceControl对象，如：

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

// 获得一个SurfaceControl.Builder实例，并填充属性
final SurfaceControl.Builder builder = new SurfaceControl.Builder()
        .setName("ColorFade")
        .setSecure(isSecure)
        .setCallsite("ColorFade.createSurface");

// 获得SurfaceControl实例
SurfaceControl mSurfaceControl = builder.build();

通过SurfaceControl.Builder可以为待创建的SurfaceControl设置属性，如：

// 设置SurfaceControl名称
Builder setName(@NonNull String name)
// 设置buffer大小
Builder setBufferSize(@IntRange(from = 0) int width, @IntRange(from = 0) int height) 
// 设置像素格式
Builder setFormat(@PixelFormat.Format int format)
// 设置是否是受保护内容
Builder setProtected(boolean protectedContent) 
// 设置是否是安全内容
Builder setSecure(boolean secure)
// 设置是否不透明
Builder setOpaque(boolean opaque)
// 设置初始状态是否隐藏
Builder setHidden(boolean hidden)
// 设置父容器
Builder setParent(@Nullable SurfaceControl parent)
// 设置元数据
Builder setMetadata(int key, int data)
// 设置调用地址（用于Debug）
Builder setCallsite(String callsite)
// 设置为EffectLayer
Builder setEffectLayer()
// 设置标记值
Builder setFlags(int flags, int mask)

设置完成后通过SurfaceControl.Builder.build()方法创建SurfaceControl对象：

// frameworks/base/core/java/android/view/SurfaceControl.java

public SurfaceControl build() {
    ......
    return new SurfaceControl(
            mSession, mName, mWidth, mHeight, mFormat, mFlags, mParent, mMetadata,
            mLocalOwnerView, mCallsite);
}

2.2、SurfaceControl()构造方法

SurfaceControl构造方法如下：

// frameworks/base/core/java/android/view/SurfaceControl.java
/**
* @param session  即是否需要指定SurfaceComposerClient对象，不指定使用默认SurfaceComposerClient
* @param name     Layer名称
* @param w        Layer宽
* @param h        Layer高
* @param flags    Layer标记
* @param metadata Initial metadata.
* @param callsite 调用地址，用于debug
*/
private SurfaceControl(SurfaceSession session, String name, int w, int h, int format, int flags,
        SurfaceControl parent, SparseIntArray metadata, WeakReference<View> localOwnerView,
        String callsite)
                throws OutOfResourcesException, IllegalArgumentException {
    ......
    // SurfaceControl名称
    mName = name;
    mWidth = w;     // 宽
    mHeight = h;    // 高
    mLocalOwnerView = localOwnerView;    // 持有该SurfaceControl的View弱引用，可为null
    // 将元数据map填充到metaParcel中
    Parcel metaParcel = Parcel.obtain();
    long nativeObject = 0;
    try {
        if (metadata != null && metadata.size() > 0) {
            metaParcel.writeInt(metadata.size());
            for (int i = 0; i < metadata.size(); ++i) {
                metaParcel.writeInt(metadata.keyAt(i));
                metaParcel.writeByteArray(
                        ByteBuffer.allocate(4).order(ByteOrder.nativeOrder())
                                .putInt(metadata.valueAt(i)).array());
            }
            metaParcel.setDataPosition(0);
        }
        // 进入JNI层创建对象
        nativeObject = nativeCreate(session, name, w, h, format, flags,
                parent != null ? parent.mNativeObject : 0, metaParcel);
    } finally {
        metaParcel.recycle();
    }
    if (nativeObject == 0) {
        throw new OutOfResourcesException(
                "Couldn't allocate SurfaceControl native object");
    }
    // 保存native对象地址
    assignNativeObject(nativeObject, callsite);
}

在以上方法中：

  1. 进行了部分全局变量初始化后，便调用nativeCreate()方法进入native层，创建native层对应的实例；

  2. 在native层创建完成Layer对象和native层SurfaceControl对象后，会返回SurfaceControl地址nativeObject，nativeObject将作为调用句柄，用于后续跟Layer的数据传递；

  3. 通过assignNativeObject()方法，将JVM中的Java对象和native层内存空间绑定，以便当Java层对象内存释放时，同步释放native层内存。

下面我们进入JNI中的流程。

2.2.1、执行android_view_SurfaceControl::nativeCreate()

JNI层对应nativeCreate（）方法如下：

// frameworks/base/core/jni/android_view_SurfaceControl.cpp

static jlong nativeCreate(JNIEnv* env, jclass clazz, jobject sessionObj,
        jstring nameStr, jint w, jint h, jint format, jint flags, jlong parentObject,
        jobject metadataParcel) {
    ScopedUtfChars name(env, nameStr);
    sp<SurfaceComposerClient> client;
    // 获取SurfaceComposerClient对象
    // 如果传入SurfaceSession不为空，则从SurfaceSession中获取SurfaceComposerClient
    if (sessionObj != NULL) {
        client = android_view_SurfaceSession_getClient(env, sessionObj);
    } else {
        // 否则，获取新的SurfaceComposerClient
        client = SurfaceComposerClient::getDefault();
    }
    
    SurfaceControl *parent = reinterpret_cast<SurfaceControl*>(parentObject);
    sp<SurfaceControl> surface;
    LayerMetadata metadata;
    // 解析并校验MetaData数据格式
    Parcel* parcel = parcelForJavaObject(env, metadataParcel);
    if (parcel && !parcel->objectsCount()) {
        status_t err = metadata.readFromParcel(parcel);
        if (err != NO_ERROR) {
          jniThrowException(env, "java/lang/IllegalArgumentException",
                            "Metadata parcel has wrong format");
        }
    }

    sp<IBinder> parentHandle;
    // 如果传入parent不为空，获取parent对应的handle值
    if (parent != nullptr) {
        parentHandle = parent->getHandle();
    }
    // 开始创建native SuraceControl对象
    status_t err = client->createSurfaceChecked(String8(name.c_str()), w, h, format, &surface,
                                                flags, parentHandle, std::move(metadata));
    .......
    // 引用计数+1
    surface->incStrong((void *)nativeCreate);
    // 返回surface地址
    return reinterpret_cast<jlong>(surface.get());
}

以上方法中：

  1. 根据SurfaceSession参数获得SurfaceComposerClient实例；

  2. 通过SurfaceComposerClient::createSurfaceChecked()创建native层SurfaceControl对象；

  3. 在创建完成后，返回SurfaceControl的地址给Java层。

2.2.2.1、创建SurfaceComposerClient实例

SurfaceComposerClient作为surfaceflinger进程和应用进程间进行IPC交互的“中间件”。如果创建SurfaceControl时携带有SurfaceSession，则从SurfaceSession中获取SurfaceComposerClient实例，否则通过SurfaceComposerClient::getDefault()方法以单例的方式获取实例：

// frameworks/native/libs/gui/SurfaceComposerClient.cpp

class DefaultComposerClient: public Singleton<DefaultComposerClient> {
    ......
public:
    static sp<SurfaceComposerClient> getComposerClient() {
        DefaultComposerClient& dc = DefaultComposerClient::getInstance();
        Mutex::Autolock _l(dc.mLock);
        if (dc.mClient == nullptr) {
            dc.mClient = new SurfaceComposerClient;
        }
        return dc.mClient;
    }
};
2.2.2.2、获取ISurfaceComposerClient实例

在进行SurfaceComposerClient对象创建时，会初始化它的一个全局变量SurfaceComposerClient::mClient，它是由surfaceflinger进程创建并返回的一个ISurfaceComposerClient接口对象，专门用于客户端和surfaceflinger进程间创建Layer是的IPC：

// frameworks/native/libs/gui/SurfaceComposerClient.cpp

SurfaceComposerClient::SurfaceComposerClient(const sp<ISurfaceComposerClient>& client)
      : mStatus(NO_ERROR), mClient(client) {}

void SurfaceComposerClient::onFirstRef() {
    sp<gui::ISurfaceComposer> sf(ComposerServiceAIDL::getComposerService());
    if (sf != nullptr && mStatus == NO_INIT) {
        sp<ISurfaceComposerClient> conn;
        // 从sf中创建并返回ISurfaceComposerClient
        binder::Status status = sf->createConnection(&conn);
        if (status.isOk() && conn != nullptr) {
            mClient = conn;
            mStatus = NO_ERROR;
        }
    }
}

SurfaceFlinger中对应的createConnection()方法如下：
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

binder::Status SurfaceComposerAIDL::createConnection(sp<gui::ISurfaceComposerClient>* outClient) {
    // 创建Client实例
    const sp<Client> client = sp<Client>::make(mFlinger);
    if (client->initCheck() == NO_ERROR) {
        *outClient = client;
        return binder::Status::ok();
    } else {
        ......
    }
}

2.2.2、执行SurfaceComposerClient::createSurfaceChecked()

获得SurfaceComposerClient实例后，将执行其createSurfaceChecked()方法：

// frameworks/native/libs/gui/SurfaceComposerClient.cpp

status_t SurfaceComposerClient::createSurfaceChecked(const String8& name, uint32_t w, uint32_t h,
                                                     PixelFormat format,
                                                     sp<SurfaceControl>* outSurface, int32_t flags,
                                                     const sp<IBinder>& parentHandle,
                                                     LayerMetadata metadata,
                                                     uint32_t* outTransformHint) {
    sp<SurfaceControl> sur;

    if (mStatus == NO_ERROR) {
        // 用于保存创建结果相关参数
        gui::CreateSurfaceResult result;
        // 通过Client创建Layer
        binder::Status status = mClient->createSurface(std::string(name.string()), flags,
                                                       parentHandle, std::move(metadata), &result);
        err = statusTFromBinderStatus(status);
        if (outTransformHint) {
            *outTransformHint = result.transformHint;
        }

        // 创建SurfaceControl对象
        if (err == NO_ERROR) {
            *outSurface = new SurfaceControl(this, result.handle, result.layerId,
                                             toString(result.layerName), w, h, format,
                                             result.transformHint, flags);
        }
    }
    return err;
}

以上方法中：

  1. 通过mClient->createSurface()进入surfaceflinger中创建Layer实例；

  2. 创建Native层 SurfaceControl实例；

在创建Layer时，传递了一个gui::CreateSurfaceResult变量，用于保存创建结果相关参数。surfaceflinger中完成Layer创建后，会将创建后的Layer相关属性保存在gui::CreateSurfaceResult中：

// frameworks/native/libs/gui/aidl/android/gui/CreateSurfaceResult.aidl

parcelable CreateSurfaceResult {
    IBinder handle;       // LayerHandle
    int layerId;          // Layer Id
    String layerName;     // Layer名称
    int transformHint;    // 
}

随后的native SurfaceControl对象创建时，就是通过gui::CreateSurfaceResult获得了Layer的相关数据后，建立了关联。

Layer实例的创建过程在surfaceflinger进程中，在下面单独这部分流程进行分析。这里先来看下Native层SurfaceControl的创建。

2.2.2.1、创建Native SurfaceControl实例

在Layer创建完成后，从gui::CreateSurfaceResult获得了LayerHandle、LayerId等属性，然后创建Native SurfaceControl：

// frameworks/native/libs/gui/SurfaceControl.cpp

SurfaceControl::SurfaceControl(const sp<SurfaceComposerClient>& client, const sp<IBinder>& handle,
                               int32_t layerId, const std::string& name, uint32_t w, uint32_t h,
                               PixelFormat format, uint32_t transform, uint32_t flags)
      : mClient(client),        // SurfaceComposerClient对象
        mHandle(handle),        // LayerHandle对象
        mLayerId(layerId),      // LayerId
        mName(name),            // Layer 名称
        mTransformHint(transform),  // 
        mWidth(w),              // Layer的宽
        mHeight(h),             // Layer的高 
        mFormat(format),        // Layer格式
        mCreateFlags(flags) {}  // 标记值

LayerHandle代表一个Layer的操作句柄，Layer的查找、销毁都通过LayerHandle来实现。

Native SurfaceControl创建完成后，Java层SurfaceControl将持有它的内存地址。

Java SurfaceControl、Native SurfaceControl、Layer之间的关系可表示如下图：

2.3、Native层对象内存管理

通过上面分析，Java SurfaceControl持有一个Native SurfaceControl，当Java SurfaceControl被释放或被回收后，native层对象是如何释放的呢？ ——通过NativeAllocationRegistry来完成。

NativeAllocationRegistry可以对Java层对象和Native对象进行关联，并当Java层对象在释放内存时，同步Native层完成Native层资源的释放。

完成SurfaceControl创建后，在SurfaceControl.assignNativeObject()方法中，对NativeAllocationRegistry进行注册：

// frameworks/base/core/java/android/view/SurfaceControl.java

private void assignNativeObject(long nativeObject, String callsite) {
    if (mNativeObject != 0) {
        release();
    }
    if (nativeObject != 0) {
        // 注册待回收Native Allocation对象并返回Runnable
        mFreeNativeResources =
                sRegistry.registerNativeAllocation(this, nativeObject);
    }
    // 保存native对象地址
    mNativeObject = nativeObject;
    mNativeHandle = mNativeObject != 0 ? nativeGetHandle(nativeObject) : 0;
    .....
}

mFreeNativeResources用于释放native层资源，这部分内容将在Layer销毁流程中进行分析。

三、创建Layer实例

现在进入surfaceflinger中，来看下Layer的创建过程。Client::createSurface()方法如下：

// frameworks/native/services/surfaceflinger/Client.cpp

binder::Status Client::createSurface(const std::string& name, int32_t flags,
                                     const sp<IBinder>& parent, const gui::LayerMetadata& metadata,
                                     gui::CreateSurfaceResult* outResult) {
    // 创建LayerCreationArgs对象
    LayerCreationArgs args(mFlinger.get(), sp<Client>::fromExisting(this), name.c_str(),
                           static_cast<uint32_t>(flags), std::move(metadata));
    args.parentHandle = parent;
    // 进入SF创建layer
    const status_t status = mFlinger->createLayer(args, *outResult);
    return binderStatusFromStatusT(status);
}

这个方法中，将客户端传入的所有参数封装在了LayerCreationArgs中，LayerCreationArgs用于封装客户端传入的创建Layer所需的属性和参数。

然后便调用SurfaceFlinger::createLayer()方法继续执行创建流程。

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

status_t SurfaceFlinger::createLayer(LayerCreationArgs& args, gui::CreateSurfaceResult& outResult) {

    sp<Layer> layer;
    // 根据flag确定要创建的Layer类型
    switch (args.flags & ISurfaceComposerClient::eFXSurfaceMask) {
        case ISurfaceComposerClient::eFXSurfaceBufferQueue:
        case ISurfaceComposerClient::eFXSurfaceContainer:
        case ISurfaceComposerClient::eFXSurfaceBufferState:
            args.flags |= ISurfaceComposerClient::eNoColorFill;
            FMT_FALLTHROUGH;
        case ISurfaceComposerClient::eFXSurfaceEffect: {
            // 创建Layer
            result = createBufferStateLayer(args, &outResult.handle, &layer);
            std::atomic<int32_t>* pendingBufferCounter = layer->getPendingBufferCounter();
            if (pendingBufferCounter) {
                std::string counterName = layer->getPendingBufferCounterName();
                mBufferCountTracker.add(outResult.handle->localBinder(), counterName,
                                        pendingBufferCounter);
            }
        } break;
        default:
            result = BAD_VALUE;
            break;
    }
    // 判断是否可以作为根Layer（没有Parent）
    // args.addToRoot默认为true
    // 当客户端没有申请android.permission.ACCESS_SURFACE_FLINGER权限时，将不能作为根节点Layer添加
    args.addToRoot = args.addToRoot && callingThreadHasUnscopedSurfaceFlingerAccess();
    // We can safely promote the parent layer in binder thread because we have a strong reference
    // to the layer's handle inside this scope.
    sp<Layer> parent = LayerHandle::getLayer(args.parentHandle.promote());
    if (args.parentHandle != nullptr && parent == nullptr) {
        args.addToRoot = false;
    }

    uint32_t outTransformHint;
    // 添加到列表
    result = addClientLayer(args, outResult.handle, layer, parent, &outTransformHint);

    // 填充返回结果
    outResult.transformHint = static_cast<int32_t>(outTransformHint);
    outResult.layerId = layer->sequence;
    outResult.layerName = String16(layer->getDebugName());
    return result;
    }

以上方法中：

  1. 通过createBufferStateLayer()方法创建Layer实例；

  2. 通过addClientLayer()方法将Layer添加到Layer列表中。

3.1、createBufferStateLayer()创建Layer和LayerHandle

Android U之前，Layer在创建时可以设置不同的类型：

  • BufferState Layer：带有Buffer的Layer，不设置类型时默认创建BufferLayer；

  • Contain Layer：不参与合成，仅作为Layer父容器挂其他Layer；

  • Effect Layer：用于呈现颜色、阴影效果的Layer；

从Android U开始，所有类型Layer都合并统一到Layer类中（但类型标记目前依然保留，可能会部分逐步废弃）。都通过createBufferStateLayer()方法创建：


status_t SurfaceFlinger::createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* handle,
                                                sp<Layer>* outLayer) {
    // 设置一个texture id                                            
    args.textureName = getNewTexture();
    // 创建Layer
    *outLayer = getFactory().createBufferStateLayer(args);
    // 创建LayerHandle
    *handle = (*outLayer)->getHandle();
    return NO_ERROR;
}

以上方法中，将依次完成Layer和LayerHandle的创建。

3.1.1、Layer()构造方法

Layer由surfaceflinger进程中的创建器DefaultFactory执行创建：

// frameworks/native/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp

sp<Layer> DefaultFactory::createBufferStateLayer(const LayerCreationArgs& args) {
    return sp<Layer>::make(args);
}

在Layer构造方法中，将同步创建LayerFE实例：

// frameworks/native/services/surfaceflinger/Layer.cpp

Layer::Layer(const LayerCreationArgs& args)
      : sequence(args.sequence),     // Layer序列号
        mFlinger(sp<SurfaceFlinger>::fromExisting(args.flinger)),
        mName(base::StringPrintf("%s#%d", args.name.c_str(), sequence)),
        mClientRef(args.client),
        // 窗口类型，如全屏、Freeform、多窗口...
        mWindowType(static_cast<WindowInfo::Type>(
                args.metadata.getInt32(gui::METADATA_WINDOW_TYPE, 0))),  
        // 标记位
        mLayerCreationFlags(args.flags),
        // Layer边界是否可见
        mBorderEnabled(false),
        mTextureName(args.textureName),
        // 创建LayerFE对象
        mLegacyLayerFE(args.flinger->getFactory().createLayerFE(mName)) {

    uint32_t layerFlags = 0;
    // 隐藏Layer标记
    if (args.flags & ISurfaceComposerClient::eHidden) layerFlags |= layer_state_t::eLayerHidden;
    // 不透明Layer标记
    if (args.flags & ISurfaceComposerClient::eOpaque) layerFlags |= layer_state_t::eLayerOpaque;
    // 安全Layer标记
    if (args.flags & ISurfaceComposerClient::eSecure) layerFlags |= layer_state_t::eLayerSecure;
    // 禁止截屏标记
    if (args.flags & ISurfaceComposerClient::eSkipScreenshot)
        layerFlags |= layer_state_t::eLayerSkipScreenshot;
    // 初始化mDrawingState
    mDrawingState.flags = layerFlags;      // Layer标记位
    mDrawingState.crop.makeInvalid();      // Layer的区域大小，默认(0,0,-1,-1)
    mDrawingState.z = 0;                   // Layer的Z-Order序列
    mDrawingState.color.a = 1.0f;          // Layer的颜色值（RGBA）
    mDrawingState.layerStack = ui::DEFAULT_LAYER_STACK;   // Layer所在LayerStack ID
    mDrawingState.sequence = 0;            // Layer可见区域更新时的序列号
    mDrawingState.transform.set(0, 0);     // Layer的变换对象（平移、旋转、....）
    mDrawingState.frameNumber = 0;         // Layer中Buffer的帧序列号（每更新GraphicBuffer时加1）
    mDrawingState.barrierFrameNumber = 0;  // Layer中Barrier Buffer的帧序列号（Barrier Buffer不会立即应用）
    mDrawingState.producerId = 0;          // Layer中Buffer对应的BufferQueueProducer ID
    mDrawingState.barrierProducerId = 0;   // Layer中Barrier Buffer对应的BufferQueueProducer ID
    mDrawingState.bufferTransform = 0;     // Layer中Buffer的变换对象
    mDrawingState.transformToDisplayInverse = false;     // ???
    mDrawingState.acquireFence = sp<Fence>::make(-1);    // ???
    mDrawingState.acquireFenceTime = std::make_shared<FenceTime>(mDrawingState.acquireFence);
    mDrawingState.dataspace = ui::Dataspace::V0_SRGB;    // Layer的dataspace,默认sRGB
    mDrawingState.hdrMetadata.validTypes = 0;            // Layer的hdr元数据
    mDrawingState.surfaceDamageRegion = Region::INVALID_REGION;   // Layer发生更新的区域
    mDrawingState.cornerRadius = 0.0f;                   // Layer的圆角半径
    mDrawingState.backgroundBlurRadius = 0;              // Layer的背景模糊半径
    mDrawingState.api = -1;                              // Layer中用于处理GraphicBuffer的本地窗口
    mDrawingState.hasColorTransform = false;             // ???
    mDrawingState.colorSpaceAgnostic = false;            // ??
    mDrawingState.frameRateSelectionPriority = PRIORITY_UNSET;
    mDrawingState.metadata = args.metadata;              // Layer元数据
    mDrawingState.shadowRadius = 0.f;                    // Layer阴影半径
    mDrawingState.fixedTransformHint = ui::Transform::ROT_INVALID;
    mDrawingState.frameTimelineInfo = {};                // ???
    mDrawingState.postTime = -1;                         // ???
    mDrawingState.destinationFrame.makeInvalid();        // ???
    mDrawingState.isTrustedOverlay = false;              // ???
    mDrawingState.dropInputMode = gui::DropInputMode::NONE;    // ???
    mDrawingState.dimmingEnabled = true;                 // ???
    mDrawingState.defaultFrameRateCompatibility = FrameRateCompatibility::Default;    // ???

    // ISurfaceComposerClient::eNoColorFill表示创建时不会进行color填充的flag
    if (args.flags & ISurfaceComposerClient::eNoColorFill) {
        // Set an invalid color so there is no color fill.
        mDrawingState.color.r = -1.0_hf;
        mDrawingState.color.g = -1.0_hf;
        mDrawingState.color.b = -1.0_hf;
    }

    mFrameTracker.setDisplayRefreshPeriod(
            args.flinger->mScheduler->getPacesetterVsyncPeriod().ns());

    mOwnerUid = args.ownerUid;
    mOwnerPid = args.ownerPid;
    // ISurfaceComposerClient::eNonPremultiplied表示颜色转换时，对Alpha值的特殊处理的标记
    mPremultipliedAlpha = !(args.flags & ISurfaceComposerClient::eNonPremultiplied);
    // ISurfaceComposerClient::eCursorWindow表示该Layer是一个光标layer
    mPotentialCursor = args.flags & ISurfaceComposerClient::eCursorWindow;
    // ISurfaceComposerClient::eProtectedByApp表示是否设置了在外接显式设备显示时的硬件保护路径
    mProtectedByApp = args.flags & ISurfaceComposerClient::eProtectedByApp;

    // 初始化LayerSnapshot
    mSnapshot->sequence = sequence;
    mSnapshot->name = getDebugName();
    mSnapshot->textureName = mTextureName;
    mSnapshot->premultipliedAlpha = mPremultipliedAlpha;
    mSnapshot->parentTransform = {};
}

以上方法中：

  1. 通过flinger->getFactory().createLayerFE()同步创建了LayerFE对象；

  2. 初始化mDrawingState。

3.1.1.1、创建LayerFE实例

LayerFE也由SufaceFlinger中的创建器DefaultFactory创建，其构造方法只有一个参数：

// frameworks/native/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
sp<LayerFE> DefaultFactory::createLayerFE(const std::string& layerName) {
    return sp<LayerFE>::make(layerName);
}

// frameworks/native/services/surfaceflinger/LayerFE.cpp
LayerFE::LayerFE(const std::string& name) : mName(name) {}

LayerFE作为Layer的"FrontEnd"端对象，在合成过程中，会从Layer中获取各类属性参与到合成流程中。

3.1.1.2、初始化mDrawingState

mDrawingState是Layer类中Layer.State类型全局变量，用于保存所有Layer的状态。在构造方法中，会对其进行初始化，之后的合成流程中，会根据客户端传入的参数对对应属性进行更新。

3.1.2、LayerHandle()构造方法

创建完成Layer后，通过Layer::getHandle()方法开始创建LayerHandle。LayerHandle表示一个Layer的句柄，用于传递给客户端以便对Layer进行更新或销毁，客户端持有LayerHandle引用，因此当客户端对象销毁析构后，对应的LayerHandle对象也将执行析构，并触发Layer的销毁流程。

在SurfaceFlinger进程中，不会持有任何LayerHandle的引用，否则可能会出现Layer泄漏问题。

// frameworks/native/services/surfaceflinger/Layer.cpp

sp<IBinder> Layer::getHandle() {
    Mutex::Autolock _l(mLock);
    mGetHandleCalled = true;
    mHandleAlive = true;
    return sp<LayerHandle>::make(mFlinger, sp<Layer>::fromExisting(this));
}

LayerHandle构造方法和析构方法如下：

// frameworks/native/services/surfaceflinger/FrontEnd/LayerHandle.cpp

LayerHandle::LayerHandle(const sp<android::SurfaceFlinger>& flinger,
                         const sp<android::Layer>& layer)
      : mFlinger(flinger), mLayer(layer), mLayerId(static_cast<uint32_t>(layer->getSequence())) {}

LayerHandle::~LayerHandle() {
    if (mFlinger) {
        // Layer析构时，触发SF的onHandleDestroyed()方法
        mFlinger->onHandleDestroyed(this, mLayer, mLayerId);
    }
}

3.2、SurfaceFlinger::addClientLayer()

回到SurfaceFlinger::createLayer()中，完成Layer对象创建后，下一个执行的方法是SurfaceFlinger::addClientLayer()方法：

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

status_t SurfaceFlinger::addClientLayer(LayerCreationArgs& args, const sp<IBinder>& handle,
                                        const sp<Layer>& layer, const wp<Layer>& parent,
                                        uint32_t* outTransformHint) {
    // Layer泄漏情况处理
    if (mNumLayers >= MAX_LAYERS) {                                        
         ......
         // 当超过做大Layer数时，Layer创建失败，返回NO_MEMORY
        return NO_MEMORY;
    }
    ......
    // 更新Transform hint
    layer->updateTransformHint(mActiveDisplayTransformHint);
    if (outTransformHint) {
        *outTransformHint = mActiveDisplayTransformHint;
    }
    // 获取父Layer ID, 若无则返回uint32_t类型最大值
    args.parentId = LayerHandle::getLayerId(args.parentHandle.promote());
    // 获取被镜像的Layer ID，若无则返回uint32_t类型最大值，用于镜像屏幕或Layer时
    args.layerIdToMirror = LayerHandle::getLayerId(args.mirrorLayerHandle.promote());
    {
        std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
        // 创建了LayerCreatedState并添加到mCreatedLayers列表中
        mCreatedLayers.emplace_back(layer, parent, args.addToRoot);
        // 创建RequestedLayerState并添加到列表中
        mNewLayers.emplace_back(std::make_unique<frontend::RequestedLayerState>(args));
        args.mirrorLayerHandle.clear();
        args.parentHandle.clear();
        // 将LayerCreationArgs添加到mNewLayerArgs列表中
        mNewLayerArgs.emplace_back(std::move(args));
    }
    // 设置一个eTransactionNeeded标记，发起surfaceflinger提交操作
    setTransactionFlags(eTransactionNeeded);
    return NO_ERROR;
}

以上方法中：

  1. 针对Layer泄漏场景处理，当SurfaceFlinger中Layer数已经到达最大时，创建Layer失败，直接返回NO_MEMORY。其中细节此处略去；

  2. 依次创建了LayerCreatedState、RequestedLayerState对象，并保存到了对应列表中；

  3. 通过setTransactionFlags()方法设置了eTransactionNeeded标记，发起SurfaceFlinger VSYNC新的调度。

3.2.1、创建LayerCreatedState实例

LayerCreatedState只封装了三个参数：Layer、ParentLayer的弱引用、以及addToRoot，仅仅用于创建过程中为Layer设置树结构，其定义如下：

// frameworks/native/services/surfaceflinger/FrontEnd/Update.h

struct LayerCreatedState {
    LayerCreatedState(const wp<Layer>& layer, const wp<Layer>& parent, bool addToRoot)
          : layer(layer), initialParent(parent), addToRoot(addToRoot) {}
    // 所创建Layer的弱引用
    wp<Layer> layer;
    // 所创建Layer的Parent Layer 弱引用，为空将会被添加到当前根节点Layer上
    wp<Layer> initialParent;
    // 表示所创建Layer是否作为根节点Layer添加，前提是没有提供Parent Layer且已申请
    // ACCESS_SURFACE_FLINGER权限，如果该值为false、且没有Parent，将会被添加到Offscreen列表中不参与合成 
    bool addToRoot;
};

稍后会Layer的挂靠结构进行具体说明。

3.2.2、创建RequestedLayerState实例

RequestedLayerState中也封装了所有的Layer创建参数，它在"SurfaceFlinger FrontEnd"架构引入，在Android V上采用LifeCycleManager组件时使用，目前流程中并未使用到。

3.2.3、setTransactionFlags()方法发起VSYNC调度

SurfaceFlinger::setTransactionFlags()方法用于设置各类Transaction标记，并触发SurfaceFlinger中VSYNC的调度：

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

void SurfaceFlinger::setTransactionFlags(uint32_t mask, TransactionSchedule schedule,
                                         const sp<IBinder>& applyToken, FrameHint frameHint) {
    mScheduler->modulateVsync({}, &VsyncModulator::setTransactionSchedule, schedule, applyToken);
    // 将标记添加到mTransactionFlags中
    uint32_t transactionFlags = mTransactionFlags.fetch_or(mask);

    if (const bool scheduled = transactionFlags & mask; !scheduled) {
        // 执行调度
        scheduleCommit(frameHint);
    } else if (frameHint == FrameHint::kActive) {
        mScheduler->resetIdleTimer();
    }
}

执行到这里时，整个从客户端SurfaceControl.Builder.build()方法开始后的流程就全部执行完毕。此时SurfaceControl、Layer、LayerHandle、LayerFE等对象均已创建完毕。

但此时，还没有对Layer设置在对应LayerTree上，是不会参与到后续的合成和显示的。这时客户端还需要通过Transaction.apply()方法对SurfaceControl进行事务提交，或SF中主动执行一次setTransactionFlags(eTransactionFlushNeeded)后，发起一帧刷新后对新创建Layer设置LayerTree。

以上流程都是执行在客户端线程和binder线程，之后在SurfaceFlinger中收到VSYNC信号后，在主线程进行事务提交流程时，会将Layer放置在合适的位置上。

以上流程时序图如下：

四、LayerTree的设置

在surfaceflinger中收到VSYNC信号进行事务提交过程中，如果存在待添加的Layer，便会将Layer添加到对应的LayerTree上。

这里从commit()方法开始，该方法体较大，这里仅看下其中与LayerTree设置相关流程：

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

bool SurfaceFlinger::commit(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime)
        FTL_FAKE_GUARD(kMainThreadContext) {

    ......
    
    // 是否需要进行合成
    bool mustComposite = mMustComposite.exchange(false);
    {
        ......
        // 清除eTransactionFlushNeeded标记，并返回清除标记前是否存在被清除的标记
        const bool flushTransactions = clearTransactionFlags(eTransactionFlushNeeded);
        // 初始化frontend::Update变量
        frontend::Update updates;
        if (flushTransactions) {
            // 刷新待更新状态，如事务列表、待添加的Layer、待销毁LayerHandle等
            updates = flushLifecycleUpdates();
            .......
        }
        bool transactionsAreEmpty;
        // 提交MirrorDisplay、Layer、Transaction等状态
        if (mLegacyFrontEndEnabled) {
            mustComposite |= updateLayerSnapshotsLegacy(vsyncId, updates, flushTransactions,
                                                        transactionsAreEmpty);
        }
        ......
    }
    ......
    // 返回结果决定是否执行后续合成操作
    return mustComposite && CC_LIKELY(mBootStage != BootStage::BOOTLOADER);
}

以上方法中跟添加Layer相关主要有两步：

  1. 通过flushLifecycleUpdates()刷新待添加的Layer，并放在frontend::Update中；

  2. 通过updateLayerSnapshotsLegacy()提交待添加Layer信息，完成LayerTree设置。

5.1、flushLifecycleUpdates()填充frontend::Update

frontend::Update封装了多个会影响Layer显示状态的列表，它在每一次收到VSYNC后进行填充：

// frameworks/native/services/surfaceflinger/FrontEnd/Update.h

struct Update {
    // 保存待处理事务请求
    std::vector<TransactionState> transactions;
    // 保存待处理Layer
    std::vector<LayerCreatedState> layerCreatedStates;
    std::vector<std::unique_ptr<frontend::RequestedLayerState>> newLayers;
    // 保存待处理Layer创建参数
    std::vector<LayerCreationArgs> layerCreationArgs;
    // 保存待销毁的LayerHandle
    std::vector<uint32_t> destroyedHandles;
};

通过flushLifecycleUpdates()方法将所需数据填充到frontend::Update中：

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
frontend::Update SurfaceFlinger::flushLifecycleUpdates() {
    frontend::Update update;
    
    update.transactions = mTransactionHandler.flushTransactions();
    {

        std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
        // 取出LayerCreatedState列表，填充给Update
        update.layerCreatedStates = std::move(mCreatedLayers);
        mCreatedLayers.clear();
        // 取出RequestedLayerState列表，填充给Update
        update.newLayers = std::move(mNewLayers);
        mNewLayers.clear();
        update.layerCreationArgs = std::move(mNewLayerArgs);
        mNewLayerArgs.clear();
        ......
    }
    return update;
}

mCreatedLayers等列表是在SurfaceFlinger::addClientLayer()中添加的。在这里，frontend::Update从源列表中取出数据，同时将全局列表清空，以便用于下次VSYNC后的数据填充。

5.2、updateLayerSnapshotsLegacy()更新Layer属性

完成frontend::Update填充后，接下来执行SurfaceFlinger::updateLayerSnapshotsLegacy()方法，对Transaction、Mirror Display、Layer属性等各类状态进行commit操作，包括从frontend::Update取出Layer相关状态进行提交：


bool SurfaceFlinger::updateLayerSnapshotsLegacy(VsyncId vsyncId, frontend::Update& update,
                                                bool transactionsFlushed,
                                                bool& outTransactionsAreEmpty) {
    bool needsTraversal = false;
    if (transactionsFlushed) {
        // 提交MirrorDisplay相关状态
        needsTraversal |= commitMirrorDisplays(vsyncId);
        // 提交Layer创建列表
        needsTraversal |= commitCreatedLayers(vsyncId, update.layerCreatedStates);
        // 应用Transaction列表
        needsTraversal |= applyTransactions(update.transactions, vsyncId);
    }
    outTransactionsAreEmpty = !needsTraversal;
    const bool shouldCommit = (getTransactionFlags() & ~eTransactionFlushNeeded) || needsTraversal;
    // 提交Transaction列表
    if (shouldCommit) {
        commitTransactions();
    }

    bool mustComposite = latchBuffers() || shouldCommit;
    // 计算各个Layer几何边界
    updateLayerGeometry();
    return mustComposite;
}

该方法为U新增方法，Legacy后缀说明在下个版本更新中会被移除

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

bool SurfaceFlinger::commitCreatedLayers(VsyncId vsyncId,
                                         std::vector<LayerCreatedState>& createdLayers) {
    if (createdLayers.size() == 0) {
        return false;
    }

    Mutex::Autolock _l(mStateLock);
    // 将Layer添加到LayerTree结构中
    for (const auto& createdLayer : createdLayers) {
        handleLayerCreatedLocked(createdLayer, vsyncId);
    }
    // 表示Layer添加成功
    mLayersAdded = true;
    return mLayersAdded;
}

5.2.1、commitCreatedLayers()提交Layer添加事件

这里其他流程暂时略去，直接看提交Layer创建列表：

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

bool SurfaceFlinger::commitCreatedLayers(VsyncId vsyncId,
                                         std::vector<LayerCreatedState>& createdLayers) {
    if (createdLayers.size() == 0) {
        return false;
    }

    Mutex::Autolock _l(mStateLock);
    // 将Layer添加到LayerTree结构中
    for (const auto& createdLayer : createdLayers) {
        handleLayerCreatedLocked(createdLayer, vsyncId);
    }
    // 表示Layer添加成功
    mLayersAdded = true;
    return mLayersAdded;
}

在handleLayerCreatedLocked()中，将会对Layer进行LayerTree的设置。

5.2.2、handleLayerCreatedLocked()设置LayerTree

handleLayerCreatedLocked()方法如下：

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

void SurfaceFlinger::handleLayerCreatedLocked(const LayerCreatedState& state, VsyncId vsyncId) {
    sp<Layer> layer = state.layer.promote();
    MUTEX_ALIAS(mStateLock, layer->mFlinger->mStateLock);

    sp<Layer> parent;
    // 根据addToRoot和parent据定是否作为根节点Layer
    bool addToRoot = state.addToRoot;
    // 创建过程中指定了parent但已经被销毁释放，则不能将该Layer添加到根节点中
    if (state.initialParent != nullptr) {
        parent = state.initialParent.promote();
        if (parent == nullptr) {
            addToRoot = false;
        }
    }
    // 如果没有指定父layer，则添加到
    // mCurrentState.layersSortedByZ列表中作为根节点保存
    if (parent == nullptr && addToRoot) {
        // 设置为根节点
        layer->setIsAtRoot(true);
        // 添加到列表中
        mCurrentState.layersSortedByZ.add(layer);
    } else if (parent == nullptr) {
        // 如果Parent未指定，此时该Layer无法依附，会先执行Remove操作, 添加到待移除列表中
        layer->onRemovedFromCurrentState();
    } else if (parent->isRemovedFromCurrentState()) {
        // 如果指定的Parent存在，但已移除，则先添加到Parent中，再,添加到待移除列表中
        parent->addChild(layer);
        layer->onRemovedFromCurrentState();
    } else {
        // 执行到这里说明Parent一切正常，添加到父Layer中管理
        parent->addChild(layer);
    }

    ui::LayerStack layerStack = layer->getLayerStack(LayerVector::StateSet::Current);
    sp<const DisplayDevice> hintDisplay;
    // Find the display that includes the layer.
    for (const auto& [token, display] : mDisplays) {
        if (display->getLayerStack() == layerStack) {
            hintDisplay = display;
            break;
        }
    }
    // 给Layer设置Transform Hint
    if (hintDisplay) {
        layer->updateTransformHint(hintDisplay->getTransformHint());
    }
}

以上方法中，会根据addToRoot参数和父Layer情况，将Layer添加到对应的列表中保存：

  1. 如果当前Layer在创建时没有指定父Layer，且addToRoot为true，则可将它作为根节点Layer，添加到mCurrentState.layersSortedByZ列表中作为根节点保存；

  2. 如果当前Layer指定了父Layer，但执行过程中父Layer已销毁释放，此时该Layer无依附的Layer，会先执行Remove操作，并逐步添加到待移除Layer列表mLayersPendingRemoval中；

  3. 如果当前Layer指定了父Layer，但执行过程中父Layer已被移除，此时先将Layer添加到父Layer中，然后执行移除操作，并逐步添加到待移除Layer列表mLayersPendingRemoval中；

  4. 如果不满足以上所有条件，说明Layer指定了父Layer，则将它添加为父Layer的子Layer；

通过以上逻辑可知，如果在创建Layer时，没有指定Parent Layer、且客户端已授予ACCESS_SURFACE_FLINGER权限，将会默认作为根节点添加到mCurrentState.layersSortedByZ列表中，否则会添加到Parent Layer的mCurrentChildren列表中，由Parent Layer进行管理。

Layer::onRemovedFromCurrentState()方法在Parent Layer发生变化时，对Child Layer进行添加或移除到OffscreenLayers列表中，添加在OffscreenLayers列表中的Layer不会参与到合成显示，但并未销毁。

以上流程时序图如下：

到这里，Layer创建流程基本完成，关于Layer提交、合成的更多细节会在单独文章中进行分析。

回看整个创建过程，从进程角度来看，可以分成两部分：从业务进程发起SurfaceControl的创建，到surfaceflinger进程完成Layer、LayerHandle、LayerFE对象创建及LayerTree的设置；

从线程角度来看，也可以分成两部分：从业务进程发起SurfaceControl创建，通过IPC跨进程调用surfaceflinger完成Layer、LayerHandle、LayerFE等对象创建，这部分在业务线程 + binder线程完成（SF::addClientLayer()执行结束后返回）；之后收到VSYNC信号后对创建Layer进行LayerTree的设置，在surfaceflinger主线程完成。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/601161.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

回归分析的理解

回归分析的理解

1.是什么&#xff1a; 2.回归问题的求解&#xff1a; 首先是根据之前的数据确定变量和因变量的关系根据关系去预测目标数据根据结果做出判断 2.1如何找到关系&#xff1f; y’是根据模型生成的预测结果&#xff1a; y’axb&#xff0c;而我们的目的是y’和y(正确的结果)之间…
阅读更多...
Innodb实现的索引

Innodb实现的索引

概念 一种用于提高数据库查询性能的有序的数据结构。通过使用索引&#xff0c;数据库引擎可以快速定位到存储表中的特定数据&#xff0c;而不必逐行遍历整个表。在处理大量数据的时候可以显著加快数据检索的速度。 通过索引列队数据进行排序&#xff0c;降低数据排序的成本&a…
阅读更多...
V23 中的新功能：LEADTOOLS 展示了它的 EXCEL-lence

V23 中的新功能：LEADTOOLS 展示了它的 EXCEL-lence

LEADTOOLS (Lead Technology)由Moe Daher and Rich Little创建于1990年&#xff0c;其总部设在北卡罗来纳州夏洛特。LEAD的建立是为了使Daher先生在数码图象与压缩技术领域的发明面向市场。在过去超过30年的发展历程中&#xff0c;LEAD以其在全世界主要国家中占有的市场领导地位…
阅读更多...
Verilog中4位数值比较器电路

Verilog中4位数值比较器电路

某4位数值比较器的功能表如下。 请用Verilog语言采用门级描述方式&#xff0c;实现此4位数值比较器 参考代码如下&#xff1a; &#xff08;CSDN代码块不支持Verilog&#xff0c;代码复制到notepad编辑器中&#xff0c;语言选择Verilog&#xff0c;看得更清楚&#xff09; t…
阅读更多...
CSS-伪类选择器

CSS-伪类选择器

结构伪类选择器 作用&#xff1a;根据元素的结构关系查找元素 分类&#xff1a; 选择器说明元素名:first-child查找第一个元素元素名:last-child查找最后一个元素元素名:nth-child(N)查找第N名元素 <!DOCTYPE html> <html lang"en"> <head><me…
阅读更多...
智启算力平台基本操作

智启算力平台基本操作

智启算力平台 智启算力平台路径搭载数据集搭载镜像配置 智启算力平台 开发文档 帮助文档 - OpenI - 启智AI开源社区 路径搭载 OpenIOSSG/promote: 启智AI协作平台首页推荐组织及推荐项目申请。 - notice/Other_notes/SDKGetPath.md at master - promote - OpenI - 启智AI开…
阅读更多...
加密杂谈：Base 向上，BSC 向下

加密杂谈：Base 向上，BSC 向下

Aerdrome 价格走过一轮&#xff0c;Base 一己之力扶持起巅峰 1B Mcap, 2B FDV 的百倍币&#xff0c;秀出了肌肉&#xff0c;其所带来的正外部性也进一步盘活了 Base 生态 反观 BSC 本轮哪怕靴子落地依然没个响&#xff0c;差距在哪里&#xff1f;本 Thread 将以此为切入点探讨…
阅读更多...
Shell编程规范和变量

Shell编程规范和变量

一.Shell脚本概述 Shell脚本的概念 将要执行的命令按顺序保存到一个文本文件给该文件可执行权限可结合各种Shell控制语句以完成更复杂的操作 Shell脚本应用场景 重复性操作交互性任务批量事务处理服务运行状态监控定时任务执行 Shell的作用 1&#xff09;介于系统内核与用…
阅读更多...
结合kimi chat的爬虫实战思路

结合kimi chat的爬虫实战思路

背景 想钻研一下项目组件&#xff0c;找找之后的学习方向。不能自以为是&#xff0c;所以借着网开源项目网站上公布的项目内容看一下&#xff0c;那些是我可以努力去学习的&#xff08;入门的&#xff09;。首先需要获取相关内容&#xff0c;于是爬取整理。 任务1&#xff1a…
阅读更多...
hadoop学习---基于Hive的数据仓库相关函数机制及其优化方案

hadoop学习---基于Hive的数据仓库相关函数机制及其优化方案

Hive相关函数&#xff08;部分&#xff09;&#xff1a; if函数: 作用: 用于进行逻辑判断操作 语法: if(条件, true返回信息,false返回信息) 注意: if函数支持嵌套使用 select if(aa,’bbbb’,111) fromlxw_dual; bbbb select if(1<2,100,200) fromlxw_dual; 200nvl函数:…
阅读更多...
面试笔记——工厂模式（简单工厂、工厂方法模式、抽象工厂模式）

面试笔记——工厂模式（简单工厂、工厂方法模式、抽象工厂模式）

场景需求&#xff1a;设计一个咖啡店点餐系统。 设计一个咖啡类&#xff08;Coffee&#xff09;&#xff0c;并定义其两个子类&#xff08;美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】&#xff09;&#xff1b;再设计一个咖啡店类&#xff08;CoffeeStore&#xff09…
阅读更多...
fork,execve,_exit从第一个程序到所有程序

fork,execve,_exit从第一个程序到所有程序

操作系统启动后到底做了什么 CPU Reset → Firmware → Loader → Kernel _start() → 第一个程序 /bin/init → 程序 (状态机) 执行 系统调用 操作系统会加载 “第一个程序” 寻找启动程序代码 if (!try_to_run_init_process("/sbin/init") ||!try_to_run_init_p…
阅读更多...
3D人体展示仪

3D人体展示仪

网址 https://3dbodyvisualizer.com/ 可以根据身高体重之类的在线生成人体的3D模型&#xff0c;感兴趣的可以试试
阅读更多...
（图论）最短路问题合集（包含C,C++,Java,Python,Go）

（图论）最短路问题合集（包含C,C++,Java,Python,Go）

不存在负权边&#xff1a; 1.朴素dijkstra算法 原题&#xff1a; 思路&#xff1a;&#xff08;依然是贪心的思想&#xff09; 1.初始化距离&#xff1a;dis[1]0&#xff0c;dis[i]INF&#xff08;正无穷&#xff09; 2.循环n次&#xff1a; 找到当前不在s中的dis最小的点&…
阅读更多...
three.js 效果细节提升

three.js 效果细节提升

1. three.js 效果细节提升 加载模型时&#xff0c;给模型设置接受阴影&#xff0c;反射阴影 gltfLoader.load("./model/court-transformed.glb", (gltf) > {gltf.scene.traverse(child > {if (child.isMesh) {child.castShadow true; // 设置阴影可以投射阴…
阅读更多...
c++笔记——概述运算符重载——解析运算符重载的难点

c++笔记——概述运算符重载——解析运算符重载的难点

前言:运算符重载是面向对象的一个重要的知识点。我们都知道内置类型可以进行一般的运算符的运算。但是如果是一个自定义类型&#xff0c; 这些运算符就无法使用了。那么为了解决这个问题&#xff0c; 我们的祖师爷就在c中添加了运算符重载的概念。 本篇主要通过实例的实现来讲述…
阅读更多...
【时序大模型总结】学习记录（1）

【时序大模型总结】学习记录（1）

1.TimeGPT-1 思路&#xff1a;在来自不同领域的大量数据上训练模型&#xff0c;然后对未见过的数据产生零样本的推断。 作者对TimeGPT进行了超过1000亿个数据点的训练&#xff0c;这些数据点都来自开源的时间序列数据。该数据集涵盖了广泛的领域&#xff0c;从金融、经济和天气…
阅读更多...
YOLOv8原理解析[目标检测理论篇]

YOLOv8原理解析[目标检测理论篇]

接下来是我最想要分享的内容&#xff0c;梳理了YOLOv8预测的整个流程&#xff0c;以及训练的整个流程。 关于YOLOv8的主干网络在YOLOv8网络结构介绍-CSDN博客介绍了&#xff0c;为了更好地介绍本章内容&#xff0c;还是把YOLOv8网络结构图放在这里&#xff0c;方便查看。 1.YOL…
阅读更多...
AI讲师大模型培训老师叶梓：大模型应用的方向探讨

AI讲师大模型培训老师叶梓：大模型应用的方向探讨

大模型应用的关键方向及其落地案例可以从多个角度进行探讨&#xff0c;结合最新的研究和实际应用案例&#xff0c;我们可以更全面地理解这些技术如何推动社会和经济的发展。 Agent&#xff08;数字代理&#xff09;: 方向说明:Agent方向的AI技术旨在创建能够独立执行任务、做出…
阅读更多...
对于SOMP算法的测试

对于SOMP算法的测试

刚开始只上传了SOMP算法的代码&#xff0c;并没有过多介绍。 所以本篇文章对SOMP算法用法进行一个介绍 SOMP算法代码 function [X_hat] MMV_SOMP(Y, PHI, s)% SOMP:同时正交匹配追踪 simultaneous orthogonal matching pursuit% 论文&#xff1a;J. Determe, J. Lo…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站