Android Framework源码解析(七):BootAnimation 启动流程解析——开机动画是如何显示出来的?

service bootanim /system/bin/bootanimation    class core animation    user graphics    group graphics audio    disabled    oneshot    ioprio rt 0    task_profiles MaxPerformance

int main(){    // 提升进程调度优先级为显示级，保障动画流畅    setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_DISPLAY);    // 读取系统属性，判断是否禁用开机动画    bool noBootAnimation = bootAnimationDisabled();    ALOGI_IF(noBootAnimation,  "boot animation disabled");    if(!noBootAnimation) {        // 初始化Binder线程池，后续与SF、WMS通信依赖Binder        sp<ProcessState> proc(ProcessState::self());        ProcessState::self()->startThreadPool();        // 实例化开机动画核心类，加载/system/media/bootanimation.zip，初始化音频回调        sp<BootAnimation> boot = new BootAnimation(audioplay::createAnimationCallbacks());        // 阻塞等待SurfaceFlinger服务Binder通道可用        waitForSurfaceFlinger();        // 启动动画子线程，主线程阻塞等待播放完成        boot->run("BootAnimation", PRIORITY_DISPLAY);        ALOGV("Boot animation set up. Joining binder thread pool.");        // 动画播放结束，主线程进入Binder循环，维持进程不立即销毁        IPCThreadState::self()->joinThreadPool();    }    return 0;}

boolbootAnimationDisabled() {    char value[PROPERTY_VALUE_MAX];    // 调试属性：强制关闭动画    property_get("debug.sf.nobootanimation", value, "0");    if (atoi(value) > 0) {        return true;    }    // 静默开机属性判断    property_get("ro.boot.quiescent", value, "0");    if (atoi(value) > 0) {        // 静默开机仅在对应开关开启时才显示动画        if (!property_get_bool("ro.bootanim.quiescent.enabled", false)) {            return true;        }    }    return false;}

boot->run("BootAnimation", PRIORITY_DISPLAY);    Thread::run() → pthread_create 创建独立动画子线程        底层静态入口 _threadLoop()            第一步：BootAnimation::readyToRun()                mAssets.addDefaultAssets();                initDisplaysAndSurfaces() // 初始化多屏幕、EGL、图层Surface                返回 NO_ERROR 代表图形环境就绪            第二步：进入 do-while 循环，循环调用 threadLoop()                threadLoop()                    movie() // 加载zip动画资源                        playAnimation() // 逐帧渲染主逻辑                            每帧渲染末尾调用 checkExit() 检测退出属性

status_t BootAnimation::readyToRun() {    ATRACE_CALL();    // 注册系统资源加载路径，用于读取zip内图片、字体    mAssets.addDefaultAssets();    // 核心：初始化屏幕、EGL渲染上下文、Surface图层    return initDisplaysAndSurfaces();}

status_tBootAnimation::initDisplaysAndSurfaces(){    // 1. 通过SurfaceComposerClient获取本机所有物理屏幕ID    std::vector<PhysicalDisplayId> displayIds = SurfaceComposerClient::getPhysicalDisplayIds();    if (displayIds.empty()) {        SLOGE("Failed to get ID for any displays");        return NAME_NOT_FOUND;    }    // 多开机动画开关关闭时，只保留主屏，过滤所有外接副屏    if (!com::android::graphics::bootanimation::flags::multidisplay()) {        displayIds.erase(displayIds.begin() + 1, displayIds.end());    }    // 遍历所有有效屏幕，获取屏幕唯一Token保存    for (const auto id : displayIds) {        const auto token = SurfaceComposerClient::getPhysicalDisplayToken(id);        if (!token.isValid()) {            SLOGE("Failed to get display token for display %" PRIu64, id.value);            return NAME_NOT_FOUND;        }        mDisplays.push_back({.displayToken = token});    }    // 全局EGL初始化，创建GLES2.0渲染上下文（所有屏幕共享一套GL上下文）    mEgl = eglGetDisplay(EGL_DEFAULT_DISPLAY);    eglInitialize(mEgl, nullptr, nullptr);    EGLConfig config = getEglConfig(mEgl);    EGLint contextAttributes[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};    mEglContext = eglCreateContext(mEgl, config, nullptr, contextAttributes);    // 读取系统属性限制图层最大分辨率，防止超大折叠屏显存溢出    mMaxWidth = android::base::GetIntProperty("ro.surface_flinger.max_graphics_width", 0);    mMaxHeight = android::base::GetIntProperty("ro.surface_flinger.max_graphics_height", 0);    // 为每一块物理屏幕创建独立Surface图层与EGL渲染窗口    for (size_t displayIdx = 0; displayIdx < mDisplays.size(); displayIdx++) {        auto& display = mDisplays[displayIdx];        DisplayMode displayMode;        // 查询屏幕当前生效分辨率、刷新率        status_t error = SurfaceComposerClient::getActiveDisplayMode(display.displayToken, &displayMode);        if (error != NO_ERROR) return error;        ui::Size resolution = displayMode.resolution;        // 根据全局限制裁剪分辨率        resolution = limitSurfaceSize(resolution.width, resolution.height);        // 向SurfaceFlinger创建专属图层BootAnimation，像素格式RGB565不透明，节省显存        display.surfaceControl = session()->createSurface(                String8("BootAnimation"), resolution.width, resolution.height,                PIXEL_FORMAT_RGB_565, ISurfaceComposerClient::eOpaque);        // 将图层绑定到对应屏幕的LayerStack，输出画面至当前物理屏        configureDisplayAndLayerStack(display, ui::LayerStack::fromValue(displayIdx));        display.surface = display.surfaceControl->getSurface();        // 基于Native窗口创建EGL渲染表面，作为OpenGL绘制目标        display.eglSurface = eglCreateWindowSurface(mEgl, config, display.surface.get(), nullptr);        // 查询EGL表面实际宽高        EGLint w, h;        eglQuerySurface(mEgl, display.eglSurface, EGL_WIDTH, &w);        eglQuerySurface(mEgl, display.eglSurface, EGL_HEIGHT, &h);        // 绑定当前屏幕EGL上下文，后续GL绘制全部输出到此屏幕        if (eglMakeCurrent(mEgl, display.eglSurface, display.eglSurface, mEglContext) == EGL_FALSE) {            return NO_INIT;        }        display.initWidth = display.width = w;        display.initHeight = display.height = h;        mTargetInset = -1;        // 根据系统属性 ro.bootanim.set_orientation_<display_id> 旋转动画画面，适配平板横屏开机        rotateAwayFromNaturalOrientationIfNeeded(display);        // 初始化投影矩阵，用于动画居中、缩放、旋转变换        projectSceneToWindow(display);    }    // 注册屏幕热插拔、分辨率变化监听，动态适配画面    mDisplayEventReceiver = std::make_unique<DisplayEventReceiver>();    status_t status = mDisplayEventReceiver->initCheck();    SLOGE_IF(status != NO_ERROR, "DisplayEventReceiver init failed: %d", status);    // 将事件fd注册到主线程Looper，异步接收屏幕变更    mLooper->addFd(mDisplayEventReceiver->getFd(), 0, Looper::EVENT_INPUT,                   new DisplayEventCallback(this), nullptr);    return NO_ERROR;}

bool BootAnimation::threadLoop() {    ATRACE_CALL();    bool result;    // 预编译图片渲染着色器    initShaders();    // 判断是否存在bootanimation.zip资源    if(mZipFileName.empty()) {        ALOGD("No animation zip file, render default Android logo");        // 无自定义动画，渲染原生静态Android文字Logo        result = android(mDisplays.front());    } else {        // 标准流程：加载并播放zip逐帧动画        result = movie();    }    // 动画播放完毕，统一销毁全部图形资源    mCallbacks->shutdown();    // 解绑EGL上下文    eglMakeCurrent(mEgl, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);    eglDestroyContext(mEgl, mEglContext);    // 释放所有屏幕EGL窗口与Surface图层    for(auto& display : mDisplays) {        eglDestroySurface(mEgl, display.eglSurface);        display.surface.clear();        display.surfaceControl.clear();    }    eglTerminate(mEgl);    eglReleaseThread();    // 终止Binder通信    IPCThreadState::self()->stopProcess();    return result;}

boolBootAnimation::movie(){    ATRACE_CALL();    // 解析/system/media/bootanimation.zip，加载desc.txt分段配置、所有帧图片    if (mAnimation == nullptr) {        mAnimation = loadAnimation(mZipFileName);    }    if (mAnimation == nullptr)        return false;    // 递归初始化各分段音频播放回调，处理嵌套子动画    for (const Animation::Part& part : mAnimation->parts) {        if (part.animation != nullptr) {            mCallbacks->init(part.animation->parts);        }    }    mCallbacks->init(mAnimation->parts);    // 检测动画分段是否配置右上角时钟，初始化时钟渲染参数    bool anyPartHasClock = false;    for (size_t i = 0; i < mAnimation->parts.size(); i++) {        if (validClock(mAnimation->parts[i])) {            anyPartHasClock = true;            break;        }    }    if (!anyPartHasClock) {        mClockEnabled = false;    } else {        // 读取开关属性，控制时钟是否显示        mClockEnabled = android::base::GetBoolProperty(CLOCK_ENABLED_PROP, false);    }    // 检测GPU是否支持非2次幂纹理，适配各类图片素材    mUseNpotTextures = false;    String8 glExtensions((constchar*)glGetString(GL_EXTENSIONS));    if (glExtensions.contains("GL_OES_texture_npot")) {        mUseNpotTextures = true;    }    // 配置全局OpenGL混合、抗锯齿基础参数    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);    glDisable(GL_DITHER);    glDisable(GL_SCISSOR_TEST);    glEnable(GL_TEXTURE_2D);    glBindTexture(GL_TEXTURE_2D, 0);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);    // 加载时钟、开机进度条字体纹理    bool clockFontOk = false;    if (mClockEnabled) {        clockFontOk = (initFont(&mClockFont, "clockfont") == NO_ERROR);        if (!clockFontOk) mClockEnabled = false;    }    initFont(&mProgressFont, "progressfont");    // 时钟校准子线程，实时更新系统时间用于渲染    if (mClockEnabled && !mTimeIsAccurate) {        mTimeCheckThread = new TimeCheckThread(this);        mTimeCheckThread->run("BootAnimTime", PRIORITY_LOW);    }    // 初始化动态主题渐变着色器    if (mAnimation->dynamicColoringEnabled) {        initDynamicColorShaders();    }    // 核心：阻塞播放完整动画，逐帧渲染逻辑    playAnimation(*mAnimation);    // 动画播放完成，回收时钟校准子线程    if (mTimeCheckThread != nullptr) {        mTimeCheckThread->requestExit();        mTimeCheckThread->join();        mTimeCheckThread = nullptr;    }    // 释放时钟纹理显存    if (clockFontOk) {        glDeleteTextures(1, &mClockFont.textureId);    }    glDeleteTextures(1, &mProgressFont.textureId);    // 释放全部动画帧资源    releaseAnimation(mAnimation);    mAnimation = nullptr;    return false;}

boolBootAnimation::playAnimation(const Animation& animation){    ATRACE_CALL();    const size_t totalParts = animation.parts.size();    // 计算单帧标准间隔（纳秒），锁定动画FPS    nsecs_t frameIntervalNs = s2ns(1) / animation.fps;    SLOGD("%sAnimationShownTiming start time: %" PRId64 "ms",          mShuttingDown ? "Shutdown" : "Boot", elapsedRealtime());    int fadeFrameCount = 0; // 关机淡出帧计数    int lastProgress = 0;  // 开机进度条缓存值    int colorTransStart = animation.colorTransitionStart;    int colorTransEnd = animation.colorTransitionEnd;    // 第一层循环：遍历desc.txt定义的所有动画分段Part    for (size_t partIdx = 0; partIdx < totalParts; partIdx++) {        const Animation::Part& part = animation.parts[partIdx];        const size_t frameCountInPart = part.frames.size();        glBindTexture(GL_TEXTURE_2D, 0);        // 支持嵌套子zip动画，递归播放        if (part.animation != nullptr) {            playAnimation(*part.animation);            if (exitPending()) break;            continue;        }        // 第二层循环：控制分段循环次数（无限循环/指定次数/淡出收尾）        for (int loopIdx = 0;             part.loopCount == 0 || loopIdx < part.loopCount || fadeFrameCount > 0;             loopIdx++) {            // 检测是否需要终止当前分段            if (shouldStopPart(part, fadeFrameCount, lastProgress)) break;            // 动态主题属性延迟加载重试逻辑            if (animation.dynamicColoringEnabled && !mDynamicColorLoaded                && (part.useDynamicColor || part.postDynamicColor)) {                SLOGD("Reload dynamic color system props");                loadDynamicColors();                if (mDynamicColorLoaded) {                    int transLen = colorTransEnd - colorTransStart;                    if (part.postDynamicColor) {                        colorTransStart = 0;                        colorTransEnd = std::min(transLen, (int)frameCountInPart - 1);                    }                }            }            // 触发当前分段配套音频播放            mCallbacks->playPart(partIdx, part, loopIdx);            // 设置分段背景清屏色            glClearColor(part.bgColor[0], part.bgColor[1], part.bgColor[2], 1.0f);            bool drawProgressBar = animation.progressEnabled                    && partIdx == totalParts - 1                    && android::base::GetIntProperty(PROGRESS_PROP, 0) != 0;            // 第三层循环：遍历当前分段内所有图片帧            for (size_t frameIdx = 0; frameIdx < frameCountInPart; frameIdx++) {                if (shouldStopPart(part, fadeFrameCount, lastProgress)) break;                // 计算动态主题渐变系数 [0 ~ 1]                float colorProgress = part.useDynamicColor                    ? std::clamp(                        ((float)frameIdx - colorTransStart) / std::max(colorTransEnd - colorTransStart, 1.0f),                        0.0f, 1.0f)                    : (part.postDynamicColor ? 1.0f : 0.0f);                // 处理屏幕分辨率、热插拔事件                processDisplayEvents();                const Animation::Frame& frame = part.frames[frameIdx];                nsecs_t frameBeginTime = systemTime();                // 纹理复用逻辑：首次循环创建纹理，后续直接复用显存，避免重复解码                if (loopIdx > 0) {                    glBindTexture(GL_TEXTURE_2D, frame.textureId);                } else {                    if (part.loopCount != 1) {                        glGenTextures(1, &frame.textureId);                        glBindTexture(GL_TEXTURE_2D, frame.textureId);                    }                    int w, h;                    // 解码图片至纹理，保留原始Alpha通道不预乘                    loadTexture(frame.buffer, &w, &h, false);                }                // 收到退出信号且分段配置淡出动画，计算透明度衰减值                float fadeAlpha = 0.0f;                if (exitPending() && part.enableFadeOut) {                    fadeAlpha = (float)(++fadeFrameCount) / part.fadeTotalFrames;                    if (fadeFrameCount >= part.fadeTotalFrames) {                        fadeFrameCount = MAX_FADE_FRAME;                    }                }                // 多屏幕循环：逐屏绘制当前帧                for (const auto& display : mDisplays) {                    // 切换EGL渲染目标至当前屏幕                    eglMakeCurrent(mEgl, display.eglSurface, display.eglSurface, mEglContext);                    // 计算画面缩放比例，实现居中适配屏幕                    float scaleW = (float)display.width / display.originalWidth;                    float scaleH = (float)display.height / display.originalHeight;                    int animBaseX = (display.width - animation.width * scaleW) / 2;                    int animBaseY = (display.height - animation.height * scaleH) / 2;                    // 帧裁剪坐标缩放换算                    int cropW = frame.cropW * scaleW;                    int cropH = frame.cropH * scaleH;                    int cropX = frame.cropX * scaleW;                    int cropY = frame.cropY * scaleH;                    int drawX = animBaseX + cropX;                    // OpenGL Y轴倒置，修正绘制纵坐标                    int drawY = display.height - (animBaseY + cropY + cropH);                    // 初始化正交投影矩阵                    projectSceneToWindow(display);                    glClear(GL_COLOR_BUFFER_BIT);                    // 绑定图片着色器，传入渐变、淡出透明度参数                    glUseProgram(mImageShaderProgram);                    glUniform1i(mTexLoc, 0);                    glUniform1f(mFadeLoc, fadeAlpha);                    if (animation.dynamicColoringEnabled) {                        glUniform1f(mColorProgressLoc, colorProgress);                    }                    glEnable(GL_BLEND);                    // 绘制带纹理矩形（核心图片渲染）                    drawTexturedRect(drawX, drawY, cropW, cropH, display);                    glDisable(GL_BLEND);                    // 叠加绘制右上角时钟文字                    if (mClockEnabled && mTimeIsAccurate && validClock(part)) {                        drawClockText(mClockFont, part.clockX, part.clockY, display);                    }                    // 叠加绘制底部开机进度百分比                    if (drawProgressBar) {                        int newProgress = android::base::GetIntProperty(PROGRESS_PROP, 0);                        if (lastProgress != 100) {                            usleep(100000); // 放慢进度条刷新速度，避免跳动过快                            if (lastProgress < newProgress) lastProgress++;                        }                        drawProgressText(lastProgress, mProgressFont, TEXT_CENTER, animation.height / 3, display);                    }                    // 交换前后双缓冲，画面输出到物理屏幕                    eglSwapBuffers(mEgl, display.eglSurface);                }                // 帧间隔休眠，锁定FPS，防止动画加速播放                nsecs_t now = systemTime();                nsecs_t sleepNs = frameIntervalNs - (now - frameBeginTime);                if (sleepNs > 0) {                    struct timespec sleepSpec;                    sleepSpec.tv_sec = (now + sleepNs) / 1000000000;                    sleepSpec.tv_nsec = (now + sleepNs) % 1000000000;                    int ret;                    // 绝对单调时钟休眠，被信号中断自动重试                    do {                        ret = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &sleepSpec, nullptr);                    } while (ret == EINTR);                }                // 每帧渲染完成，检测是否收到退出指令（核心退出检测入口）                checkExit();            }            // 当前分段所有帧播放完毕，执行分段暂停pause            int pauseUs = part.pauseFrameCount * ns2us(frameIntervalNs);            while (pauseUs > 0 && !exitPending()) {                if (pauseUs > MAX_CHECK_INTERVAL_US) {                    usleep(MAX_CHECK_INTERVAL_US);                    pauseUs -= MAX_CHECK_INTERVAL_US;                } else {                    usleep(pauseUs);                    break;                }                // 休眠中途持续检测退出信号                checkExit();            }            // 收到退出信号，无限循环分段强制置进度100并跳出            if (exitPending() && part.loopCount == 0 && mCurrentInset >= mTargetInset && !part.enableFadeOut) {                if (lastProgress != 0 && lastProgress != 100) {                    android::base::SetProperty(PROGRESS_PROP, "100");                    continue;                }                break;            }        }    }    // 动画全部播放完成，批量释放循环帧纹理，释放GPU显存    for (const Animation::Part& part : animation.parts) {        if (part.loopCount != 1) {            for (const auto& frame : part.frames) {                glDeleteTextures(1, &frame.textureId);            }        }    }    SLOGD("%sAnimationShownTiming end time: %" PRId64 "ms",          mShuttingDown ? "Shutdown" : "Boot", elapsedRealtime());    return true;}

voidBootAnimation::checkExit(){    ATRACE_CALL();    char propValue[PROPERTY_VALUE_MAX];    // 读取全局退出标记属性 service.bootanim.exit    property_get("service.bootanim.exit", propValue, "0");    int exitFlag = atoi(propValue);    if (exitFlag != 0) {        // 标记线程需要退出，下一轮循环执行淡出收尾        requestExit();    }}

private class Idler implements MessageQueue.IdleHandler {    @Override    public final boolean queueIdle() {        boolean stopProfiling = false;        if (mBoundApplication != null && mProfiler.profileFd != null                && mProfiler.autoStopProfiler) {            stopProfiling = true;        }        final ActivityClient ac = ActivityClient.getInstance();        // 批量上报所有Resume完成的页面空闲状态        while (mNewActivities.size() > 0) {            final ActivityClientRecord record = mNewActivities.remove(0);            if (localLOGV) {                Slog.v(TAG, "Report idle activity " + record                        + " finished=" + (record.activity != null && record.activity.mFinished));            }            // 页面有效则跨Binder通知ATMS页面进入空闲            if (record.activity != null && !record.activity.mFinished) {                ac.activityIdle(record.token, record.createdConfig, stopProfiling);                record.createdConfig = null;            }        }        if (stopProfiling) {            mProfiler.stopProfiling();        }        // 返回false，执行一次后销毁，不重复触发        return false;    }}

public void activityIdle(IBinder token, Configuration config, boolean stopProfiling) {    try {        // 调用IActivityTaskManager Binder接口，转发至系统端ActivityClientController        getActivityTaskManager().activityIdle(token, config, stopProfiling);    } catch (RemoteException e) {        e.rethrowFromSystemServer();    }}

public void activityIdle(IBinder token, Configuration config, boolean stopProfiling) {    final long origCallingId = Binder.clearCallingIdentity();    try {        synchronized (mGlobalLock) {            Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "activityIdle");            // 根据页面Token查询服务端Activity记录            final ActivityRecord r = ActivityRecord.forTokenLocked(token);            if (r == null) return;            // 转发至任务栈调度核心处理空闲逻辑            mTaskSupervisor.activityIdleInternal(r, false, false, config);            // 按需关闭性能采样器            if (stopProfiling && r.hasProcess()) {                r.app.clearProfilerIfNeeded();            }        }    } finally {        Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);        Binder.restoreCallingIdentity(origCallingId);    }}

void activityIdleInternal(ActivityRecord r, boolean fromTimeout,        boolean processPausingActivities, Configuration config) {    // 省略页面暂停、内存回收、栈调度逻辑    // 核心判定：系统仍在开机 且 所有前台Resume页面全部空闲    if ((mService.isBooting() && mRootWindowContainer.allResumedActivitiesIdle())            || fromTimeout) {        checkFinishBootingLocked();    }    // 清除页面重启标记    r.mRelaunchReason = RELAUNCH_REASON_NONE;}private void checkFinishBootingLocked() {    boolean isBooting = mService.isBooting();    boolean enableScreen = false;    mService.setBooting(false);    // 首次完整开机，标记开机完成    if (!mService.isBooted()) {        mService.setBooted(true);        enableScreen = true;    }    if (isBooting || enableScreen) {        // 投递开机收尾任务至ATMS主线程Handler        mService.postFinishBooting(isBooting, enableScreen);    }}

void postFinishBooting(boolean finishBooting, boolean enableScreen) {    mH.post(() -> {        if (finishBooting) {            // 通知AMS完成开机，发送BOOT_COMPLETED广播、调度后台进程            mAmInternal.finishBooting();        }        if (enableScreen) {            // 联动WMS执行屏幕启用、关闭开机动画            mInternal.enableScreenAfterBoot(isBooted());        }    });}public void enableScreenAfterBoot(boolean booted) {    writeBootProgressEnableScreen(SystemClock.uptimeMillis());    // 调用WindowManagerService核心方法    mWindowManager.enableScreenAfterBoot();    synchronized (mGlobalLock) {        updateEventDispatchingLocked(booted);    }}

publicvoidenableScreenAfterBoot() {    synchronized (mGlobalLock) {        if (mSystemBooted) return;        mSystemBooted = true;        hideBootMessagesLocked();        mPolicy.systemBooted();        // 执行关闭开机动画核心逻辑        performEnableScreen();    }}privatevoidperformEnableScreen() {    synchronized (mGlobalLock) {        // 省略屏幕亮度、输入设备初始化代码        if (!mBootAnimationStopped) {            // 核心：写入系统属性，通知BootAnimation退出            SystemProperties.set("service.bootanim.exit", "1");            mBootAnimationStopped = true;        }    }}

public static void set(@NonNullString key, @NullableString val) {    if (val != null && !key.startsWith("ro.") &&            val.getBytes(StandardCharsets.UTF_8).length > PROP_VALUE_MAX) {        throw new IllegalArgumentException("Property value too long");    }    if (TRACK_KEY_ACCESS) onKeyAccess(key);    // 调用native底层方法    native_set(key, val);}

voidSystemProperties_set(JNIEnv *env, jobject clazz, jstring keyJ, jstring valJ){    ScopedUtfChars key(env, keyJ);    if (!key.c_str()) return;    std::optional<ScopedUtfChars> value;    if (valJ != nullptr) {        value.emplace(env, valJ);        if (!value->c_str()) return;    }    const char* valueStr = value ? value->c_str() : "";    errno = 0;    // 调用bionic库底层属性设置函数    bool success = !__system_property_set(key.c_str(), valueStr);    if (!success) {        if (errno != 0) {            jniThrowExceptionFmt(env, "java/lang/RuntimeException",                    "set prop %s=%s failed: %m", key.c_str(), valueStr);        } else {            jniThrowExceptionFmt(env, "java/lang/RuntimeException",                    "set prop %s=%s failed, check logcat", key.c_str(), valueStr);        }    }}