一部手机做好屏幕适配

最新推荐文章于 2024-09-27 01:33:45 发布

2015从头再来

最新推荐文章于 2024-09-27 01:33:45 发布

阅读量2.6k

点赞数

分类专栏： Android

本文链接：https://blog.csdn.net/fuzhongbin/article/details/78743310

版权

Android 专栏收录该内容

143 篇文章 0 订阅

订阅专栏

一.Android多机型适配：

多机型适配在Android开发中经常会碰到，那么如果我们只有一部测试机，如何能做到用这一部手机来看各种不同分辨率手机的UI显示呢！不需要桌前摆一排手机来一个一个的是看。

二.WM命令：

1.什么是WM命令：

说了这么多前提，实际上需要使用的就是一行 wm 命令，可以通过 adb shell 来操作它。

wm 命令主要用来帮助我们修改一些屏幕的参数，先来看看它的文档。使用 adb shell wm 命令，可以方便的查看 wm 的文档描述

可以看到，wm 命令可以帮助我们修改当前设备的 size 、 density 等参数，而这两个参数就是决定了当前设备的显示效果。

2.2 WM命令

上面的文档中有很多命令，其实我们平时用到的一般只有size,density这两个，以下例子为一部1080x1920的设备：

1. wm size命令

wm size 命令，可以用来查询和修改当前设备的尺寸，如果想要修改尺寸，可以使用 px 或者 dp 为单位（默认为 px），使用 x 进行连接，这个其实看看 wm size 的输出，你就清楚了。

上面的例子中，调用了不同的命令：

1.使用 wm size 命令查看当前设备的尺寸。

2.使用 wm size 命令将当前尺寸修改成了 1000x2000。

3.再次使用 wm size 命令查看当前设备的尺寸。

4.最后使用 wm size reset 命令，将屏幕尺寸还原。

5.再用 wm size 命令，查看还原后的尺寸。

这几个步骤就已经涵盖了 wm size 命令的所有使用步骤，可以使用它查看当前屏幕尺寸，并且修改屏幕尺寸和还原它。

2.wm density命令

wm density 命令，可以用来查看和修改当前设备的 density 参数。

使用起来跟wm size相同，我们直接上命令吧。

在这个例子中，我做了几件事情：

1.使用 wm density 查看当前设备的 density。

2.在使用 wm density 命令，修改当前设备的 density 为 560,580。

3.然后再使用 wm density 查看修改后的参数。

4.最后使用 wm density reset 将设备的 density 还原。

5.最后再查看一下还原后的值。

3.wm overscan命令

wm overscan 命令，可以修改当前设备的屏幕内边距。这个命令一般用不到。

在这个例子中，做了两件事：

1.使用 wm overscan 修改边距为 30 。

2.然后使用 wm overscan reset 将其还原。

WM命令源码：

