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.
Gerenciamento de framebuffer do cliente
Mantenha tudo organizado com as coleções
Salve e categorize o conteúdo com base nas suas preferências.
No Android 13 e versões mais recentes, os novos framebuffers, usados durante a
composição do cliente,
são alocados sempre que a resolução da tela muda. Essa
alocação é realizada pelo SurfaceFlinger no próximo ciclo de invalidação
após uma mudança de resolução.
Gerenciamento de framebuffer durante mudanças de resolução
As mudanças de resolução ocorrem devido a um dos seguintes
cenários:
Um evento hotplug,
iniciado pelo compositor de hardware (HWC, na sigla em inglês), que ocorre ao trocar de uma tela
externa para outra que tem uma resolução padrão diferente.
Durante um evento de hotplug, os identificadores dos framebuffers antigos são liberados
quando os dados de exibição antigos são desalocados.
Uma mudança de modo de exibição iniciada pelo SurfaceFlinger, que ocorre quando o
usuário muda a resolução com as configurações do usuário,
ou um app muda a resolução com preferredDisplayModeId
.
Durante uma mudança de modo de exibição, os identificadores dos framebuffers de clientes
são liberados pelo SurfaceFlinger antes de chamar setActiveConfig
ou setActiveConfigWithConstraints
.
Para evitar problemas catastróficos, como a fragmentação de memória, em dispositivos que
não reservam memória suficiente para os framebuffers antigos e novos, é fundamental
que o HWC deixe de usar os framebuffers antigos e libere todos
os identificadores para esses framebuffers, conforme mostrado nos seguintes casos:
A liberação dos identificadores permite que a memória do framebuffer seja totalmente desalocada
antes da alocação de novos framebuffers que o SurfaceFlinger executa
durante o próximo ciclo de invalidação.
Recomendações para o gerenciamento de framebuffer
Se o HWC não liberar os identificadores para framebuffers antigos a tempo,
a nova alocação de framebuffer vai ocorrer antes da dealocação
do framebuffer antigo. Isso pode causar problemas catastróficos quando a nova alocação falhar
devido à fragmentação ou outros problemas. Pior ainda, se
o HWC não liberar esses identificadores, um vazamento de memória poderá
ocorrer.
Para evitar falhas catastróficas de alocação, siga estas recomendações:
Se o HWC precisar continuar usando os framebuffers de cliente antigos até que os novos
sejam fornecidos, é fundamental reservar memória suficiente
para os framebuffers antigos e novos e, possivelmente, executar algoritmos de desfragmentação
no espaço de memória do framebuffer.
Aloque um pool de memória dedicado para os framebuffers que são separados do
resto da memória do buffer gráfico. Isso é importante porque, entre
a dealocação e a realocação dos framebuffers, um processo de terceiros pode
tentar alocar memória gráfica. Se o mesmo pool de memória gráfica for
usado pelo framebuffer e se a memória gráfica estiver cheia, o processo de terceiros
poderá ocupar a memória gráfica alocada anteriormente por um framebuffer,
deixando memória insuficiente para a realocação do framebuffer ou, possivelmente,
fragmentando o espaço de memória.
Testar o gerenciamento de framebuffer
Os OEMs são aconselhados a testar o gerenciamento adequado da memória de framebuffer do cliente em
interruptores de resolução para o dispositivo, conforme descrito abaixo:
Para eventos de hotplug, basta desconectar e reconectar duas telas diferentes com
resoluções diferentes.
Para alternar entre modos, use o teste do verificador
CTS ModeSwitchingTestActivity
para iniciar uma troca de modo para testar o comportamento da memória do framebuffer.
Esse teste pode identificar visualmente problemas difíceis de detectar
programaticamente.
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.
[[["Fácil de entender","easyToUnderstand","thumb-up"],["Meu problema foi resolvido","solvedMyProblem","thumb-up"],["Outro","otherUp","thumb-up"]],[["Não contém as informações de que eu preciso","missingTheInformationINeed","thumb-down"],["Muito complicado / etapas demais","tooComplicatedTooManySteps","thumb-down"],["Desatualizado","outOfDate","thumb-down"],["Problema na tradução","translationIssue","thumb-down"],["Problema com as amostras / o código","samplesCodeIssue","thumb-down"],["Outro","otherDown","thumb-down"]],["Última atualização 2025-07-27 UTC."],[],[],null,["# Client framebuffer management\n\nStarting with Android 13, new framebuffers, used during\n[client](https://android.googlesource.com/platform/hardware/interfaces/+/refs/heads/android16-release/graphics/composer/aidl/android/hardware/graphics/composer3/DisplayCommand.aidl#113)\ncomposition, are allocated whenever the display resolution changes. This\nallocation is performed by SurfaceFlinger on the next *invalidate* cycle\nafter a resolution change.\n\nFramebuffer management during resolution switches\n-------------------------------------------------\n\nResolution changes occur due to one of the following\ntwo scenarios:\n\n- A [hotplug event](https://android.googlesource.com/platform/hardware/interfaces/+/refs/heads/android16-release/graphics/composer/aidl/android/hardware/graphics/composer3/IComposerCallback.aidl#41),\n initiated by Hardware Composer (HWC), which occurs when swapping from one external\n display to a different external display that has a different default resolution.\n\n During a hotplug event, the handles to the old framebuffers are released\n when the old display data is deallocated.\n- A display mode switch initiated by SurfaceFlinger, which occurs when the\n user changes the resolution with [user settings](https://android.googlesource.com/platform/frameworks/base/+/refs/heads/android16-release/core/java/android/hardware/display/DisplayManager.java#1209),\n or an app changes the resolution with [`preferredDisplayModeId`](https://developer.android.com/reference/android/view/WindowManager.LayoutParams#preferredDisplayModeId).\n\n During a display mode switch, the handles to existing client framebuffers\n are released by SurfaceFlinger before calling [`setActiveConfig`](https://android.googlesource.com/platform/hardware/interfaces/+/refs/heads/android16-release/graphics/composer/aidl/android/hardware/graphics/composer3/IComposerClient.aidl#550)\n or [`setActiveConfigWithConstraints`](https://android.googlesource.com/platform/hardware/interfaces/+/refs/heads/android16-release/graphics/composer/aidl/android/hardware/graphics/composer3/IComposerClient.aidl#577).\n\nTo avoid catastrophic problems, such as memory fragmentation, on devices that\ndon't reserve enough memory for the old and new framebuffers, it's critical\nthat HWC ceases to use the old framebuffers and releases any\nhandles to these framebuffers as shown in the following cases:\n\n- For hotplug events, immediately before calling [`onHotplug`](https://android.googlesource.com/platform/hardware/interfaces/+/refs/heads/android16-release/graphics/composer/aidl/android/hardware/graphics/composer3/IComposerCallback.aidl#41).\n\n- For mode switches, immediately after the call to [`setActiveConfig`](https://android.googlesource.com/platform/hardware/interfaces/+/refs/heads/android16-release/graphics/composer/aidl/android/hardware/graphics/composer3/IComposerClient.aidl#550)\n or [`setActiveConfigWithConstraints`](https://android.googlesource.com/platform/hardware/interfaces/+/refs/heads/android16-release/graphics/composer/aidl/android/hardware/graphics/composer3/IComposerClient.aidl#577).\n\nReleasing the handles allows the framebuffer memory to be fully deallocated\nprior to the allocation of new framebuffers that SurfaceFlinger performs\nduring the next *invalidate* cycle.\n\n### Recommendations for framebuffer management\n\nIf HWC doesn't release handles to old framebuffers in time,\nthe new framebuffer allocation takes place before the old framebuffer\ndeallocation. This can cause catastrophic problems when the new allocation fails\ndue to fragmentation or other issues. Even worse, if\nHWC doesn't release these handles at all, a memory leak can\noccur.\n\nTo avoid catastrophic allocation failures, follow these recommendations:\n\n- If HWC needs to continue using the old client framebuffers until the new\n client framebuffers are provided, then it's critical to reserve enough memory\n for both the old and new framebuffers, and possibly run defragmentation\n algorithms on the framebuffer memory space.\n\n- Allocate a dedicated memory pool for the framebuffers that's separate from\n the rest of the graphic buffer memory. This is important because between\n deallocation and reallocation of the framebuffers, a third-party process can\n attempt to allocate graphics memory. If the same graphics memory pool is\n used by the framebuffer and if the graphics memory is full, the third-party\n process can occupy the graphics memory previously allocated by a framebuffer,\n thus leaving insufficient memory for the framebuffer reallocation or, possibly\n fragmenting the memory space.\n\nTest framebuffer management\n---------------------------\n\nOEMs are advised to test for proper client framebuffer memory management across\nresolution switches for their device, described as follows:\n\n- For hotplug events, simply unplug and reconnect two different displays with\n different resolutions.\n\n- For mode switches, use the [`ModeSwitchingTestActivity`](https://cs.android.com/android/platform/superproject/+/android-latest-release:cts/apps/CtsVerifier/src/com/android/cts/verifier/tv/display/ModeSwitchingTestActivity.java;l=47-53;drc=c80d948aff1e7df5c2dc0ddba0d1cd63a90e4d9c) CTS\n Verifier test to initiate a mode switch for testing framebuffer memory behavior.\n This test can visually identify problems that are hard to detect\n programmatically."]]