Desenvolvedores que trabalham com Xamarin.Forms foram pegos de surpresa por uma mudança significativa no Android 15: os aplicativos começaram a ser renderizados em tela cheia (de ponta a ponta) por padrão, sobrepondo as barras de status e navegação do sistema. Esse comportamento inesperado quebrou a interface do usuário de muitos aplicativos que antes funcionavam perfeitamente. Este post fornece documentação abrangente e uma solução robusta para corrigir esse problema, garantindo que seu aplicativo mantenha uma aparência profissional e funcional em todas as versões do Android, incluindo a mais recente. A solução foi implementada e testada em um projeto do mundo real, AppCelmi.

O Problema: Uma UI Quebrada no Android 15

Sintomas

• Sobreposição da UI: O aplicativo é renderizado sobre o relógio, os ícones de notificação e a barra de navegação.
• Elementos Inacessíveis: Botões e outros componentes da UI podem ficar ocultos atrás das barras do sistema.
• Experiência do Usuário (UX) Comprometida: A interface torna-se confusa, não profissional e difícil de usar.
• Impacto Generalizado: Afeta principalmente aplicativos legados ou aqueles não explicitamente preparados para a renderização de ponta a ponta.

A Solução: WindowInsets e ViewCompat

A solução correta e recomendada pelo Google envolve o uso das APIs ViewCompat e WindowInsetsCompat para gerenciar dinamicamente o preenchimento do seu aplicativo, respeitando assim as áreas do sistema (insets).

Por que esta abordagem?

• Oficial e Moderna: Segue as diretrizes oficiais do Google para o desenvolvimento Android.
• Compatibilidade com Versões Anteriores: Funciona perfeitamente do Android 5.0 (API 21) até o Android 15 (API 35).
• Robusta e Preparada para o Futuro: É uma solução durável que se adapta a diferentes tamanhos de tela, entalhes e barras de navegação.

Implementação do Código

A correção é aplicada inteiramente dentro do projeto Android (.Droid) da sua solução Xamarin.Forms, sem necessidade de alterações no código compartilhado.

1. Arquivo: MainActivity.cs

No método OnCreate, orquestramos a configuração da janela para desativar o comportamento padrão e, em seguida, aplicamos nosso listener de insets personalizado.

using Android.App;
using Android.Content.PM;
using Android.OS;
using Android.Views;
using AndroidX.Core.View;
using Xamarin.Forms.Platform.Android;

namespace BalancasCelmi.Droid // Substitua pelo seu namespace
{
    [Activity(Label = "AppCelmi", Icon = "@mipmap/icon", Theme = "@style/MainTheme", /* ... outros atributos ... */)]
    public partial class MainActivity : FormsAppCompatActivity
    {
        protected override void OnCreate(Bundle savedInstanceState)
        {
            base.OnCreate(savedInstanceState);

            // 1. Configurar a janela para renderização controlada
            ConfigureWindowInsets();

            global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
            LoadApplication(new App());
            
            // 2. Aplicar o listener que ajustará o preenchimento
            ApplyWindowInsets();
        }

        private void ConfigureWindowInsets()
        {
            // Habilitar o controle sobre as áreas do sistema
            Window.AddFlags(WindowManagerFlags.DrawsSystemBarBackgrounds);
            Window.ClearFlags(WindowManagerFlags.TranslucentStatus | WindowManagerFlags.TranslucentNavigation);
            Window.SetStatusBarColor(Android.Graphics.Color.Rgb(246, 114, 16)); // Cor do tema laranja

            // Para Android 11+ (API 30+), informar ao sistema que o aplicativo lidará com os insets
            if (Build.VERSION.SdkInt >= BuildVersionCodes.R)
            {
                Window.SetDecorFitsSystemWindows(false);
            }
            // Para versões mais antigas, usar flags de visibilidade
            else if (Build.VERSION.SdkInt >= BuildVersionCodes.Lollipop)
            {
                Window.DecorView.SystemUiVisibility = (StatusBarVisibility)(
                    SystemUiFlags.LayoutStable |
                    SystemUiFlags.LayoutHideNavigation |
                    SystemUiFlags.LayoutFullscreen
                );
            }
        }