package com.android.commands.wm;
20
21import android.content.Context;
22import android.graphics.Point;
23import android.graphics.Rect;
24import android.os.RemoteException;
25import android.os.ServiceManager;
26import android.os.UserHandle;
27import android.util.AndroidException;
28import android.util.DisplayMetrics;
29import android.view.Display;
30import android.view.IWindowManager;
31import com.android.internal.os.BaseCommand;
32
33import java.io.PrintStream;
34import java.util.regex.Matcher;
35import java.util.regex.Pattern;
36
37public class Wm extends BaseCommand {
38
39    private IWindowManager mWm;
40
41    /**
42     * Command-line entry point.
43     *
44     * @param args The command-line arguments
45     */
46    public static void main(String[] args) {
47        (new Wm()).run(args);
48    }
49
50    @Override
51    public void onShowUsage(PrintStream out) {
52        out.println(
53                "usage: wm [subcommand] [options]\n" +
54                "       wm size [reset|WxH|WdpxHdp]\n" +
55                "       wm density [reset|DENSITY]\n" +
56                "       wm overscan [reset|LEFT,TOP,RIGHT,BOTTOM]\n" +
57                "       wm scaling [off|auto]\n" +
58                "       wm screen-capture [userId] [true|false]\n" +
59                "\n" +
60                "wm size: return or override display size.\n" +
61                "         width and height in pixels unless suffixed with 'dp'.\n" +
62                "\n" +
63                "wm density: override display density.\n" +
64                "\n" +
65                "wm overscan: set overscan area for display.\n" +
66                "\n" +
67                "wm scaling: set display scaling mode.\n" +
68                "\n" +
69                "wm screen-capture: enable/disable screen capture.\n" +
70                "\n" +
71                "wm dismiss-keyguard: dismiss the keyguard, prompting the user for auth if " +
72                "necessary.\n"
73                );
74    }
75
76    @Override
77    public void onRun() throws Exception {
78        mWm = IWindowManager.Stub.asInterface(ServiceManager.checkService(
79                        Context.WINDOW_SERVICE));
80        if (mWm == null) {
81            System.err.println(NO_SYSTEM_ERROR_CODE);
82            throw new AndroidException("Can't connect to window manager; is the system running?");
83        }
84
85        String op = nextArgRequired();
86
87        if (op.equals("size")) {
88            runDisplaySize();
89        } else if (op.equals("density")) {
90            runDisplayDensity();
91        } else if (op.equals("overscan")) {
92            runDisplayOverscan();
93        } else if (op.equals("scaling")) {
94            runDisplayScaling();
95        } else if (op.equals("screen-capture")) {
96            runSetScreenCapture();
97        } else if (op.equals("dismiss-keyguard")) {
98            runDismissKeyguard();
99        } else {
100            showError("Error: unknown command '" + op + "'");
101            return;
102        }
103    }
104
105    private void runSetScreenCapture() throws Exception {
106        String userIdStr = nextArg();
107        String enableStr = nextArg();
108        int userId;
109        boolean disable;
110
111        try {
112            userId = Integer.parseInt(userIdStr);
113        } catch (NumberFormatException e) {
114            System.err.println("Error: bad number " + e);
115            return;
116        }
117
118        disable = !Boolean.parseBoolean(enableStr);
119
120        try {
121            mWm.setScreenCaptureDisabled(userId, disable);
122        } catch (RemoteException e) {
123            System.err.println("Error: Can't set screen capture " + e);
124        }
125    }
126
127    private void runDisplaySize() throws Exception {
128        String size = nextArg();
129        int w, h;
130        if (size == null) {
131            Point initialSize = new Point();
132            Point baseSize = new Point();
133            try {
134                mWm.getInitialDisplaySize(Display.DEFAULT_DISPLAY, initialSize);
135                mWm.getBaseDisplaySize(Display.DEFAULT_DISPLAY, baseSize);
136                System.out.println("Physical size: " + initialSize.x + "x" + initialSize.y);
137                if (!initialSize.equals(baseSize)) {
138                    System.out.println("Override size: " + baseSize.x + "x" + baseSize.y);
139                }
140            } catch (RemoteException e) {
141            }
142            return;
143        } else if ("reset".equals(size)) {
144            w = h = -1;
145        } else {
146            int div = size.indexOf('x');
147            if (div <= 0 || div >= (size.length()-1)) {
148                System.err.println("Error: bad size " + size);
149                return;
150            }
151            String wstr = size.substring(0, div);
152            String hstr = size.substring(div+1);
153            try {
154                w = parseDimension(wstr);
155                h = parseDimension(hstr);
156            } catch (NumberFormatException e) {
157                System.err.println("Error: bad number " + e);
158                return;
159            }
160        }
161
162        try {
163            if (w >= 0 && h >= 0) {
164                // TODO(multidisplay): For now Configuration only applies to main screen.
165                mWm.setForcedDisplaySize(Display.DEFAULT_DISPLAY, w, h);
166            } else {
167                mWm.clearForcedDisplaySize(Display.DEFAULT_DISPLAY);
168            }
169        } catch (RemoteException e) {
170        }
171    }
172
173    private void runDisplayDensity() throws Exception {
174        String densityStr = nextArg();
175        int density;
176        if (densityStr == null) {
177            try {
178                int initialDensity = mWm.getInitialDisplayDensity(Display.DEFAULT_DISPLAY);
179                int baseDensity = mWm.getBaseDisplayDensity(Display.DEFAULT_DISPLAY);
180                System.out.println("Physical density: " + initialDensity);
181                if (initialDensity != baseDensity) {
182                    System.out.println("Override density: " + baseDensity);
183                }
184            } catch (RemoteException e) {
185            }
186            return;
187        } else if ("reset".equals(densityStr)) {
188            density = -1;
189        } else {
190            try {
191                density = Integer.parseInt(densityStr);
192            } catch (NumberFormatException e) {
193                System.err.println("Error: bad number " + e);
194                return;
195            }
196            if (density < 72) {
197                System.err.println("Error: density must be >= 72");
198                return;
199            }
200        }
201
202        try {
203            if (density > 0) {
204                // TODO(multidisplay): For now Configuration only applies to main screen.
205                mWm.setForcedDisplayDensityForUser(Display.DEFAULT_DISPLAY, density,
206                        UserHandle.USER_CURRENT);
207            } else {
208                mWm.clearForcedDisplayDensityForUser(Display.DEFAULT_DISPLAY,
209                        UserHandle.USER_CURRENT);
210            }
211        } catch (RemoteException e) {
212        }
213    }
214
215    private void runDisplayOverscan() throws Exception {
216        String overscanStr = nextArgRequired();
217        Rect rect = new Rect();
218        if ("reset".equals(overscanStr)) {
219            rect.set(0, 0, 0, 0);
220        } else {
221            final Pattern FLATTENED_PATTERN = Pattern.compile(
222                    "(-?\\d+),(-?\\d+),(-?\\d+),(-?\\d+)");
223            Matcher matcher = FLATTENED_PATTERN.matcher(overscanStr);
224            if (!matcher.matches()) {
225                System.err.println("Error: bad rectangle arg: " + overscanStr);
226                return;
227            }
228            rect.left = Integer.parseInt(matcher.group(1));
229            rect.top = Integer.parseInt(matcher.group(2));
230            rect.right = Integer.parseInt(matcher.group(3));
231            rect.bottom = Integer.parseInt(matcher.group(4));
232        }
233
234        try {
235            mWm.setOverscan(Display.DEFAULT_DISPLAY, rect.left, rect.top, rect.right, rect.bottom);
236        } catch (RemoteException e) {
237        }
238    }
239
240    private void runDisplayScaling() throws Exception {
241        String scalingStr = nextArgRequired();
242        if ("auto".equals(scalingStr)) {
243            mWm.setForcedDisplayScalingMode(Display.DEFAULT_DISPLAY, 0);
244        } else if ("off".equals(scalingStr)) {
245            mWm.setForcedDisplayScalingMode(Display.DEFAULT_DISPLAY, 1);
246        } else {
247            System.err.println("Error: scaling must be 'auto' or 'off'");
248        }
249    }
250
251    private void runDismissKeyguard() throws Exception {
252        mWm.dismissKeyguard();
253    }
254
255    private int parseDimension(String s) throws NumberFormatException {
256        if (s.endsWith("px")) {
257            return Integer.parseInt(s.substring(0, s.length() - 2));
258        }
259        if (s.endsWith("dp")) {
260            int density;
261            try {
262                density = mWm.getBaseDisplayDensity(Display.DEFAULT_DISPLAY);
263            } catch (RemoteException e) {
264                density = DisplayMetrics.DENSITY_DEFAULT;
265            }
266            return Integer.parseInt(s.substring(0, s.length() - 2)) * density /
267                    DisplayMetrics.DENSITY_DEFAULT;
268        }
269        return Integer.parseInt(s);
270    }
271}

