Introducción de esta sección:

Lo que esta sección trae para todos es el servicio del sistema que Android nos proporciona: WindowManager (Servicio de gestión de ventanas). Es la capa más baja para mostrar View; Toast, Activity y Dialog utilizan este WindowManager en su capa inferior. ¡Es global! El núcleo de esta clase no es más que llamar a los métodos addView, removeView, updateViewLayout para mostrar View y establecer las propiedades relacionadas a través de la API WindowManager.LayoutParams.

En esta sección exploraremos algunos ejemplos de aplicación de este WindowManager en el desarrollo real.

Documentación oficial de la API:WindowManager


1. Algunos conceptos de WindowManager:

1) Introducción a WindowManager

¡Es una API que Android nos proporciona para interactuar con el administrador de ventanas! Todos sabemos que las interfaces de una App están compuestas por Activities, y una Activity está compuesta por Views. Cuando queremos mostrar una interfaz, lo primero que pensamos es en Activity, ¿verdad? O también en Dialog y Toast.

Pero en algunos casos, estos tres anteriores pueden no satisfacer nuestras necesidades. Por ejemplo, si solo queremos una simple visualización, usar Activity parece un poco redundante, mientras que Dialog requiere un objeto Context y Toast no se puede hacer clic... Para las situaciones anteriores, podemos usar esa cosa llamada WindowManager para agregar View a la pantalla, ¡o eliminar View de la pantalla! Él es la interfaz que gestiona el mecanismo de ventanas de Android, ¡la capa más baja para mostrar View!


2) Cómo obtener una instancia de WindowManager

①Obtener el objeto WindowManager:

WindowManager wManager = getApplicationContext().getSystemService(Context. WINDOW_ SERVICE);

②Obtener el objeto WindowManager.LayoutParams para preparar operaciones posteriores

WindowManager.LayoutParams wmParams=new WindowManager.LayoutParams();

2. Ejemplos de uso de WindowManager:

Ejemplo 1: Obtener el ancho y alto de la pantalla

Antes de Android 4.2, podíamos usar el siguiente método para obtener el ancho y alto de la pantalla:

public static int[] getScreenHW(Context context) {
    WindowManager manager = (WindowManager)context
    .getSystemService(Context.WINDOW_SERVICE);
    Display display = manager.getDefaultDisplay();
    int width = display.getWidth();
    int height = display.getHeight();
    int[] HW = new int[] { width, height };
    return HW;
}

Pero el método anterior quedó obsoleto después de Android 4.2; podemos usar otro método para obtener el ancho y alto de la pantalla:

public static int[] getScreenHW2(Context context) {
    WindowManager manager = (WindowManager) context.
    getSystemService(Context.WINDOW_SERVICE);
    DisplayMetrics dm = new DisplayMetrics();
    manager.getDefaultDisplay().getMetrics(dm);
    int width = dm.widthPixels;
    int height = dm.heightPixels;
    int[] HW = new int[] { width, height };
    return HW;
}

Luego podemos escribir dos métodos más para obtener el ancho y el alto. Aquí tomamos el segundo método para obtener el ancho y alto de la pantalla como ejemplo:

public static int getScreenW(Context context) {
    return getScreenHW2(context)[0];
}

public static int getScreenH(Context context) {
    return getScreenHW2(context)[1];
}

Por supuesto, si no escribes una clase de utilidad adicional, puedes obtenerlo directamente, por ejemplo:

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        WindowManager wManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
        DisplayMetrics dm = new DisplayMetrics();
        wManager.getDefaultDisplay().getMetrics(dm);
        Toast.makeText(MainActivity.this, "当前手机的屏幕宽高:" + dm.widthPixels + "*" +
                dm.heightPixels, Toast.LENGTH_SHORT).show();
    }
}

Resultado de ejecución:


Ejemplo 2: Configurar la ventana para que se muestre a pantalla completa

getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
        getSupportActionBar().hide();

Resultado de ejecución:


Ejemplo 3: Mantener la pantalla siempre encendida

public void setKeepScreenOn(Activity activity,boolean keepScreenOn)  
{  
    if(keepScreenOn)  
    {  
        activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);  
    }else{  
        activity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);  
    }  
} 

