Android13实时刷新频率的实现代码(完整代码)

public class showrefreshratepreferencecontroller extends developeroptionspreferencecontroller
        implements preference.onpreferencechangelistener, preferencecontrollermixin {
    ......
    private static final int setting_value_query = 2;
    private static final int setting_value_on = 1;
    private static final int setting_value_off = 0;
    @visiblefortesting
    static final string surface_flinger_service_key = "surfaceflinger";
    @visiblefortesting
    static final int surface_flinger_code = 1034;
    private static final string surface_composer_interface_key = "android.ui.isurfacecomposer";
    private final ibinder msurfaceflinger;
    ......
    @override
    public boolean onpreferencechange(preference preference, object newvalue) {
        final boolean isenabled = (boolean) newvalue;
        writeshowrefreshratesetting(isenabled);
        return true;
    }
    @override
    public void updatestate(preference preference) {
        updateshowrefreshratesetting();
    }
    ......
    @visiblefortesting
    void updateshowrefreshratesetting() {
        // magic communication with surface flinger.
        try {
            if (msurfaceflinger != null) {
                final parcel data = parcel.obtain();
                final parcel reply = parcel.obtain();
                data.writeinterfacetoken(surface_composer_interface_key);
                data.writeint(setting_value_query);
                msurfaceflinger.transact(surface_flinger_code, data, reply, 0 /* flags */); // 调用 surfaceflinger::ontransact 中 1034 方法
                final boolean enabled = reply.readboolean();    // 通过 surfaceflinger 获取 mrefreshrateoverlay != null判断显示是否打开
                ((switchpreference) mpreference).setchecked(enabled);
                reply.recycle();
                data.recycle();
            }
        } catch (remoteexception ex) {
            // intentional no-op
        }
    }
    @visiblefortesting
    void writeshowrefreshratesetting(boolean isenabled) {   // 设置打开显示刷新频率
        try {
            if (msurfaceflinger != null) {
                final parcel data = parcel.obtain();
                data.writeinterfacetoken(surface_composer_interface_key);
                final int showrefreshrate = isenabled ? setting_value_on : setting_value_off;
                data.writeint(showrefreshrate);
                msurfaceflinger.transact(surface_flinger_code, data,
                        null /* reply */, 0 /* flags */);
                data.recycle();
            }
        } catch (remoteexception ex) {
            // intentional no-op
        }
        updateshowrefreshratesetting();
    }
}

namespace {
    ......
status_t surfaceflinger::ontransact(uint32_t code, const parcel& data, parcel* reply,
                                    uint32_t flags) {
    if (const status_t error = checktransactcodecredentials(code); error != ok) {
        return error;
    }
    status_t err = bnsurfacecomposer::ontransact(code, data, reply, flags);
    if (err == unknown_transaction || err == permission_denied) {
        check_interface(isurfacecomposer, data, reply);
        ipcthreadstate* ipc = ipcthreadstate::self();
        const int uid = ipc->getcallinguid();
        if(code == 8002) {
            reply->writeint32(mscheduler->getdfrcfps());
            return no_error;
        }
        if (cc_unlikely(uid != aid_system
                && !permissioncache::checkcallingpermission(shardwaretest))) {
            const int pid = ipc->getcallingpid();
            aloge("permission denial: "
                    "can't access surfaceflinger pid=%d, uid=%d", pid, uid);
            return permission_denied;
        }
        int n;
        switch (code) {
            ......
            case 1034: {
                auto future = mscheduler->schedule([&] {
                    switch (n = data.readint32()) {
                        case 0:
                        case 1:
                            ftl_fake_guard(mstatelock,
                                           enablerefreshrateoverlay(static_cast<bool>(n)));
                            break;
                        default: {
                            reply->writebool(
                                    ftl_fake_guard(mstatelock, isrefreshrateoverlayenabled()));
                        }
                    }
                });
                future.wait();
                return no_error;
            }
            ......
void surfaceflinger::enablerefreshrateoverlay(bool enable)
{
    for (const auto& [ignored, display] : mdisplays) {
        if (display->isinternal() && !display->isvirtual()) {
            if (enable) {
                auto fpsrange = display->refreshrateconfigs().getsupportedrefreshraterange();
                mrefreshrateoverlay = std::make_shared<refreshrateoverlay>(fpsrange, mrefreshrateoverlayspinner);
            } else {
                mrefreshrateoverlay.reset(); //disable refreshrateoverlay
            }
            display->enablerefreshrateoverlay(mrefreshrateoverlay);
        }
    }
}
            ......

refreshrateoverlay::refreshrateoverlay(fpsrange fpsrange, bool showspinner)
      : mfpsrange(fpsrange),
        mshowspinner(showspinner),
        msurfacecontrol(surfacecomposerclient::getdefault()
                                ->createsurface(string8("refreshrateoverlay"), kbufferwidth,
                                                kbufferheight, pixel_format_rgba_8888,
                                                isurfacecomposerclient::efxsurfacebufferstate)) {
    if (!msurfacecontrol) {
        aloge("%s: failed to create buffer state layer", __func__);
        return;
    }
    createtransaction(msurfacecontrol)
            .setlayer(msurfacecontrol, int32_max - 2)
            .settrustedoverlay(msurfacecontrol, true)
            .apply();
}