我来为您全面剖析Android View系统，从应用层一直追踪到Framework层和内核层。
## 1. Android View系统架构概览
```
┌─────────────────────────────────────────┐
│ Application Layer │
│ (Activity/Fragment/View) │
├─────────────────────────────────────────┤
│ Framework Layer │
│ (ViewRootImpl/WindowManager/Surface) │
├─────────────────────────────────────────┤
│ Native Layer │
│ (SurfaceFlinger/OpenGL/Skia) │
├─────────────────────────────────────────┤
│ HAL Layer │
│ (Gralloc/HWComposer) │
├─────────────────────────────────────────┤
│ Kernel Layer │
│ (Display Driver/GPU Driver) │
└─────────────────────────────────────────┘
```
## 2. View创建和显示流程
### 2.1 应用层View创建
```java
// Activity.java
public void setContentView(int layoutResID) {
getWindow().setContentView(layoutResID);
initWindowDecorActionBar();
}
// PhoneWindow.java
@Override
public void setContentView(int layoutResID) {
if (mContentParent == null) {
installDecor(); // 创建DecorView
}
// 解析布局文件
mLayoutInflater.inflate(layoutResID, mContentParent);
}
```
### 2.2 ViewRootImpl创建
```java
// WindowManagerGlobal.java
public void addView(View view, ViewGroup.LayoutParams params,
Display display, Window parentWindow) {
ViewRootImpl root;
View panelParentView = null;
synchronized (mLock) {
// 创建ViewRootImpl
root = new ViewRootImpl(view.getContext(), display);
view.setLayoutParams(wparams);
mViews.add(view);
mRoots.add(root);
mParams.add(wparams);
// 将DecorView交给ViewRootImpl
root.setView(view, wparams, panelParentView);
}
}
```
## 3. View绘制流程详解
### 3.1 绘制触发机制
```java
// ViewRootImpl.java
public void requestLayout() {
if (!mHandlingLayoutInLayoutRequest) {
checkThread();
mLayoutRequested = true;
scheduleTraversals();
}
}
void scheduleTraversals() {
if (!mTraversalScheduled) {
mTraversalScheduled = true;
mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
// 通过Choreographer调度绘制
mChoreographer.postCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
}
}
```
### 3.2 Choreographer机制
```java
// Choreographer.java
private void scheduleFrameLocked(long now) {
if (!mFrameScheduled) {
mFrameScheduled = true;
if (USE_VSYNC) {
// 请求VSYNC信号
if (isRunningOnLooperThreadLocked()) {
scheduleVsyncLocked();
} else {
Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);
msg.setAsynchronous(true);
mHandler.sendMessageAtFrontOfQueue(msg);
}
}
}
}
// Native层请求VSYNC
private void scheduleVsyncLocked() {
mDisplayEventReceiver.scheduleVsync();
}
```
### 3.3 三大绘制流程
```java
// ViewRootImpl.java
private void performTraversals() {
// 测量
if (mFirst || windowShouldResize || insetsChanged ||
viewVisibilityChanged || params != null) {
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
}
// 布局
if (didLayout) {
performLayout(lp, desiredWindowWidth, desiredWindowHeight);
}
// 绘制
if (!cancelDraw && !newSurface) {
performDraw();
}
}
```
## 4. Surface创建和管理
### 4.1 Surface创建流程
```java
// ViewRootImpl.java
private int relayoutWindow(WindowManager.LayoutParams params, int viewVisibility,
boolean insetsPending) throws RemoteException {
// 通过WindowManagerService创建Surface
int relayoutResult = mWindowSession.relayout(
mWindow, mSeq, params,
(int) (mView.getMeasuredWidth() * appScale + 0.5f),
(int) (mView.getMeasuredHeight() * appScale + 0.5f),
viewVisibility, insetsPending ? WindowManagerGlobal.RELAYOUT_INSETS_PENDING : 0,
mWinFrame, mPendingOverscanInsets, mPendingContentInsets,
mPendingVisibleInsets, mPendingStableInsets, mPendingOutsets,
mPendingBackDropFrame, mPendingConfiguration, mSurface);
return relayoutResult;
}
```
### 4.2 Native层Surface实现
```cpp
// Surface.cpp
status_t Surface::lock(ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds) {
ANativeWindowBuffer* buffer;
status_t err = dequeueBuffer(&buffer, &fenceFd);
if (err == NO_ERROR) {
sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(buffer));
err = lockBuffer(backBuffer.get());
if (err == NO_ERROR) {
// 映射图形缓冲区到用户空间
void* vaddr;
err = backBuffer->lock(GRALLOC_USAGE_SW_READ_OFTEN |
GRALLOC_USAGE_SW_WRITE_OFTEN, &vaddr);
if (err == NO_ERROR) {
outBuffer->bits = vaddr;
}
}
}
return err;
}
```
## 5. 渲染管线
### 5.1 软件渲染(CPU渲染)
```java
// View.java - Canvas绘制
private void drawBackground(Canvas canvas) {
final Drawable background = mBackground;
if (background == null) {
return;
}
// 设置边界
setBackgroundBounds();
// 使用Canvas绘制
final int scrollX = mScrollX;
final int scrollY = mScrollY;
if ((scrollX | scrollY) == 0) {
background.draw(canvas);
} else {
canvas.translate(scrollX, scrollY);
background.draw(canvas);
canvas.translate(-scrollX, -scrollY);
}
}
```
### 5.2 硬件加速渲染(GPU渲染)
```java
// ThreadedRenderer.java
void draw(View view, AttachInfo attachInfo, DrawCallbacks callbacks) {
// 更新根节点
updateRootDisplayList(view, callbacks);
// 同步渲染状态
int syncResult = nSyncAndDrawFrame(mNativeProxy, frameInfo, frameInfo.length);
}
// Native层GPU渲染
// RenderThread.cpp
void RenderThread::draw(RenderTask* task) {
CanvasContext* context = task->mContext;
EGLSurface surface = task->mSurface;
// 绑定EGL上下文
if (!eglMakeCurrent(mEglDisplay, surface, surface, mEglContext)) {
return;
}
// 执行OpenGL绘制命令
context->draw();
// 交换缓冲区
eglSwapBuffers(mEglDisplay, surface);
}
```
## 6. SurfaceFlinger合成
### 6.1 Layer管理
```cpp
// SurfaceFlinger.cpp
void SurfaceFlinger::handleMessageRefresh() {
// 准备合成
preComposition();
// 重建层列表
rebuildLayerStacks();
// 设置每层的合成状态
setUpHWComposer();
// 执行合成
doComposition();
// 提交到显示设备
postComposition();
}
```
### 6.2 HWComposer硬件合成
```cpp
// HWComposer.cpp
status_t HWComposer::prepare() {
for (size_t i = 0; i < mDisplayData.size(); i++) {
DisplayData& displayData = mDisplayData[i];
if (displayData.list) {
// 调用HAL层prepare
int err = mHwc->prepare(mHwc, mNumDisplays, mLists);
}
}
return NO_ERROR;
}
status_t HWComposer::commit() {
// 提交给硬件合成器
int err = mHwc->set(mHwc, mNumDisplays, mLists);
return err;
}
```
## 7. 内核层显示驱动
### 7.1 DRM/KMS框架
```c
// drm_framebuffer.c
int drm_mode_page_flip_ioctl(struct drm_device *dev,
void *data, struct drm_file *file_priv) {
struct drm_mode_crtc_page_flip *page_flip = data;
struct drm_crtc *crtc;
struct drm_framebuffer *fb;
// 获取CRTC
crtc = drm_crtc_find(dev, page_flip->crtc_id);
// 获取Framebuffer
fb = drm_framebuffer_lookup(dev, page_flip->fb_id);
// 执行页翻转
ret = crtc->funcs->page_flip(crtc, fb, e, page_flip->flags);
return ret;
}
```
### 7.2 GPU驱动交互
```c
// gpu_driver.c
static int gpu_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
switch (cmd) {
case DRM_IOCTL_MODE_CREATE_DUMB:
// 创建显存缓冲区
return drm_mode_create_dumb_ioctl(dev, data, file_priv);
case DRM_IOCTL_MODE_MAP_DUMB:
// 映射显存到用户空间
return drm_mode_mmap_dumb_ioctl(dev, data, file_priv);
case DRM_IOCTL_MODE_ADDFB:
// 添加Framebuffer
return drm_mode_addfb_ioctl(dev, data, file_priv);
}
}
```
## 8. 触摸事件处理
### 8.1 内核输入子系统
```c
// input_event.c
static void input_handle_event(struct input_dev *dev,
unsigned int type, unsigned int code, int value) {
switch (type) {
case EV_ABS:
// 处理触摸坐标
if (is_mt_event(code)) {
input_handle_abs_event(dev, code, value);
}
break;
}
// 同步事件
if (type == EV_SYN && code == SYN_REPORT) {
input_sync(dev);
}
}
```
### 8.2 InputDispatcher分发
```cpp
// InputDispatcher.cpp
bool InputDispatcher::dispatchMotionLocked(
nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason,
nsecs_t* nextWakeupTime) {
// 找到目标窗口
Vector<InputTarget> inputTargets;
bool conflictingPointerActions = false;
int32_t injectionResult = findTouchedWindowTargetsLocked(currentTime,
entry, inputTargets, nextWakeupTime, &conflictingPointerActions);
// 分发到目标窗口
dispatchEventLocked(currentTime, entry, inputTargets);
return true;
}
```
## 9. 性能优化要点
### 9.1 减少过度绘制
```java
// 使用ViewStub延迟加载
ViewStub stub = findViewById(R.id.stub);
View inflated = stub.inflate();
// 移除不必要的背景
getWindow().setBackgroundDrawable(null);
```
### 9.2 使用硬件加速
```java
// 开启硬件加速
setLayerType(View.LAYER_TYPE_HARDWARE, null);
// 使用RenderNode缓存复杂绘制
RenderNode renderNode = new RenderNode("myRenderNode");
Canvas canvas = renderNode.start(width, height);
// 绘制操作
renderNode.end(canvas);
```
### 9.3 优化布局层级
```xml
<!-- 使用ConstraintLayout减少层级 -->
<androidx.constraintlayout.widget.ConstraintLayout>
<!-- 扁平化布局结构 -->
</androidx.constraintlayout.widget.ConstraintLayout>
```
## 总结
Android View系统是一个复杂的多层架构系统，从应用层的View绘制，经过Framework层的Surface管理，到Native层的图形渲染，最终到达内核层的显示驱动。理解这个完整的流程对于进行性能优化和解决显示问题非常重要。
关键点：
1. **VSYNC同步机制**确保流畅的动画效果
2. **Surface双缓冲**避免画面撕裂
3. **硬件加速**提升渲染性能
4. **SurfaceFlinger**负责最终的画面合成