Ejemplo 4: Implementación de una ventana flotante simple

Imagen del efecto de ejecución:

Código de implementación:

Primero necesitamos un Service en segundo plano que espere nuestras operaciones, como completar el dibujo y la eliminación de la ventana flotante. Así que definimos un Service:MyService.java: Necesitamos un método para crear la View de la ventana flotante:

private void createWindowView() {
    btnView = new Button(getApplicationContext());
    btnView.setBackgroundResource(R.mipmap.ic_launcher);
    windowManager = (WindowManager) getApplicationContext()
            .getSystemService(Context.WINDOW_SERVICE);
    params = new WindowManager.LayoutParams();

    // 设置Window Type
    params.type = WindowManager.LayoutParams.TYPE_SYSTEM_ALERT;
    // 设置悬浮框不可触摸
    params.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
            | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
    // 悬浮窗不可触摸,不接受任何事件,同时不影响后面的事件响应
    params.format = PixelFormat.RGBA_8888;
    // 设置悬浮框的宽高
    params.width = 200;
    params.height = 200;
    params.gravity = Gravity.LEFT;
    params.x = 200;
    params.y = 000;
    // 设置悬浮框的Touch监听
    btnView.setOnTouchListener(new View.OnTouchListener() {
        //保存悬浮框最后位置的变量
        int lastX, lastY;
        int paramX, paramY;

        @Override
        public boolean onTouch(View v, MotionEvent event) {
            switch (event.getAction()) {
                case MotionEvent.ACTION_DOWN:
                    lastX = (int) event.getRawX();
                    lastY = (int) event.getRawY();
                    paramX = params.x;
                    paramY = params.y;
                    break;
                case MotionEvent.ACTION_MOVE:
                    int dx = (int) event.getRawX() - lastX;
                    int dy = (int) event.getRawY() - lastY;
                    params.x = paramX + dx;
                    params.y = paramY + dy;
                    // 更新悬浮窗位置
                    windowManager.updateViewLayout(btnView, params);
                    break;
            }
            return true;
        }
    });
    windowManager.addView(btnView, params);
    isAdded = true;
}

Luego solo necesitamos llamar al método createWindowView() mencionado anteriormente en el método OnCreate() para iniciar y cargar la ventana flotante. Pero encontramos una cosa: parece que esto no se puede cerrar. ¡Maldición! Bueno, a continuación analizaremos los requisitos.

Cuando está en la interfaz normal del teléfono, es decir, en el escritorio, esta cosa se muestra. Cuando iniciamos otras aplicaciones, esta ventana flotante debería desaparecer. Cuando salimos de la aplicación y volvemos al escritorio, esta ventana flotante debería reaparecer.

Entonces, primero necesitamos determinar si la aplicación está en el escritorio. Así que agregamos el siguiente código:

/**  
 * 判断当前界面是否是桌面  
 */    
public boolean isHome(){    
    if(mActivityManager == null) {  
        mActivityManager = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);    
    }  
    List<RunningTaskInfo> rti = mActivityManager.getRunningTasks(1);    
    return homeList.contains(rti.get(0).topActivity.getPackageName());    
}  
  
/**  
 * 获得属于桌面的应用的应用包名称  
 * @return 返回包含所有包名的字符串列表  
 */  
private List<String> getHomes() {  
    List<String> names = new ArrayList<String>();    
    PackageManager packageManager = this.getPackageManager();    
    // 属性    
    Intent intent = new Intent(Intent.ACTION_MAIN);    
    intent.addCategory(Intent.CATEGORY_HOME);    
    List<ResolveInfo> resolveInfo = packageManager.queryIntentActivities(intent,    
            PackageManager.MATCH_DEFAULT_ONLY);    
    for(ResolveInfo ri : resolveInfo) {    
        names.add(ri.activityInfo.packageName);    
    }  
    return names;    
}  

Bien, a continuación necesitamos realizar una serie de comprobaciones periódicas, por ejemplo: si está en el escritorio, si la ventana flotante ya se ha cargado; si no, cargarla; de lo contrario, si ya está cargada, ¡eliminar esta ventana flotante! Aquí usamos un handler~, porque no se puede actualizar la UI directamente en un subproceso secundario. Así que, ya sabes, escribimos nuestro propio handler para completar la operación anterior:

