Introduction à cette section :

Cette section vous présente WindowManager (service de gestion des fenêtres) parmi les services système fournis par Android. C'est le niveau le plus bas pour afficher des Views. Toast, Activity et Dialog utilisent tous ce WindowManager au niveau inférieur. Il est global ! Le cœur de cette classe n'est rien d'autre que d'appeler les méthodes addView, removeView, updateViewLayout pour afficher des Views et définir les propriétés associées via l'API WindowManager.LayoutParams ! Restez à l'écoute~

Dans cette section, explorons quelques exemples d'applications pratiques de WindowManager en développement réel~

Documentation officielle de l'API :WindowManager


1. Quelques concepts de WindowManager :

1) Introduction à WindowManager

C'est une API fournie par Android pour interagir avec le gestionnaire de fenêtres ! Nous savons tous que l'interface d'une application est composée d'Activities, et qu'une Activity est composée de Views. Lorsque nous voulons afficher une interface, la première chose qui nous vient à l'esprit est Activity, n'est-ce pas ? Ou Dialog et Toast.

Mais dans certains cas, les trois ci-dessus peuvent ne pas répondre à nos besoins. Par exemple, pour un affichage simple, utiliser Activity semble un peu superflu, tandis que Dialog nécessite un objet Context, et Toast ne peut pas être cliqué... Pour les situations ci-dessus, nous pouvons utiliser WindowManager, cette chose, pour ajouter des Views à l'écran ou supprimer des Views de l'écran ! C'est une interface pour gérer le mécanisme de fenêtres d'Android, le niveau le plus bas pour afficher des Views !


2) Comment obtenir une instance de WindowManager

①Obtenir l'objet WindowManager:

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

②Obtenir l'objet WindowManager.LayoutParams afin de préparer les opérations suivantes

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

2. Exemples d'utilisation de WindowManager :

Exemple 1 : Obtenir la largeur et la hauteur de l'écran

Avant Android 4.2, nous pouvions utiliser la méthode suivante pour obtenir la largeur et la hauteur de l'écran :

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;
}

Cependant, la méthode ci-dessus est devenue obsolète après Android 4.2. Nous pouvons utiliser une autre méthode pour obtenir la largeur et la hauteur de l'écran :

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;
}

Ensuite, nous pouvons écrire deux méthodes distinctes pour obtenir la largeur et la hauteur. Ici, nous prenons comme exemple la deuxième méthode d'obtention de la largeur et de la hauteur de l'écran :

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

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

Bien sûr, si vous n'écrivez pas de classe utilitaire séparée, vous pouvez les obtenir directement, par exemple :

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();
    }
}

Résultat de l'exécution:


Exemple 2 : Configurer la fenêtre en affichage plein écran

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

Résultat de l'exécution:


Exemple 3 : Garder l'écran toujours allumé

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);  
    }  
} 

Exemple 4 : Implémentation d'une fenêtre flottante simple

Capture d’écran du résultat:

Code d'implémentation:

Tout d'abord, nous avons besoin d'un Service en arrière-plan pour attendre nos opérations en arrière-plan, comme terminer le dessin et la suppression de la fenêtre flottante. Par conséquent, nous définissons un Service :MyService.javaNous avons besoin d'une méthode pour créer la View de la fenêtre flottante :

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;
}

Ensuite, nous avons juste besoin d'appeler la méthode createWindowView() ci-dessus dans la méthode OnCreate() pour commencer à charger la fenêtre flottante. Mais nous avons remarqué une chose : ce truc semble ne pas pouvoir être fermé, mince, bon, ensuite nous devons analyser les exigences !

Elle ne doit être affichée que lorsque le téléphone est sur l'interface normale, c'est-à-dire le bureau. Lorsque nous lançons d'autres applications, cette fenêtre flottante doit disparaître. Lorsque nous quittons l'application et revenons au bureau, cette fenêtre flottante doit réapparaître !

Ensuite, nous devons d'abord déterminer si l'App est sur le bureau, donc nous ajoutons le code suivant :

/**  
 * 判断当前界面是否是桌面  
 */    
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;    
}  

D'accord, ensuite nous devons effectuer une série de vérifications à intervalles réguliers, telles que : si l'application est sur le bureau, si la fenêtre flottante a été chargée ; si ce n'est pas le cas, la charger ; sinon, si elle a été chargée, supprimer la fenêtre flottante ! Ici, nous utilisons un handler~, parce que nous ne pouvons pas mettre à jour directement l'UI dans un thread enfant, donc, vous voyez, nous écrivons notre propre handler pour effectuer les opérations ci-dessus :

//定义一个更新界面的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;  
        }  
    }  
}; 

La dernière chose à faire est de redéfinir la méthode onStartCommand() du Service, c'est-à-dire effectuer des vérifications, extraire les données de l'Intent et déterminer s'il faut ajouter la fenêtre flottante ou la supprimer !

@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);  
} 

Bon, à ce stade, le travail principal est terminé. Ensuite, quelques détails : utilisez une Activity pour démarrer ce 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;
        }
    }
}

Ajoutez ensuite les permissions dans AndroidManifest.xml et enregistrez MainService :

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

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

Bon, la logique reste relativement facile à comprendre~ Vous pouvez jeter un coup d'œil par vous-même~


3. Lectures complémentaires :

À partir du quatrième exemple, vous avez peut-être remarqué : WindowManager.LayoutParams, cette chose, est un flag, comme le plein écran~ Par manque de temps, je ne vais pas les énumérer un par un. Vous pouvez consulter le site officiel ou les liens suivants :

Documentation officielle : WindowManager.LayoutParams

Service système Android - WindowManager

De plus, si la fenêtre flottante ci-dessus vous intéresse et que vous souhaitez l'étudier plus en profondeur, vous pouvez consulter le blog de l'oncle Guo (Guo Lin) :

Implémentation de l'effet de fenêtre flottante sur le bureau Android, en imitant l'effet de fenêtre flottante de 360 Mobile Guard

Fenêtre flottante avancée sur le bureau Android, implémentation de l'effet de petite fusée de QQ Mobile Manager


4. Téléchargement des exemples de code de cette section :

WindowManagerDemo2.zip


Résumé de cette section :

Dans cette section, nous avons découvert WindowManager dans les services système Android. Les trois premiers exemples peuvent être davantage utilisés en développement réel. Il est recommandé d'écrire le premier exemple sous forme de classe utilitaire ; après tout, la largeur et la hauteur d'écran sont assez souvent utilisées~ Quant à la fenêtre flottante, si vous pouvez la comprendre, tant mieux ; sinon, ce n'est pas grave~ En développement réel, on vous demande rarement de créer une fenêtre flottante... Bon, très bien, c'est tout pour cette section, merci~