根据上述源码以wm size 为例，解析下源码：

1.wm 命令的逻辑非常的简单，它实际上是和 WindowManagerService 进行交互，通过 WMS 来修改屏幕相关的一些参数。

这里就不介绍完整的 wm 源码了，就以一个方法举例来看看 wm 的逻辑。这里就以 wm size 命令举例好了。

首先，看看 wm 命令的入口onRun()。

2.这里会初始化 mWm ，并且根据输入的参数，调用不同的方法，如果输入的是 size ，则会调用 runDisplaySize() 方法。

3.在 runDisplaySize() 方法中，会先判断 size 命令后面有没有跟其它参数，如果没有，则认为是一次查询操作，会将查询到的结果输出。

而如果是 reset 方法的话，就将 w 、h 这两个代表宽高的值，设置为 -1，最终会通过 mWm.clearForcedDisplaySize() 方法，将屏幕的 size 还原。

否者就从输入的参数中，通过 x 进行分割，拿到我们输入的宽高。最终通过 mWm.setForcedDisplaySize() 方法，将当前屏幕的 size 修改成我们输入的结果。

在设置size 的时候，还会通过 parseDimens() 方法，重新计算一下输入的尺寸。

4.从这里可以看出，它支持两个尺寸，px 和 dp ，如果如果不指定尺寸，则默认认为是 px 。

到这里就完成了一次通过 wm size 命令，修改设备屏幕参数的全过程

操作注意事项：