//定义一个更新界面的Handler  
private Handler mHandler = new Handler() {  
    @Override  
    public void handleMessage(Message msg) {  
        switch(msg.what) {  
        case HANDLE_CHECK_ACTIVITY:  
            if(isHome()) {  
                if(!isAdded) {  
                    windowManager.addView(btnView, params);  
                    isAdded = true;  
                new Thread(new Runnable() {  
                    public void run() {  
                        for(int i=0;i<10;i++){  
                            try {  
                                Thread.sleep(1000);  
                            } catch (InterruptedException e) {e.printStackTrace();}  
                            Message m = new Message();  
                            m.what=2;  
                            mHandler.sendMessage(m);  
                        }  
                    }  
                }).start();}  
            } else {  
                if(isAdded) {  
                    windowManager.removeView(btnView);  
                    isAdded = false;  
                }  
            }  
            mHandler.sendEmptyMessageDelayed(HANDLE_CHECK_ACTIVITY, 0);  
            break;  
        }  
    }  
}; 

Lo último que hay que hacer es sobrescribir el método onStartCommand() del Service, que consiste en hacer comprobaciones, extraer los datos del Intent y determinar si se necesita agregar la ventana flotante o si se debe eliminarla.

@Override  
public int onStartCommand(Intent intent, int flags, int startId) {  
    int operation = intent.getIntExtra(OPERATION, OPERATION_SHOW);  
    switch(operation) {  
    case OPERATION_SHOW:  
        mHandler.removeMessages(HANDLE_CHECK_ACTIVITY);  
        mHandler.sendEmptyMessage(HANDLE_CHECK_ACTIVITY);  
        break;  
    case OPERATION_HIDE:  
        mHandler.removeMessages(HANDLE_CHECK_ACTIVITY);  
        break;  
    }  
    return super.onStartCommand(intent, flags, startId);  
} 

Bien, hasta aquí, el trabajo principal está completo. Lo que sigue son algunos detalles menores: usar una Activity para iniciar este Service:MainActivity.java:

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private Button btn_on;

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

    private void bindViews() {
        btn_on = (Button) findViewById(R.id.btn_on);
        btn_on.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_on:
                Intent mIntent = new Intent(MainActivity.this, MainService.class);
                mIntent.putExtra(MainService.OPERATION, MainService.OPERATION_SHOW);
                startService(mIntent);
                Toast.makeText(MainActivity.this, "悬浮框已开启~", Toast.LENGTH_SHORT).show();
                break;
        }
    }
}

Luego, agregar los permisos en AndroidManifest.xml y registrar MainService:

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

<service android:name=".MainService"/>

Bien, la lógica es bastante fácil de entender~ Echen un vistazo ustedes mismos~


3. Referencias adicionales:

En el cuarto ejemplo, puede que hayas notado: esa cosa de WindowManager.LayoutParams, esto es un marcador, como por ejemplo pantalla completa~ Por cuestión de tiempo no los enumeraré uno por uno. Puedes consultar el sitio web oficial o los siguientes enlaces:

Documentación oficial: WindowManager.LayoutParams

Servicio del sistema Android - WindowManager

Además, si estás interesado en la ventana flotante anterior y quieres investigar más a fondo, puedes ver el blog del tío Guo (Guo Lin):

Implementación del efecto de ventana flotante en el escritorio de Android, imitando el efecto de ventana flotante de 360 Mobile Guard

Avanzado de ventana flotante en el escritorio de Android, implementación del efecto del pequeño cohete de QQ Mobile Manager


4. Descarga de ejemplos de código de esta sección:

WindowManagerDemo2.zip


Resumen de esta sección:

En esta sección hemos estudiado WindowManager entre los servicios del sistema de Android. Los primeros tres ejemplos probablemente se usarán más en el desarrollo real. Se recomienda escribir el primer ejemplo como una clase de utilidad, ya que el ancho y alto de la pantalla se utilizan bastante. En cuanto a la ventana flotante, si puedes entenderla, entiéndela; si no, no importa. En el desarrollo real rara vez te piden crear una ventana flotante... Bueno, esto es todo por esta sección, ¡gracias!