跨进程通信

# 跨进程通信

# 1. 概述

上层（App，WMS）通过 Android 图形系统中的事务（Transaction）机制向 Surfaceflinger 发送数据。Transaction 类是 SurfaceFlinger 中用于批量处理 Surface 状态变更的核心类，采用了事务模式设计。主要特点包括：

批量操作：将多个 Surface 操作打包成一个事务
原子性：所有操作要么全部成功，要么全部失败
延迟执行：操作先缓存，调用 apply() 时统一提交
链式调用：所有方法返回 Transaction 引用，支持链式操作

基本流程：

应用程序 → Transaction → SurfaceComposerClient → SurfaceFlinger

创建事务：应用通过 SurfaceComposerClient 创建 Transaction 对象
设置操作：通过各种 setXXX 方法设置图形属性
提交事务：调用 apply() 方法将所有操作批量提交给 SurfaceFlinger
处理事务：SurfaceFlinger 在 commit 阶段处理这些事务

# 2. Java 层操作

Transaction 有 Java 层的封装，使用方式如下：

// 创建事务
SurfaceControl.Transaction t = new SurfaceControl.Transaction();
// 设置属性（如位置、透明度、缓冲区）
t.setPosition(surfaceControl, x, y)
 .setAlpha(surfaceControl, 0.5f)
 .setBuffer(surfaceControl, buffer)
 .apply(); // 提交事务（异步）
// 或 t.commit(); // 同步提交

1
2
3
4
5
6
7
8

Java 层只是一些 JNI 封装，最终会调用到 C++ 层的 Transaction 类，不做详细分析。

# 3. C++ 层操作

C++ 层常见的使用场景如下：

基本事务创建与提交

#include <gui/SurfaceComposerClient.h>

using namespace android;

// 创建 SurfaceComposerClient
sp<SurfaceComposerClient> client = new SurfaceComposerClient();

// 创建事务对象
SurfaceComposerClient::Transaction t;
// 设置 Surface 的层级（Z-order）
t.setLayer(surfaceControl, 0x7FFFFFFF); // 设置为最高层级
// 显示 Surface
t.show(surfaceControl);
// 提交事务（异步方式）
t.apply();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

设置 Surface 属性

SurfaceComposerClient::Transaction t;
// 设置位置和大小
t.setPosition(surfaceControl, 100, 200);
t.setSize(surfaceControl, 1920, 1080);
// 设置透明度（0.0 完全透明，1.0 不透明）
t.setAlpha(surfaceControl, 0.8f);
// 设置背景颜色（RGB 颜色和透明度）
t.setBackgroundColor(surfaceControl, half3{1.0, 0.0, 0.0}, 1.0f, ui::Dataspace::SRGB);
// 提交事务
t.apply();

1
2
3
4
5
6
7
8
9
10

缓冲区管理

#include <gui/BufferQueue.h>
#include <ui/GraphicBuffer.h>

// 创建 GraphicBuffer
sp<GraphicBuffer> buffer = new GraphicBuffer(
    1920, 1080, HAL_PIXEL_FORMAT_RGBA_8888,
    GraphicBuffer::USAGE_HW_RENDER | GraphicBuffer::USAGE_HW_TEXTURE
);

// 锁定并写入缓冲区数据（此处省略具体渲染逻辑）
void* data;
buffer->lock(GraphicBuffer::USAGE_SW_WRITE_OFTEN, &data);
// ... 渲染操作 ...
buffer->unlock();

// 在事务中设置缓冲区
SurfaceComposerClient::Transaction t;
t.setBuffer(surfaceControl, buffer);
// 设置释放回调（避免缓冲区泄漏）
t.setBuffer(surfaceControl, buffer, nullptr, [](void* /*data*/, const sp<Fence>& /*fence*/) {
    // 缓冲区被 SurfaceFlinger 释放后可在此回调中执行清理操作
});
// 提交事务
t.apply();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

复杂事务（批量操作与同步）

