A partir de 27 de março de 2025, recomendamos usar android-latest-release
em vez de aosp-main
para criar e contribuir com o AOSP. Para mais informações, consulte Mudanças no AOSP.
Arquitetura gráfica
Mantenha tudo organizado com as coleções
Salve e categorize o conteúdo com base nas suas preferências.
O que todo desenvolvedor precisa saber sobre superfícies, SurfaceHolder,
EGLSurface, SurfaceView, GLSurfaceView, SurfaceTexture, TextureView,
SurfaceFlinger e Vulkan.
Esta página descreve os elementos essenciais da arquitetura de gráficos
do sistema Android e como eles são usados pelo framework do app e pelo sistema
multimídia. O foco é em como os buffers de dados gráficos se movem pelo sistema.
Se você já se perguntou por que a SurfaceView e a TextureView se comportam dessa maneira
ou como as superfícies e a EGLSurface interagem, você está no lugar certo.
É necessário ter algum conhecimento sobre dispositivos Android e desenvolvimento de apps.
Você não precisa de conhecimento detalhado do framework do app, e poucas chamadas de API
são mencionadas, mas o material não se sobrepõe a outras documentações
públicas. O objetivo é fornecer detalhes sobre os eventos importantes
envolvidos na renderização de um frame para saída e ajudar você a fazer escolhas informadas
ao projetar um app. Para isso, trabalhamos de baixo para cima,
descrevendo como as classes da interface funcionam, e não como elas podem ser usadas.
Esta seção inclui várias páginas que abrangem tudo, desde material
de segundo plano até detalhes de HAL e casos de uso. Ele começa com uma explicação dos buffers
gráficos do Android, descreve o mecanismo de composição e exibição e, em seguida, passa
para os mecanismos de nível mais alto que fornecem dados ao compositor. Recomendamos
ler as páginas na ordem listada abaixo em vez de pular para um
tópico que pareça interessante.
Componentes de baixo nível
- BufferQueue e
gralloc. A BufferQueue conecta algo que gera buffers de dados
gráficos (o produtor) a algo que aceita os dados para exibição ou
processamento adicional (o consumidor). As alocações de buffer são realizadas
pelo alocador de memória gralloc implementado por uma
interface HAL específica do fornecedor.
- SurfaceFlinger,
Hardware Composer e telas virtuais. O SurfaceFlinger aceita buffers de
dados de várias fontes, os compõe e os envia para a tela. O
HAL do compositor de hardware (HWC) determina a maneira mais eficiente de compor
buffers com o hardware disponível, e as telas virtuais disponibilizam a saída composta
no sistema (gravando a tela ou enviando-a por uma
rede).
- Surface, canvas e
SurfaceHolder. Uma superfície produz uma fila de buffer que geralmente é consumida pelo
SurfaceFlinger. Ao renderizar em uma superfície, o resultado acaba em um buffer
que é enviado ao consumidor. As APIs Canvas oferecem uma implementação de software
(com suporte à aceleração de hardware) para desenhar diretamente em uma superfície
(alternativa de baixo nível ao OpenGL ES). Qualquer coisa que tenha a ver com uma visualização envolve
um SurfaceHolder, cujas APIs permitem receber e definir parâmetros de superfície, como
tamanho e formato.
- EGLSurface e
OpenGL ES. O OpenGL ES (GLES)
define uma API de renderização gráfica projetada para ser
combinada com o EGL, uma biblioteca que
pode criar e acessar janelas pelo
sistema operacional. Para desenhar polígonos com textura, use chamadas GLES. Para colocar
a renderização na tela, use chamadas EGL. Esta página também aborda ANativeWindow,
o equivalente em C/C++ da classe Java Surface usada para criar uma superfície de janela
EGL a partir do código nativo.
- Vulkan. O Vulkan é
uma API multiplataforma de baixa sobrecarga para gráficos 3D de alto desempenho. Assim como o OpenGL
ES, o Vulkan oferece ferramentas para criar gráficos de alta qualidade em tempo real em
apps. As vantagens do Vulkan incluem reduções na sobrecarga da CPU e suporte
à linguagem SPIR-V Binary Intermediate
(link em inglês).
Componentes de alto nível
- SurfaceView e
GLSurfaceView. O SurfaceView combina uma superfície e uma visualização. Os componentes de visualização
da SurfaceView são compostos pelo SurfaceFlinger (e não pelo app), permitindo
a renderização de uma linha de execução/processo separada e o isolamento da renderização da interface do app.
A GLSurfaceView fornece classes auxiliares para gerenciar contextos EGL, comunicação
intercorrente e interação com o ciclo de vida da atividade (mas não é necessário
usar GLES).
- SurfaceTexture.
A SurfaceTexture combina uma superfície e uma textura GLES para criar uma BufferQueue
para a qual o app é o consumidor. Quando um produtor enfileira um novo buffer, ele notificará
seu app, que por sua vez libera o buffer mantido anteriormente, adquire o novo
buffer da fila e faz chamadas EGL para disponibilizar o buffer para o GLES
como uma textura externa. O Android 7.0 adicionou suporte à reprodução de vídeo de textura
seguro, permitindo o pós-processamento de conteúdo de vídeo protegido pela GPU.
- TextureView.
A TextureView combina uma visualização com uma SurfaceTexture. O TextureView envolve uma
SurfaceTexture e assume a responsabilidade de responder a callbacks e
adquirir novos buffers. Ao renderizar, a TextureView usa o conteúdo do buffer mais
recentemente recebido como fonte de dados, renderizando onde e como o
estado da visualização indica. A composição de visualização é sempre realizada com GLES,
o que significa que as atualizações de conteúdo podem fazer com que outros elementos de visualização sejam renderizados também.
O conteúdo e os exemplos de código nesta página estão sujeitos às licenças descritas na Licença de conteúdo. Java e OpenJDK são marcas registradas da Oracle e/ou suas afiliadas.
Última atualização 2025-07-27 UTC.
[null,null,["Última atualização 2025-07-27 UTC."],[],[],null,["# Graphics architecture\n\n*What every developer should know about surfaces, SurfaceHolder,\nEGLSurface, SurfaceView, GLSurfaceView, SurfaceTexture, TextureView,\nSurfaceFlinger, and Vulkan.*\n\nThis page describes essential elements of the Android system-level graphics\narchitecture and how they are used by the app framework and multimedia\nsystem. The focus is on how buffers of graphical data move through the system.\nIf you've ever wondered why SurfaceView and TextureView behave the way they do,\nor how surfaces and EGLSurface interact, you're in the correct place.\n\nSome familiarity with Android devices and app development is assumed.\nYou don't need detailed knowledge of the app framework and very few API calls\nare mentioned, but the material doesn't overlap with other public\ndocumentation. The goal is to provide details on the significant events\ninvolved in rendering a frame for output to help you make informed choices\nwhen designing an app. To achieve this, we work from the bottom up,\ndescribing how the UI classes work rather than how they can be used.\n\nThis section includes several pages covering everything from background\nmaterial to HAL details to use cases. It starts with an explanation of Android\ngraphics buffers, describes the composition and display mechanism, then proceeds\nto the higher-level mechanisms that supply the compositor with data. We\nrecommend reading pages in the order listed below rather than skipping to a\ntopic that sounds interesting.\n\nLow-level components\n--------------------\n\n- [BufferQueue and\n gralloc](/docs/core/graphics/arch-bq-gralloc). BufferQueue connects something that generates buffers of graphical data (the *producer* ) to something that accepts the data for display or further processing (the *consumer* ). Buffer allocations are performed through the *gralloc* memory allocator implemented through a vendor-specific HAL interface.\n- [SurfaceFlinger,\n Hardware Composer, and virtual displays](/docs/core/graphics/arch-sf-hwc). SurfaceFlinger accepts buffers of data from multiple sources, composites them, and sends them to the display. The Hardware Composer HAL (HWC) determines the most efficient way to composite buffers with the available hardware, and virtual displays make composited output available within the system (recording the screen or sending the screen over a network).\n- [Surface, canvas, and\n SurfaceHolder](/docs/core/graphics/arch-sh). A surface produces a buffer queue that is often consumed by SurfaceFlinger. When rendering onto a surface, the result ends up in a buffer that gets shipped to the consumer. Canvas APIs provide a software implementation (with hardware-acceleration support) for drawing directly on a surface (low-level alternative to OpenGL ES). Anything having to do with a view involves a SurfaceHolder, whose APIs enable getting and setting surface parameters such as size and format.\n- [EGLSurface and\n OpenGL ES](/docs/core/graphics/arch-egl-opengl). [OpenGL ES (GLES)](https://www.khronos.org/opengles/) defines a graphics-rendering API designed to be combined with [EGL](https://www.khronos.org/egl), a library that can create and access windows through the operating system (to draw textured polygons, use GLES calls; to put rendering on the screen, use EGL calls). This page also covers ANativeWindow, the C/C++ equivalent of the Java Surface class used to create an EGL window surface from native code.\n- [Vulkan](/docs/core/graphics/arch-vulkan). Vulkan is a low-overhead, cross-platform API for high-performance 3D graphics. Like OpenGL ES, Vulkan provides tools for creating high-quality, real-time graphics in apps. Vulkan advantages include reductions in CPU overhead and support for the [SPIR-V Binary Intermediate](https://www.khronos.org/spir) language.\n\nHigh-level components\n---------------------\n\n- [SurfaceView and\n GLSurfaceView](/docs/core/graphics/arch-sv-glsv). SurfaceView combines a surface and a view. SurfaceView's view components are composited by SurfaceFlinger (and not the app), enabling rendering from a separate thread/process and isolation from app UI rendering. GLSurfaceView provides helper classes to manage EGL contexts, interthread communication, and interaction with the activity lifecycle (but isn't required to use GLES).\n- [SurfaceTexture](/docs/core/graphics/arch-st). SurfaceTexture combines a surface and GLES texture to create a BufferQueue for which your app is the consumer. When a producer queues a new buffer, it notifies your app, which in turn releases the previously-held buffer, acquires the new buffer from the queue, and makes EGL calls to make the buffer available to GLES as an external texture. Android 7.0 added support for secure texture video playback enabling GPU post-processing of protected video content.\n- [TextureView](/docs/core/graphics/arch-tv). TextureView combines a view with a SurfaceTexture. TextureView wraps a SurfaceTexture and takes responsibility for responding to callbacks and acquiring new buffers. When drawing, TextureView uses the contents of the most recently received buffer as its data source, rendering wherever and however the view state indicates it should. View composition is always performed with GLES, meaning updates to contents may cause other view elements to redraw as well."]]