        private void ApplyWindowInsets()
        {
            var contentView = FindViewById(Android.Resource.Id.Content);
            if (contentView != null)
            {
                // Definir o listener na view de conteúdo principal
                ViewCompat.SetOnApplyWindowInsetsListener(contentView, new WindowInsetsListener());
                ViewCompat.RequestApplyInsets(contentView);
            }
        }
    }

    // Listener que recebe os insets do sistema e aplica o preenchimento
    public class WindowInsetsListener : Java.Lang.Object, IOnApplyWindowInsetsListener
    {
        public WindowInsetsCompat OnApplyWindowInsets(View v, WindowInsetsCompat insets)
        {
            // Obter os insets para as barras do sistema (status, navegação) e display cutouts (notch)
            var systemBars = insets.GetInsets(
                WindowInsetsCompat.Type.SystemBars() | 
                WindowInsetsCompat.Type.DisplayCutout()
            );

            // Aplicar o preenchimento à view principal do aplicativo
            v.SetPadding(
                0,                 // Esquerda
                systemBars.Top,    // Topo
                0,                 // Direita
                systemBars.Bottom  // Fundo
            );

            // Informar ao sistema que consumimos os insets
            return WindowInsetsCompat.Consumed;
        }
    }
}

2. Arquivo: Resources/values/styles.xml

É crucial garantir que seu tema não force os modos de tela cheia ou translúcido, permitindo que seu código C# gerencie o comportamento.

<?xml version="1.0" encoding="utf-8" ?>
<resources>
  <style name="MainTheme" parent="MainTheme.Base">
    <item name="colorPrimary">#F6720F</item>
    <item name="colorPrimaryDark">#F6720F</item>
    <item name="colorAccent">#F5D2BE</item>
    
    <item name="android:windowFullscreen">false</item>
    <item name="android:windowTranslucentStatus">false</item>
    <item name="android:windowTranslucentNavigation">false</item>
    <item name="android:fitsSystemWindows">false</item>
    <item name="android:windowDrawsSystemBarBackgrounds">true</item>
  </style>
</resources>

Como a Solução Funciona

• Desativar o Padrão: Primeiro, instruímos o sistema Android (via styles.xml e o método ConfigureWindowInsets) a não aplicar o modo de ponta a ponta automaticamente. Assumimos o controle.

• Ouvir o Sistema: Em seguida, registramos um WindowInsetsListener. Este listener é notificado pelo SO sempre que as dimensões das barras do sistema mudam (por exemplo, na rotação da tela).

• Calcular o Preenchimento: O listener recebe as dimensões exatas da barra de status (topo) e da barra de navegação (fundo).

• Aplicar Preenchimento Dinâmico: Com essas dimensões, ele aplica preenchimento dinâmico à view raiz do seu aplicativo, empurrando seu conteúdo para a área segura e visível e evitando qualquer sobreposição.

Resultados e Benefícios

A implementação desta solução restaura completamente o layout esperado do aplicativo.

✅ UI Profissional: A interface está novamente limpa, organizada e profissional.

✅ Compatibilidade Total: Funciona consistentemente em todas as versões modernas do Android.

✅ Design Responsivo: Adapta-se nativamente a qualquer dispositivo, com ou sem notch.

✅ Manutenibilidade: O código é limpo, segue as melhores práticas e não exigirá correções constantes a cada nova versão do Android.

Conclusão Final e Recomendação

Embora as mudanças no Android 15 tenham pego muitos de surpresa, a solução baseada em WindowInsets é a maneira correta e definitiva de garantir que seus aplicativos Xamarin.Forms se comportem adequadamente. A implementação é relativamente simples e se concentra apenas na camada Android nativa, preservando sua lógica de negócios compartilhada.

Recomendação: Adote esta prática em todos os seus projetos Xamarin.Forms para evitar problemas futuros e garantir uma experiência de usuário impecável.

Data de implementação e teste: 4 de julho de 2025.

Para mais detalhes técnicos, consulte a documentação oficial do Android sobre Edge-to-Edge.