// 创建多个 SurfaceControl
sp<SurfaceControl> surface1 = client->createSurface(...);
sp<SurfaceControl> surface2 = client->createSurface(...);

SurfaceComposerClient::Transaction t;
// 批量设置多个 Surface 的属性
t.setLayer(surface1, 1000)
 .setAlpha(surface1, 0.5f)
 .setPosition(surface1, 50, 50)
 .show(surface1);

t.setLayer(surface2, 900)
 .setAlpha(surface2, 1.0f)
 .setPosition(surface2, 150, 150)
 .hide(surface2); // 隐藏 surface2

// 设置期望的显示时间（与 VSync 同步）
int64_t desiredPresentTime = systemTime() + ms2ns(16); // 下一帧时间附近
t.setDesiredPresentTime(desiredPresentTime);

// 同步提交（等待事务处理完成）
t.commit(true); // 参数 true 表示同步提交

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

设置刷新率

#include <gui/SurfaceComposerClient.h>
#include <ui/DisplayMode.h>

using namespace android;

// 假设已获得有效的 SurfaceControl 指针（如通过创建 Surface 或获取现有 Surface）
sp<SurfaceControl> surfaceControl = ...; 

// 1. 获取当前显示的模式和支持的刷新率
sp<IBinder> display = SurfaceComposerClient::getInternalDisplayToken();
if (display == nullptr) {
    // 处理错误：无法获取显示令牌
    return;
}

Vector<DisplayMode> modes;
status_t err = SurfaceComposerClient::getDisplaySupportedModes(display, &modes);
if (err != NO_ERROR) {
    // 处理错误：无法获取显示模式
    return;
}

// 遍历并选择目标刷新率（例如 60Hz 或 120Hz）
float targetFrameRate = 60.0f; // 目标帧率
bool rateSupported = false;
for (const DisplayMode& mode : modes) {
    if (fabs(mode.peakRefreshRate - targetFrameRate) < 1.0f) {
        rateSupported = true;
        break;
    }
}
if (!rateSupported) {
    // 设备不支持目标刷新率，可选择默认处理或日志警告
    targetFrameRate = 0.0f; // 0 表示接受系统决策
}

// 2. 创建事务并设置帧率
SurfaceComposerClient::Transaction t;
t.setFrameRate(
    surfaceControl, 
    targetFrameRate, 
    ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_DEFAULT, // 兼容性模式
    ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS // 变更策略
);

// 3. 提交事务
t.apply(); // 异步应用
// 或 t.commit(true); // 同步提交（需谨慎使用，可能阻塞）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

# 4. TransactionState 结构分析

