Janela/WindowManager no Android

Janela/WindowManager no Android

No Android, Window e WindowManager são componentes importantes para gerenciar o layout da interface e a exibição da janela. Eles permitem que os aplicativos exibam diferentes interfaces e janelas na tela e controlem sua posição, tamanho, exibição e ocultação.

1. Janela:
   Janela é um conceito abstrato no Android que representa a interface do aplicativo. Cada atividade possui uma janela correspondente, que é o contêiner de visualização de nível superior da atividade. Window é responsável por lidar com o layout, desenho, manipulação de eventos e outras operações da Activity. A janela pode conter uma ou mais visualizações, que são usadas para exibir conteúdo específico da interface.

No ciclo de vida da Atividade, a criação e destruição da Janela é gerenciada automaticamente pelo sistema, geralmente onCreate()criada quando um método é chamado e onDestroy()destruída quando um método é chamado. Os desenvolvedores podem personalizar a aparência e o comportamento da janela definindo o tema e o estilo da atividade.

2. WindowManager:
   WindowManager é um serviço de sistema usado para gerenciar o Windows. É responsável por lidar com a adição, remoção, atualização, layout e outras operações do Windows. WindowManager permite que aplicativos criem diferentes tipos de janelas na tela e especifiquem sua posição de exibição e relacionamento hierárquico.

O WindowManager pode getSystemService(Context.WINDOW_SERVICE)ser obtido por meio de métodos, que podem então ser usados ​​para adicionar, atualizar ou remover o Window.

Os tipos comuns de janelas incluem:

• Janela do Aplicativo: A janela principal do aplicativo, geralmente correspondente a uma Atividade.
• Janela do sistema: janelas no nível do sistema, como barra de status, barra de navegação, etc.
• Janela de diálogo: Janela de diálogo, usada para exibir caixas de diálogo ou caixas pop-up.
• Janela do Toast: janela de prompt do Toast, usada para exibir informações curtas de prompt.

Os desenvolvedores podem usar a classe WindowManager.LayoutParams para especificar as propriedades de exibição da janela, como largura, altura, posição, transparência, etc. Ao definir LayoutParams diferentes, efeitos especiais da janela podem ser obtidos, como tela inteira, janela flutuante, janela no nível do sistema, etc.

Deve-se notar que para aplicações comuns, na maioria dos casos não há necessidade de operar diretamente o Window e o WindowManager, porque a estrutura Android gerenciará automaticamente a janela da atividade e a exibição da interface. No entanto, em alguns cenários especiais, como interfaces personalizadas, janelas flutuantes, etc., os desenvolvedores podem precisar usar Window e WindowManager para obter exibição e interação de interface mais flexíveis. Ao usá-lo, você precisa prestar atenção ao seguir as especificações e restrições de permissão do sistema Android para garantir o funcionamento normal e a experiência do usuário do aplicativo.

Exemplos de código

No Android, podemos usar o WindowManager para adicionar dinamicamente uma janela flutuante (Floating Window). Uma janela flutuante é uma janela exibida suspensa acima da interface do aplicativo. É comumente usada em aplicativos de bate-papo, como avatares de bate-papo flutuantes, notificações em nível de sistema e barras de ferramentas flutuantes.

Aqui está um exemplo simples que demonstra como usar o WindowManager para adicionar uma janela flutuante:

Primeiro, adicione permissões de janela flutuante em AndroidManifest.xml:

<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>

Em seguida, adicione código na Activity para adicionar dinamicamente uma janela flutuante:

import android.content.Context;
import android.graphics.PixelFormat;
import android.os.Bundle;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.WindowManager;
import android.widget.Button;

public class FloatingWindowActivity extends AppCompatActivity {
    
    

    private WindowManager windowManager;
    private View floatingView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
    
    
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_floating_window);

        windowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);

        // 加载悬浮窗口的布局
        floatingView = LayoutInflater.from(this).inflate(R.layout.layout_floating_window, null);

        // 设置悬浮窗口的参数
        WindowManager.LayoutParams params = new WindowManager.LayoutParams(
                WindowManager.LayoutParams.WRAP_CONTENT,
                WindowManager.LayoutParams.WRAP_CONTENT,
                WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY, // 系统级别的悬浮窗口权限
                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE, // 不接受触摸事件
                PixelFormat.TRANSLUCENT);

        params.gravity = Gravity.TOP | Gravity.START; // 悬浮窗口的位置：左上角

        // 添加悬浮窗口到屏幕上
        windowManager.addView(floatingView, params);

        Button closeButton = floatingView.findViewById(R.id.btn_close);
        closeButton.setOnClickListener(new View.OnClickListener() {
    
    
            @Override
            public void onClick(View v) {
    
    
                // 点击关闭按钮，移除悬浮窗口
                windowManager.removeView(floatingView);
            }
        });
    }

    @Override
    protected void onDestroy() {
    
    
        super.onDestroy();
        // 在Activity销毁时，移除悬浮窗口，释放资源
        if (floatingView != null) {
    
    
            windowManager.removeView(floatingView);
        }
    }
}

Neste exemplo, primeiro carregamos um layout de janela flutuante personalizado layout_floating_window.xmlque contém um botão Fechar. Em seguida, WindowManagercriamos um WindowManager.LayoutParamsobjeto para definir os parâmetros da janela flutuante, incluindo tamanho, posição, nível de exibição, etc. A seguir, chamamos windowManager.addView()o método para adicionar a janela flutuante à tela.

Deve-se observar que a permissão de janela flutuante (SYSTEM_ALERT_WINDOW) é uma permissão sensível que precisa ser declarada em AndroidManifest.xml e concedida manualmente ao usuário nas configurações do aplicativo. Somente depois que o usuário concordar em conceder permissão para a janela flutuante a janela flutuante poderá ser exibida normalmente.

Em aplicativos reais, as janelas flutuantes podem envolver lógica de interação e gerenciamento de permissões mais complexas. Ao usar janelas flutuantes, você precisa considerar cuidadosamente a experiência do usuário e a segurança da privacidade para garantir a conformidade com as especificações e práticas recomendadas do sistema Android.