TransactionState 是 Transaction 中的核心成员：

    // frameworks/native/include/gui/SurfaceComposerClient.h
    class Transaction {
    private:
        static sp<IBinder> sApplyToken;
        static std::mutex sApplyTokenMutex;
        void releaseBufferIfOverwriting(const layer_state_t& state);
        // Tracks registered callbacks
        sp<TransactionCompletedListener> mTransactionCompletedListener = nullptr;

        TransactionState mState;

        int mStatus = NO_ERROR;

        // .......
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

本节对 TransactionState 的功能结构进行分析。

源码路径：

frameworks/native/include/gui/TransactionState.h
frameworks/native/libs/gui/TransactionState.cpp

1
2

# 4.1 类的整体作用

TransactionState 是 Android 图形系统中的事务状态容器类，主要用于：

封装事务数据：存储客户端提交的所有图形操作请求
跨进程传输：支持 Parcel 序列化，用于 Binder 通信
状态管理：管理 Layer 和 Display 的状态变化
批量操作：将多个图形操作打包成一个原子事务

# 4.2 核心成员变量分析

# 4.2.1 事务标识和元数据

uint64_t mId = 0;                               // 事务唯一标识符
std::vector<uint64_t> mMergedTransactionIds;    // 合并的事务 ID 列表
uint32_t mFlags = 0;                            // 事务标志位

1
2
3

mId ：每次应用事务时更新，用于跟踪和调试
mMergedTransactionIds ：记录被合并的事务历史（最多 10 个）
mFlags ：控制事务行为（如早期唤醒、单向调用等）

mFlags 字段使用的是 ISurfaceComposer 中定义的标志位：

enum {
    eAnimation = 0x02,           // 0000 0010
    eEarlyWakeupStart = 0x08,    // 0000 1000  
    eEarlyWakeupEnd = 0x10,      // 0001 0000
    eOneWay = 0x20               // 0010 0000
};

1
2
3
4
5
6

eAnimation (0x02)：标识这是一个动画事务
- 告知 SurfaceFlinger 这个事务是动画的一部分
- 可能触发特殊的调度策略和性能优化
- 用于动画性能分析和统计
eEarlyWakeupStart (0x08)：开始早期唤醒模式
- 目的：避免错过帧截止时间
- 机制：SurfaceFlinger 会在 (sf vsync offset - debug.sf.early_phase_offset_ns) 时提前唤醒
- 使用场景：当预期有大量 Layer 需要合成时使用
- 权限要求：需要 android.permission.WAKEUP_SURFACE_FLINGER 权限
- 使用者：主要由 WindowManager 使用
eEarlyWakeupEnd (0x10)：结束早期唤醒模式
- 与 eEarlyWakeupStart 配对使用
- 告知 SurfaceFlinger 可以恢复正常的唤醒时机
- 同样需要特殊权限
- 同样需要特殊权限
eOneWay (0x20)：单向调用标志
- 表示这是一个单向 Binder 调用
- 调用者不等待返回结果
- 提高调用性能，减少阻塞时间

# 4.2.2 时间线信息

gui::FrameTimelineInfo mFrameTimelineInfo;  // 帧时间线信息
int64_t mDesiredPresentTime = 0;            // 期望呈现时间
bool mIsAutoTimestamp = true;               // 是否自动时间戳

1
2
3

mFrameTimelineInfo ：包含 VSync ID 和输入事件 ID
mDesiredPresentTime ：客户端期望的呈现时间（纳秒）
mIsAutoTimestamp ：如果为 true，使用 setBuffer 调用时间

gui::FrameTimelineInfo 的结构与作用:

parcelable FrameTimelineInfo {
    const long INVALID_VSYNC_ID = -1;
    
    long vsyncId = INVALID_VSYNC_ID;              // VSync ID
    int inputEventId = 0;                         // 输入事件 ID
    long startTimeNanos = 0;                      // 开始渲染时间
    boolean useForRefreshRateSelection = false;   // 是否用于刷新率选择
    long skippedFrameVsyncId = INVALID_VSYNC_ID;  // 跳过帧的 VSync ID
    long skippedFrameStartTimeNanos = 0;          // 跳过帧的开始时间
}

1
2
3
4
5
6
7
8
9
10

# 4.2.3 应用令牌和缓存控制

sp<IBinder> mApplyToken;                    // 应用令牌
bool mMayContainBuffer = false;             // 可能包含缓冲区标志
bool mLogCallPoints = false;                // 调试日志标志

1
2
3

mApplyToken ：用于事务排队，如果为空则使用进程通用令牌
mMayContainBuffer ：提示事务可能包含需要缓存的缓冲区
mLogCallPoints ：启用调试日志输出

# 4.2.4 状态变化集合

std::vector<DisplayState> mDisplayStates;   // 显示器状态变化
std::vector<ComposerState> mComposerStates; // 合成器状态变化

1
2

DisplayState 结构：

struct DisplayState {
    enum : uint32_t {
        eSurfaceChanged = 0x01,           // Surface 变化
        eLayerStackChanged = 0x02,        // Layer 栈变化
        eDisplayProjectionChanged = 0x04, // 显示投影变化
        eDisplaySizeChanged = 0x08,       // 显示尺寸变化
        eFlagsChanged = 0x10,             // 标志变化
    };
    
    uint32_t what = 0;                    // 变化类型
    sp<IBinder> token;                    // 显示器令牌
    ui::LayerStack layerStack;            // Layer 栈
    ui::Rotation orientation;             // 旋转方向
    Rect layerStackSpaceRect;             // Layer 栈空间矩形
    Rect orientedDisplaySpaceRect;        // 定向显示空间矩形
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

ComposerState 结构：

class ComposerState {
public:
    layer_state_t state;                  // Layer 状态
};

1
2
3
4

# 2.2.5 输入和回调管理

InputWindowCommands mInputWindowCommands;               // 输入窗口命令
std::vector<client_cache_t> mUncacheBuffers;            // 需要取消缓存的缓冲区
bool mHasListenerCallbacks = false;                     // 是否有监听器回调
std::vector<ListenerCallbacks> mListenerCallbacks;      // 监听器回调列表

1
2
3
4

InputWindowCommands 结构：

struct InputWindowCommands {
    std::vector<gui::FocusRequest> focusRequests;              // 焦点请求
    std::unordered_set<sp<Listener>, SpHash<Listener>> windowInfosReportedListeners; // 窗口信息监听器
    
    void addFocusRequest(const gui::FocusRequest& request);
    void addWindowInfosReportedListener(const sp<Listener>& listener);
};

1
2
3
4
5
6
7

# 4.3 核心方法功能

# 4.3.1 状态管理方法

layer_state_t* getLayerState(const sp<SurfaceControl>& sc);  // 获取 Layer 状态
DisplayState& getDisplayState(const sp<IBinder>& token);     // 获取显示器状态

1
2

# 4.3.2 事务合并

void merge(TransactionState&& other, 
           const std::function<void(layer_state_t&)>& onBufferOverwrite);

1
2

将另一个事务状态合并到当前事务中，处理缓冲区覆盖情况

# 4.3.3 序列化支持

status_t writeToParcel(Parcel* parcel) const;  // 写入 Parcel
status_t readFromParcel(const Parcel* parcel); // 从 Parcel 读取

1
2

# 4.3.4 帧时间线合并

void mergeFrameTimelineInfo(const FrameTimelineInfo& other);

合并帧时间线信息

# 4.4 layer_state_t 的结构与作用

layer_state_t 是 Android 图形系统中描述单个 Layer 状态变化的核心数据结构，用于：

状态描述：完整描述一个 Layer 的所有可变属性
变化跟踪：通过 what 字段精确标识哪些属性发生了变化
跨进程传输：支持 Parcel 序列化，用于客户端到 SurfaceFlinger 的通信
批量更新：将多个属性变化打包成一个原子操作

核心字段分析:

基本标识

sp<IBinder> surface;        // Surface 的 Binder 令牌
int32_t layerId;           // Layer ID
uint64_t what;             // 变化标志位（核心字段）

1
2
3

几何属性

float x, y;                // 位置坐标
int32_t z;                 // Z 轴层级
matrix22_t matrix;         // 2x2 变换矩阵
FloatRect crop;            // 裁剪区域
Rect destinationFrame;     // 目标帧区域

1
2
3
4
5

视觉属性

half4 color;               // 颜色值
float cornerRadius;        // 圆角半径
float clientDrawnCornerRadius; // 客户端绘制的圆角半径
uint32_t backgroundBlurRadius; // 背景模糊半径
float shadowRadius;        // 阴影半径

1
2
3
4
5

缓冲区相关

std::shared_ptr<BufferData> bufferData = nullptr; // 缓冲区数据
uint32_t bufferTransform;                         // 缓冲区变换
Rect bufferCrop;                                  // 缓冲区裁剪
ui::Dataspace dataspace;                          // 数据空间

1
2
3
4

显示属性

ui::LayerStack layerStack;     // Layer 栈
uint32_t flags;               // Layer 标志
uint32_t mask;                // 标志掩码
bool transformToDisplayInverse; // 显示逆变换

1
2
3
4

变化标志位 (what 字段)

// 基础变化标志
enum {
    ePositionChanged = 0x00000001,              // 位置变化
    eLayerChanged = 0x00000002,                 // Layer 层级变化
    eTrustedPresentationInfoChanged = 0x00000004, // 可信呈现信息变化
    eAlphaChanged = 0x00000008,                 // 透明度变化
    eMatrixChanged = 0x00000010,                // 变换矩阵变化
    eTransparentRegionChanged = 0x00000020,     // 透明区域变化
    eFlagsChanged = 0x00000040,                 // 标志变化
    eLayerStackChanged = 0x00000080,            // Layer 栈变化
    // ... 更多标志位
};

// 层级变化
static constexpr uint64_t HIERARCHY_CHANGES = 
    eLayerChanged | eRelativeLayerChanged | eReparent | eLayerStackChanged;

// 几何变化  
static constexpr uint64_t GEOMETRY_CHANGES = 
    eBufferCropChanged | eBufferTransformChanged | eCornerRadiusChanged | 
    eClientDrawnCornerRadiusChanged | eCropChanged | eDestinationFrameChanged | 
    eMatrixChanged | ePositionChanged | eTransformToDisplayInverseChanged | 
    eTransparentRegionChanged | eEdgeExtensionChanged;

// 缓冲区变化
static constexpr uint64_t BUFFER_CHANGES = 
    eApiChanged | eBufferChanged | eBufferCropChanged | eBufferTransformChanged | 
    eDataspaceChanged | eSidebandStreamChanged | eSurfaceDamageRegionChanged;

// 内容变化
static constexpr uint64_t CONTENT_CHANGES = 
    BUFFER_CHANGES | eAlphaChanged | eAutoRefreshChanged | eBackgroundBlurRadiusChanged | 
    eBackgroundColorChanged | eBlurRegionsChanged | eColorChanged;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

Layer 标志位 (flags 字段)

enum {
    eLayerHidden = 0x01,                    // Layer 隐藏
    eLayerOpaque = 0x02,                    // Layer 不透明
    eLayerSkipScreenshot = 0x40,            // 跳过截图
    eLayerSecure = 0x80,                    // 安全 Layer
    eEnableBackpressure = 0x100,            // 启用背压
    eLayerIsDisplayDecoration = 0x200,      // 显示装饰
    eIgnoreDestinationFrame = 0x400,        // 忽略目标帧
    eLayerIsRefreshRateIndicator = 0x800,   // 刷新率指示器
    eCanOccludePresentation = 0x1000,       // 可遮挡呈现
    eRecoverableFromBufferStuffing = 0x2000, // 可从缓冲区填充恢复
    ePresentLatest = 0x4000,                // 呈现最新（MTK 特性）
};

1
2
3
4
5
6
7
8
9
10
11
12
13

特定功能字段

// 帧率控制
float frameRate;                        // 帧率
int8_t frameRateCompatibility;          // 帧率兼容性
int8_t changeFrameRateStrategy;         // 帧率变化策略
int8_t defaultFrameRateCompatibility;   // 默认帧率兼容性
int8_t frameRateCategory;               // 帧率类别

// HDR 支持
HdrMetadata hdrMetadata;                // HDR 元数据
float currentHdrSdrRatio;               // 当前 HDR/SDR 比率
float desiredHdrSdrRatio;               // 期望 HDR/SDR 比率

// 输入处理
gui::DropInputMode dropInputMode;       // 丢弃输入模式
gui::TrustedOverlay trustedOverlay;     // 可信覆盖层

// mtk 扩展
// MTK Present Latest 功能
ePresentLatest = 0x4000,

// 传音扩展
// Union Render 功能
sp<IGraphicBufferProducer> unionRenderSurface;
int32_t unionRenderMode;
int32_t unionRenderFrameSpacing;
int32_t unionRenderRotation;
// VFX 动画
VFXAnimationInfo vfxAnimInfo;
// 平滑圆角
float clientTranCornerSmoothWeight;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

← Scheduler 初始化显示疑难问题分析基础→